@contractkit/plugin-typescript 0.31.2 → 0.33.0

package/dist/ts-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ts-render.d.ts","sourceRoot":"","sources":["../src/ts-render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAA6B,MAAM,mBAAmB,CAAC;AAErF,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,2GAA2G,CAAC;AAE7I,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;sFAEsF;AACtF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvD;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,6HAA6H;AAC7H,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQzD;AAID;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,GAAE,cAAyB,GAAG,MAAM,CAoC9F;AAgDD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,EAAE,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,GAAE,cAAyB,GAAG,MAAM,CA2BlI;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,EAAE,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,GAAE,cAAyB,GAAG,MAAM,CA2BpI"}
+{"version":3,"file":"ts-render.d.ts","sourceRoot":"","sources":["../src/ts-render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAA6B,MAAM,mBAAmB,CAAC;AAErF,iFAAiF;AACjF,eAAO,MAAM,oBAAoB,2GAA2G,CAAC;AAE7I,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;sFAEsF;AACtF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvD;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,6HAA6H;AAC7H,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQzD;AAID;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,GAAE,cAAyB,GAAG,MAAM,CAoC9F;AAsDD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,EAAE,eAAe,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,GAAE,cAAyB,GAAG,MAAM,CA2BlI;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,EAAE,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,GAAE,cAAyB,GAAG,MAAM,CA2BpI"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractkit/plugin-typescript",
-  "version": "0.31.2",
+  "version": "0.33.0",
   "description": "ContractKit built-in plugin: TypeScript codegen (SDK clients, Koa routers, Zod schemas, plain types)",
   "license": "MIT",
   "author": {
@@ -27,7 +27,7 @@
     ".": "./dist/index.js"
   },
   "dependencies": {
-    "@contractkit/core": "0.26.1"
+    "@contractkit/core": "0.28.0"
   },
   "devDependencies": {
     "@repo/config-typescript": "0.1.0",

package/src/codegen-contract.ts

@@ -23,6 +23,8 @@ import {
 } from '@contractkit/core';
 import { escapeJsDocLines } from './ts-render.js';
 import type { TsRenderTarget } from './ts-render.js';
+import { DECIMAL_IMPORT, DECIMAL_PRELUDE_LINES } from './decimal-runtime.js';
+import { renderReviveFunctions, reviveFnName, DECIMAL_COERCE_DECL } from './codegen-revive.js';
 
 /**
  * Maps a ContractKit object mode to its Zod constructor name.
@@ -60,6 +62,13 @@ export interface ContractCodegenContext {
      * `generateContract`, whose Zod schemas are server-shaped by construction. Default `'client'`.
      */
     target?: TsRenderTarget;
+    /** Model names that carry a `decimal`, directly or transitively. */
+    modelsWithDecimal?: Set<string>;
+    /**
+     * Emit `reviveX()` hydration functions alongside the schemas. Set only for SDK type files: a
+     * server handler receives decimals already parsed by `_ZodDecimal`, so it has nothing to revive.
+     */
+    emitRevivers?: boolean;
 }
 
 // ─── Public entry point ────────────────────────────────────────────────────
@@ -142,6 +151,7 @@ export function generateContract(root: ContractRootNode, context?: ContractCodeg
     const needsBinary = rootNeedsScalar(root, 'binary');
     const needsDatetime = rootNeedsScalar(root, 'datetime');
     const needsJson = rootNeedsScalar(root, 'json');
+    const needsDecimal = rootNeedsScalar(root, 'decimal');
     const externalRefs = collectExternalRefs(root);
     const lines: string[] = [];
 
@@ -166,9 +176,14 @@ export function generateContract(root: ContractRootNode, context?: ContractCodeg
     if (needsDuration) luxonImports.push('Duration');
     if (needsInterval) luxonImports.push('Interval');
     if (luxonImports.length > 0) lines.push(`import { ${luxonImports.join(', ')} } from 'luxon';`);
+    if (needsDecimal) lines.push(DECIMAL_IMPORT);
     for (const ref of allExternalRefs) {
         const importPath = resolveImportPath(ref, context);
-        lines.push(`import { ${ref} } from '${importPath}';`);
+        // A cross-file model that carries a decimal contributes its reviver too — the local
+        // reviver calls it rather than re-deriving the other file's shape.
+        const names =
+            context?.emitRevivers && context.modelsWithDecimal?.has(ref) ? `${ref}, ${reviveFnName(ref)}` : ref;
+        lines.push(`import { ${names} } from '${importPath}';`);
     }
     lines.push('');
     if (needsBinary) {
@@ -184,21 +199,45 @@ export function generateContract(root: ContractRootNode, context?: ContractCodeg
             `const _ZodInterval = z.preprocess((val) => typeof val === 'string' ? Interval.fromISO(val) : val, z.custom<Interval>((val) => val instanceof Interval && val.isValid, { message: 'Must be an ISO 8601 interval' })).transform(val => val.toISO()!);`,
         );
     }
+    if (needsDecimal) {
+        lines.push(...DECIMAL_PRELUDE_LINES);
+    }
     if (needsJson) {
         lines.push(`type _JsonValue = string | number | boolean | null | _JsonValue[] | { [key: string]: _JsonValue };`);
         lines.push(
             `const _ZodJson: z.ZodType<_JsonValue> = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(_ZodJson), z.record(z.string(), _ZodJson)]));`,
         );
     }
-    if (needsBinary || needsDatetime || needsInterval || needsJson) lines.push('');
+    if (needsBinary || needsDatetime || needsInterval || needsDecimal || needsJson) lines.push('');
 
     const modelsWithWriteonly = new Set(root.models.filter(m => m.fields.some(f => f.visibility === 'writeonly')).map(m => m.name));
     const modelMap = new Map(root.models.map(m => [m.name, m]));
 
+    const reviveOpts =
+        context?.emitRevivers && context.modelsWithDecimal
+            ? { modelsWithDecimal: context.modelsWithDecimal, modelsWithOutput: allModelsWithOutput, modelMap }
+            : undefined;
+
+    const bodyLines: string[] = [];
     for (const model of topoSortModels(root.models)) {
-        lines.push(...generateModel(model, context?.currentOutPath, allModelsWithInput, modelsWithWriteonly, modelMap, allModelsWithOutput));
+        bodyLines.push(...generateModel(model, context?.currentOutPath, allModelsWithInput, modelsWithWriteonly, modelMap, allModelsWithOutput));
+        if (reviveOpts) {
+            const revivers = renderReviveFunctions(model, reviveOpts);
+            if (revivers.length > 0) {
+                bodyLines.push('');
+                bodyLines.push(...revivers);
+            }
+        }
+        bodyLines.push('');
+    }
+
+    // Decided from the emitted revivers rather than from a predicate over the AST, so the
+    // declaration and its uses cannot drift apart and leave an unused local behind.
+    if (bodyLines.some(l => l.includes('__dec('))) {
+        lines.push(...DECIMAL_COERCE_DECL);
         lines.push('');
     }
+    lines.push(...bodyLines);
 
     return lines.join('\n');
 }
@@ -631,6 +670,22 @@ function renderScalar(s: ScalarTypeNode): string {
             if (s.max !== undefined) inner += `.max(${s.max}n)`;
             return `z.preprocess((val) => typeof val === 'string' ? BigInt(val.replace(/n$/, '')) : val, ${inner})`;
         }
+        case 'decimal': {
+            // Deliberately no output `.transform()`: `isRevalidatable` in codegen-operation treats
+            // every scalar as idempotent under re-parse, which `server.validateResponses` relies on.
+            // Preprocess passes an already-`Decimal` value straight through, so parse(parse(x)) is
+            // stable. Modelling this on `_ZodInterval` — which does transform — would break that.
+            const checks: string[] = [];
+            if (s.scale !== undefined) checks.push(`v.decimalPlaces() <= ${s.scale}`);
+            if (s.min !== undefined) checks.push(`v.gte('${escapeString(String(s.min))}')`);
+            if (s.max !== undefined) checks.push(`v.lte('${escapeString(String(s.max))}')`);
+            if (checks.length === 0) return '_ZodDecimal';
+            const messageParts: string[] = [];
+            if (s.scale !== undefined) messageParts.push(`at most ${s.scale} decimal place${s.scale === 1 ? '' : 's'}`);
+            if (s.min !== undefined) messageParts.push(`at least ${s.min}`);
+            if (s.max !== undefined) messageParts.push(`at most ${s.max}`);
+            return `_ZodDecimal.refine((v) => ${checks.join(' && ')}, { message: 'Must be ${escapeString(messageParts.join(', '))}' })`;
+        }
         case 'boolean':
             return `z.preprocess((v) => v === 'true' ? true : v === 'false' ? false : v, z.boolean())`;
         case 'date': {

package/src/codegen-mcp.ts

@@ -3,6 +3,7 @@ import { resolveModifiers, emittedResponses } from '@contractkit/core';
 import { renderType, renderInputType, pascalToDotCase } from './codegen-contract.js';
 import { inferService, deriveModulePath, buildArgs, deriveBaseName } from './codegen-operation.js';
 import { quoteKey, escapeSingleQuoted } from './ts-render.js';
+import { DECIMAL_IMPORT, DECIMAL_PRELUDE_LINES } from './decimal-runtime.js';
 import { basename, dirname, relative } from 'node:path';
 
 // ─── Options ────────────────────────────────────────────────────────────────
@@ -289,6 +290,9 @@ function scalarHelperLines(body: string): string[] {
             `const _ZodDatetime = z.preprocess((val) => typeof val === 'string' ? DateTime.fromISO(val) : val, z.custom<DateTime>((val) => val instanceof DateTime && val.isValid, { message: 'Must be in ISO 8601 format' }));`,
         );
     }
+    if (body.includes('_ZodDecimal')) {
+        lines.push(...DECIMAL_PRELUDE_LINES);
+    }
     if (body.includes('_ZodInterval')) {
         lines.push(
             `const _ZodInterval = z.preprocess((val) => typeof val === 'string' ? Interval.fromISO(val) : val, z.custom<Interval>((val) => val instanceof Interval && val.isValid, { message: 'Must be an ISO 8601 interval' })).transform(val => val.toISO()!);`,
@@ -430,6 +434,7 @@ export function generateMcpFile(root: OpRootNode, options: McpCodegenOptions = {
     if (/\bInterval\b/.test(bodyWithHelpers)) luxon.push('Interval');
     if (/\bDuration\b/.test(bodyWithHelpers)) luxon.push('Duration');
     if (luxon.length > 0) imports.push(`import { ${luxon.join(', ')} } from 'luxon';`);
+    if (/\bDecimal\b/.test(bodyWithHelpers)) imports.push(DECIMAL_IMPORT);
 
     imports.push(`import type { CallToolResult, Tool } from '@modelcontextprotocol/sdk/types.js';`);
     imports.push(`import type { McpToolHandler, McpToolHandlerMap, McpToolContext } from '@maroonedsoftware/mcp';`);

package/src/codegen-operation.ts

@@ -18,6 +18,7 @@ import {
     modeToWrapper,
 } from './codegen-contract.js';
 import { renderOutputTsType, quoteKey, headerNameToProperty, escapeJsDocLines, escapeSingleQuoted } from './ts-render.js';
+import { DECIMAL_IMPORT, DECIMAL_PRELUDE_LINES } from './decimal-runtime.js';
 import { basename, dirname, relative } from 'path';
 
 // ─── Content-type helpers ──────────────────────────────────────────────────
@@ -50,7 +51,15 @@ export function bodyTypesStructurallyEqual(a: ContractTypeNode, b: ContractTypeN
     switch (a.kind) {
         case 'scalar': {
             const bb = b as typeof a;
-            return a.name === bb.name && a.min === bb.min && a.max === bb.max && a.len === bb.len && a.regex === bb.regex && a.format === bb.format;
+            return (
+                a.name === bb.name &&
+                a.min === bb.min &&
+                a.max === bb.max &&
+                a.len === bb.len &&
+                a.scale === bb.scale &&
+                a.regex === bb.regex &&
+                a.format === bb.format
+            );
         }
         case 'array': {
             const bb = b as typeof a;
@@ -132,6 +141,18 @@ export interface OpCodegenOptions {
      * from the generated router entirely.
      */
     includeInternal?: boolean;
+    /**
+     * Re-parse the service result through its declared response schema before writing `ctx.body`,
+     * and write the parsed value. Requires the type file to hold Zod schemas (`server.zod`) —
+     * plain interfaces are types, with no runtime schema value to validate against. Default false.
+     */
+    validateResponses?: boolean;
+    /**
+     * Set of model names whose schema applies a `format(...)` key transform, directly or through a
+     * referenced model. Response bodies touching one are left unvalidated: the service returns the
+     * post-transform shape, which the schema itself cannot re-parse.
+     */
+    modelsWithTransform?: Set<string>;
 }
 
 /**
@@ -185,6 +206,9 @@ export function generateOp(root: OpRootNode, options: OpCodegenOptions = {}): st
             `const _ZodDatetime = z.preprocess((val) => typeof val === 'string' ? DateTime.fromISO(val) : val, z.custom<DateTime>((val) => val instanceof DateTime && val.isValid, { message: 'Must be in ISO 8601 format' }));`,
         );
     }
+    if (references('_ZodDecimal')) {
+        helpers.push(...DECIMAL_PRELUDE_LINES);
+    }
     if (references('_ZodInterval')) {
         helpers.push(
             `const _ZodInterval = z.preprocess((val) => typeof val === 'string' ? Interval.fromISO(val) : val, z.custom<Interval>((val) => val instanceof Interval && val.isValid, { message: 'Must be an ISO 8601 interval' })).transform(val => val.toISO()!);`,
@@ -212,13 +236,20 @@ export function generateOp(root: OpRootNode, options: OpCodegenOptions = {}): st
         body.push(`import { ${koaImports.join(', ')} } from '@maroonedsoftware/koa';`);
     }
 
-    for (const svc of services) {
+    // Services and model names come from the AST, which over-approximates two ways: a model with an
+    // Input/Output variant contributes its base name even when only the variant is ever annotated,
+    // and `collectServices`/`collectTypes` walk every operation including the `internal` ones
+    // `includeInternal: false` drops. Filtering through `uses` — the same gate every symbol above
+    // goes through — keeps the import list to what the handlers actually reference, so generated
+    // code does not trip `noUnusedLocals` in the consuming project.
+    for (const svc of services.filter(uses)) {
         const modulePath = root.services?.[svc] ?? root.meta[svc] ?? deriveModulePath(svc, options.servicePathTemplate);
         body.push(`import { ${svc} } from '${modulePath}';`);
     }
 
-    if (types.length > 0) {
-        body.push(...generateTypeImports(types, root.file, options));
+    const usedTypes = types.filter(uses);
+    if (usedTypes.length > 0) {
+        body.push(...generateTypeImports(usedTypes, root.file, options));
     }
 
     // luxon is needed for date/time/datetime (DateTime), duration (Duration) and interval (Interval);
@@ -228,6 +259,12 @@ export function generateOp(root: OpRootNode, options: OpCodegenOptions = {}): st
         body.push(`import { ${luxonImports.join(', ')} } from 'luxon';`);
     }
 
+    // Same `uses` gate: `Decimal` appears in the `_ZodDecimal` helper and in service-result
+    // annotations via `serverTsScalar`, and the helper text is folded into `generated` above.
+    if (uses('Decimal')) {
+        body.push(DECIMAL_IMPORT);
+    }
+
     if (uses('parseAndValidate')) {
         body.push(`import { parseAndValidate } from '@maroonedsoftware/zod';`);
     }
@@ -383,9 +420,12 @@ function generateSingleStatusResult(
     const hasRespHeaders = respHeaders.length > 0;
     const headersAnnotation = hasRespHeaders ? renderHeadersAnnotation(respHeaders, options.modelsWithOutput) : '';
 
+    let bodySchema: string | undefined;
+
     if (bodies.length === 1) {
         const { annotation, prelude } = formatTypeAnnotation(bodies[0]!.bodyType, options.modelsWithOutput);
         if (prelude) lines.push(`    ${prelude}`);
+        bodySchema = responseBodySchema(bodies[0]!.bodyType, options, prelude ? 'resultType' : undefined);
         lines.push(`    const service = ctx.container.get(${className});`);
         if (hasRespHeaders) {
             lines.push(`    const result: { body: ${annotation}; headers: ${headersAnnotation} } = ${call};`);
@@ -393,7 +433,9 @@ function generateSingleStatusResult(
             lines.push(`    const result: ${annotation} = ${call};`);
         }
     } else if (bodies.length > 1) {
-        const { members, preludes } = renderResponseMembers(resp!, options, { includeStatus: false, varPrefix: 'result' });
+        const rendered = renderResponseMembers(resp!, options, { includeStatus: false, varPrefix: 'result' });
+        const { members, preludes } = rendered;
+        bodySchema = rendered.bodySchema;
         for (const prelude of preludes) lines.push(`    ${prelude}`);
         lines.push(`    const service = ctx.container.get(${className});`);
         lines.push(`    const result: ${members.join(' | ')} = ${call};`);
@@ -414,10 +456,10 @@ function generateSingleStatusResult(
 
     if (bodies.length === 1) {
         lines.push(`    ctx.type = '${bodies[0]!.contentType}';`);
-        lines.push(`    ctx.body = ${hasRespHeaders ? 'result.body' : 'result'};`);
+        lines.push(`    ctx.body = ${responseBodyExpr(hasRespHeaders ? 'result.body' : 'result', bodySchema)};`);
     } else if (bodies.length > 1) {
         lines.push(`    ctx.type = result.contentType;`);
-        lines.push(`    ctx.body = result.body;`);
+        lines.push(`    ctx.body = ${responseBodyExpr('result.body', bodySchema)};`);
     }
 
     return lines;
@@ -433,10 +475,13 @@ function generateMultiStatusResult(emitted: OpResponseNode[], className: string,
     const members: string[] = [];
     const preludes: string[] = [];
 
+    const bodySchemas = new Map<number, string | undefined>();
+
     for (const resp of emitted) {
         const rendered = renderResponseMembers(resp, options, { includeStatus: true, varPrefix: `result${resp.statusCode}` });
         members.push(...rendered.members);
         preludes.push(...rendered.preludes);
+        bodySchemas.set(resp.statusCode, rendered.bodySchema);
     }
 
     for (const prelude of preludes) lines.push(`    ${prelude}`);
@@ -452,7 +497,7 @@ function generateMultiStatusResult(emitted: OpResponseNode[], className: string,
         lines.push(...headerSetLines(resp.headers ?? [], '            '));
         if (resp.bodies.length > 0) {
             lines.push(`            ctx.type = result.contentType;`);
-            lines.push(`            ctx.body = result.body;`);
+            lines.push(`            ctx.body = ${responseBodyExpr('result.body', bodySchemas.get(resp.statusCode))};`);
         }
         lines.push(`            break;`);
     }
@@ -473,7 +518,7 @@ function renderResponseMembers(
     resp: OpResponseNode,
     options: OpCodegenOptions,
     opts: { includeStatus: boolean; varPrefix: string },
-): { members: string[]; preludes: string[] } {
+): { members: string[]; preludes: string[]; bodySchema?: string } {
     const bodies = resp.bodies;
     const headers = resp.headers ?? [];
     const leading = opts.includeStatus ? [`status: ${resp.statusCode}`] : [];
@@ -488,10 +533,18 @@ function renderResponseMembers(
     if (uniform) {
         const { annotation, prelude } = formatTypeAnnotation(bodies[0]!.bodyType, options.modelsWithOutput, `${opts.varPrefix}Type`);
         if (prelude) preludes.push(prelude);
+        const bodySchema = responseBodySchema(bodies[0]!.bodyType, options, prelude ? `${opts.varPrefix}Type` : undefined);
         const contentType = bodies.map(b => `'${b.contentType}'`).join(' | ');
-        return { members: [`{ ${[...leading, `contentType: ${contentType}`, `body: ${annotation}`, ...trailing].join('; ')} }`], preludes };
+        return {
+            members: [`{ ${[...leading, `contentType: ${contentType}`, `body: ${annotation}`, ...trailing].join('; ')} }`],
+            preludes,
+            bodySchema,
+        };
     }
 
+    // One member per mime: `contentType` and `body` stay correlated, so validating would need a
+    // second switch on `result.contentType` nested inside the status switch. Left unvalidated —
+    // note the absent `bodySchema` in the return below.
     const members = bodies.map((b, i) => {
         const { annotation, prelude } = formatTypeAnnotation(b.bodyType, options.modelsWithOutput, `${opts.varPrefix}Type${i}`);
         if (prelude) preludes.push(prelude);
@@ -610,6 +663,10 @@ function serverTsScalar(name: ScalarTypeNode['name']): string {
             return 'number';
         case 'bigint':
             return 'bigint';
+        case 'decimal':
+            // Unlike the date scalars, this matches `renderTsScalar`'s wire view — `_ZodDecimal`
+            // has no output transform, so `z.infer` is a `Decimal` on both sides.
+            return 'Decimal';
         case 'boolean':
             return 'boolean';
         case 'date':
@@ -660,6 +717,71 @@ function formatTypeAnnotation(bodyType: ContractTypeNode, modelsWithOutput?: Set
     };
 }
 
+/**
+ * Whether a response body can be soundly re-parsed through the schema `renderType` emits for it.
+ *
+ * False for anything transitively touching a model with a `format(...)` key transform — the service
+ * returns the post-transform value while the schema expects the pre-transform one — and for an
+ * intersection outside `renderIntersection`'s `.extend()` fast path, where `.and()` of two strict
+ * objects rejects every value because each side sees the other's keys as unrecognized.
+ */
+function isRevalidatable(type: ContractTypeNode, modelsWithOutput?: Set<string>, modelsWithTransform?: Set<string>): boolean {
+    const rec = (t: ContractTypeNode): boolean => isRevalidatable(t, modelsWithOutput, modelsWithTransform);
+    switch (type.kind) {
+        case 'ref':
+            return !modelsWithOutput?.has(type.name) && !modelsWithTransform?.has(type.name);
+        case 'array':
+            return rec(type.item);
+        case 'tuple':
+            return type.items.every(rec);
+        case 'record':
+            return rec(type.key) && rec(type.value);
+        case 'intersection': {
+            // Mirrors renderIntersection: a lone member renders as itself, `ref & (ref|object)*`
+            // renders as an `.extend()` chain, and anything else falls back to `.and()`.
+            const [first, ...rest] = type.members;
+            if (!first) return true;
+            if (rest.length === 0) return rec(first);
+            const usesExtendChain = first.kind === 'ref' && rest.every(m => m.kind === 'ref' || m.kind === 'inlineObject');
+            return usesExtendChain && type.members.every(rec);
+        }
+        case 'union':
+        case 'discriminatedUnion':
+            return type.members.every(rec);
+        case 'inlineObject':
+            return type.fields.every(f => rec(f.type));
+        case 'lazy':
+            return rec(type.inner);
+        default:
+            // scalar, enum, literal — identity or idempotent under re-parse
+            return true;
+    }
+}
+
+/**
+ * The runtime schema a handler validates a response body against, or `undefined` when the body
+ * cannot be soundly re-parsed and validation must be skipped.
+ *
+ * @param preludeVar The schema const {@link formatTypeAnnotation} already emitted for this body
+ *   (complex types only — `undefined` when it returned no prelude). Reusing it keeps a large object
+ *   literal from appearing twice in the same handler.
+ */
+function responseBodySchema(bodyType: ContractTypeNode, options: OpCodegenOptions, preludeVar: string | undefined): string | undefined {
+    if (!options.validateResponses) return undefined;
+    if (!isRevalidatable(bodyType, options.modelsWithOutput, options.modelsWithTransform)) return undefined;
+    return preludeVar ?? renderType(bodyType);
+}
+
+/**
+ * The `ctx.body = ...` right-hand side for a response body: the raw result expression, or a
+ * `parseAndValidate` of it. The `500` is deliberate — a service returning a shape its own contract
+ * rejects is a server fault, not a client one, and `@maroonedsoftware/zod` routes the field-level
+ * detail to `internalDetails` (log-only) rather than the response body at 5xx.
+ */
+function responseBodyExpr(value: string, schema: string | undefined): string {
+    return schema ? `await parseAndValidate(${value}, ${schema}, 500)` : value;
+}
+
 function generateParamValidation(
     source: ParamSource | undefined,
     ctxExpr: string,

package/src/codegen-plain-types.ts

@@ -12,6 +12,8 @@ import {
 } from './codegen-contract.js';
 import { renderTsType, renderInputTsType, renderOutputTsType, quoteKey, escapeJsDocLines, JSON_VALUE_TYPE_DECL } from './ts-render.js';
 import type { TsRenderTarget } from './ts-render.js';
+import { DECIMAL_IMPORT, DECIMAL_CONFIG_LINE } from './decimal-runtime.js';
+import { renderReviveFunctions, reviveFnName, DECIMAL_COERCE_DECL } from './codegen-revive.js';
 
 // ─── Public entry point ────────────────────────────────────────────────────
 
@@ -44,10 +46,20 @@ export function generatePlainTypes(root: ContractRootNode, context?: ContractCod
     const externalOutputRefs = allModelsWithOutput.size > 0 ? collectExternalOutputRefs(root, allModelsWithOutput) : [];
     const allExternalRefs = [...new Set([...externalRefs, ...externalInputRefs, ...externalOutputRefs])].sort();
 
-    // Type-only imports for external references
+    // Not `import type`: `renderTsScalar` maps `decimal` to `Decimal` in this mode too, so the class
+    // is a real runtime dependency of any consumer holding one — same position as in
+    // `generateContract`, which emits it ahead of the external model refs.
+    const needsDecimal = rootNeedsScalar(root, 'decimal') || (context?.emitRevivers && context.modelsWithDecimal ? root.models.some(m => context.modelsWithDecimal!.has(m.name)) : false);
+    if (needsDecimal) lines.push(DECIMAL_IMPORT);
+
+    // Type-only imports for external references. A cross-file model carrying a decimal also
+    // contributes its reviver, which is a value and so needs a second, non-type import.
     for (const ref of allExternalRefs) {
         const importPath = resolveImportPath(ref, context);
         lines.push(`import type { ${ref} } from '${importPath}';`);
+        if (context?.emitRevivers && context.modelsWithDecimal?.has(ref)) {
+            lines.push(`import { ${reviveFnName(ref)} } from '${importPath}';`);
+        }
     }
     if (allExternalRefs.length > 0) lines.push('');
 
@@ -62,10 +74,38 @@ export function generatePlainTypes(root: ContractRootNode, context?: ContractCod
 
     const modelMap = new Map(root.models.map(m => [m.name, m]));
 
+    const reviveOpts =
+        context?.emitRevivers && context.modelsWithDecimal
+            ? { modelsWithDecimal: context.modelsWithDecimal, modelsWithOutput: allModelsWithOutput, modelMap }
+            : undefined;
+
+    const bodyLines: string[] = [];
     for (const model of topoSortModels(root.models)) {
-        lines.push(...generateModel(model, target, context?.currentOutPath, allModelsWithInput, allModelsWithOutput, modelMap));
+        bodyLines.push(...generateModel(model, target, context?.currentOutPath, allModelsWithInput, allModelsWithOutput, modelMap));
+        if (reviveOpts) {
+            const revivers = renderReviveFunctions(model, reviveOpts);
+            if (revivers.length > 0) {
+                bodyLines.push('');
+                bodyLines.push(...revivers);
+            }
+        }
+        bodyLines.push('');
+    }
+
+    // Global decimal.js config belongs in any file holding a `Decimal`: there is no Zod schema in
+    // this mode, but `String(value)` and `JSON.stringify` still have to stay out of exponential form.
+    if (needsDecimal) {
+        lines.push('');
+        lines.push(DECIMAL_CONFIG_LINE);
+    }
+
+    // Same rule as in `generateContract`: the helper is emitted only if the revivers actually
+    // reference it, so the two cannot drift and trip `noUnusedLocals`.
+    if (bodyLines.some(l => l.includes('__dec('))) {
+        lines.push(...DECIMAL_COERCE_DECL);
         lines.push('');
     }
+    lines.push(...bodyLines);
 
     return lines.join('\n');
 }