@contractkit/plugin-typescript 0.32.0 → 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.32.0",
+  "version": "0.33.0",
   "description": "ContractKit built-in plugin: TypeScript codegen (SDK clients, Koa routers, Zod schemas, plain types)",
   "license": "MIT",
   "author": {
@@ -27,11 +27,11 @@
     ".": "./dist/index.js"
   },
   "dependencies": {
-    "@contractkit/core": "0.27.0"
+    "@contractkit/core": "0.28.0"
   },
   "devDependencies": {
-    "@repo/config-eslint": "0.3.1",
-    "@repo/config-typescript": "0.1.0"
+    "@repo/config-typescript": "0.1.0",
+    "@repo/config-eslint": "0.3.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --sourcemap --dts && tsc --emitDeclarationOnly --declaration",

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;
@@ -197,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()!);`,
@@ -247,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';`);
     }
@@ -645,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':

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');
 }

package/src/codegen-revive.ts

@@ -0,0 +1,304 @@
+import type { ContractTypeNode, FieldNode, ModelNode } from '@contractkit/core';
+
+/**
+ * Emitters for the `reviveX` functions that rehydrate `decimal` fields in an SDK response.
+ *
+ * A decimal arrives as a quoted JSON string, but the generated types say `Decimal`, so something
+ * has to construct one. The SDK cannot do it the way `bigint` does — `bigIntReviver` works only
+ * because bigint invented a tagged `"123n"` wire encoding, and `"10.50"` is indistinguishable from
+ * an ordinary string without knowing the schema. Nor can it re-parse the response through the Zod
+ * schema: `XOutput` is a `z.output<>` type alias with no runtime value behind it, and models
+ * default to `z.strictObject`, so any field the server added would throw in every deployed client.
+ *
+ * So the knowledge lives in generated code instead: one function per model that walks to the field
+ * positions a decimal can occupy and converts in place. Mutating rather than rebuilding keeps the
+ * cost proportional to the number of decimal fields, and preserves unknown server-added keys —
+ * the forward compatibility a strict re-parse would destroy.
+ *
+ * Emitted from the AST, so zod mode and plain-types mode produce identical runtime behaviour.
+ */
+
+export interface ReviveCodegenOptions {
+    /** Models that carry a decimal, directly or transitively. Only these get a reviver. */
+    modelsWithDecimal: Set<string>;
+    /** Models with an `Output` variant, which need a second reviver keyed by the output casing. */
+    modelsWithOutput?: Set<string>;
+    /** Every model in scope, for resolving discriminated-union members to their literal tag. */
+    modelMap?: Map<string, ModelNode>;
+}
+
+/** The per-file coercion helper. Emitted once in any file that declares a reviver. */
+export const DECIMAL_COERCE_DECL = [
+    `const __dec = (v: unknown, path: string): Decimal => {`,
+    `    if (typeof v !== 'string') {`,
+    `        throw new TypeError(\`ContractKit: expected a decimal string at '\${path}', received \${typeof v} — decimals must be sent as quoted JSON strings.\`);`,
+    `    }`,
+    `    try {`,
+    `        return new Decimal(v);`,
+    `    } catch {`,
+    `        throw new TypeError(\`ContractKit: '\${v}' at '\${path}' is not a valid decimal.\`);`,
+    `    }`,
+    `};`,
+];
+
+/** `reviveInvoice` / `reviveInvoiceOutput`. */
+export function reviveFnName(model: string, variant: 'base' | 'output' = 'base'): string {
+    return `revive${model}${variant === 'output' ? 'Output' : ''}`;
+}
+
+function applyCase(name: string, caseTransform: 'camel' | 'snake' | 'pascal' | undefined): string {
+    if (!caseTransform || caseTransform === 'camel') return name;
+    if (caseTransform === 'snake') return name.replace(/[A-Z]/g, c => `_${c.toLowerCase()}`);
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+/** Whether a type reaches a decimal, following refs through `modelsWithDecimal`. */
+export function typeReachesDecimal(type: ContractTypeNode, opts: ReviveCodegenOptions): boolean {
+    switch (type.kind) {
+        case 'scalar':
+            return type.name === 'decimal';
+        case 'ref':
+            return opts.modelsWithDecimal.has(type.name);
+        case 'array':
+            return typeReachesDecimal(type.item, opts);
+        case 'lazy':
+            return typeReachesDecimal(type.inner, opts);
+        case 'tuple':
+            return type.items.some(t => typeReachesDecimal(t, opts));
+        case 'record':
+            return typeReachesDecimal(type.value, opts);
+        case 'union':
+        case 'discriminatedUnion':
+        case 'intersection':
+            return type.members.some(t => typeReachesDecimal(t, opts));
+        case 'inlineObject':
+            return type.fields.some(f => typeReachesDecimal(f.type, opts));
+        default:
+            return false;
+    }
+}
+
+/** Fresh local names, so nested loops in one function body cannot collide. */
+class Scope {
+    private n = 0;
+    next(prefix: string): string {
+        return `__${prefix}${this.n++}`;
+    }
+}
+
+/**
+ * Statements that hydrate `slot` — an assignable expression — in place.
+ *
+ * `path` is threaded purely for the error message; it is what tells a consumer *which* field of a
+ * large response was malformed.
+ */
+function emit(slot: string, type: ContractTypeNode, path: string, opts: ReviveCodegenOptions, scope: Scope, variant: 'base' | 'output'): string[] {
+    switch (type.kind) {
+        case 'scalar':
+            return type.name === 'decimal' ? [`${slot} = __dec(${slot}, '${path}');`] : [];
+
+        case 'ref':
+            return opts.modelsWithDecimal.has(type.name) ? [`${reviveRefName(type.name, opts, variant)}(${slot} as never);`] : [];
+
+        case 'lazy':
+            return emit(slot, type.inner, path, opts, scope, variant);
+
+        case 'array': {
+            if (!typeReachesDecimal(type.item, opts)) return [];
+            const arr = scope.next('a');
+            const i = scope.next('i');
+            const inner = emit(`${arr}[${i}]`, type.item, `${path}[]`, opts, scope, variant);
+            return [
+                `{`,
+                `    const ${arr} = ${slot} as unknown[];`,
+                `    for (let ${i} = 0; ${i} < ${arr}.length; ${i}++) {`,
+                ...inner.map(l => `        ${l}`),
+                `    }`,
+                `}`,
+            ];
+        }
+
+        case 'tuple': {
+            const items = type.items.flatMap((t, idx) =>
+                typeReachesDecimal(t, opts) ? emit(`(${slot} as unknown[])[${idx}]`, t, `${path}[${idx}]`, opts, scope, variant) : [],
+            );
+            return items;
+        }
+
+        case 'record': {
+            if (!typeReachesDecimal(type.value, opts)) return [];
+            const rec = scope.next('r');
+            const k = scope.next('k');
+            const inner = emit(`${rec}[${k}]`, type.value, `${path}{}`, opts, scope, variant);
+            return [
+                `{`,
+                `    const ${rec} = ${slot} as Record<string, unknown>;`,
+                `    for (const ${k} of Object.keys(${rec})) {`,
+                ...inner.map(l => `        ${l}`),
+                `    }`,
+                `}`,
+            ];
+        }
+
+        case 'inlineObject': {
+            const relevant = type.fields.filter(f => typeReachesDecimal(f.type, opts));
+            if (relevant.length === 0) return [];
+            const obj = scope.next('o');
+            const body = relevant.flatMap(f => fieldStatements(obj, f, path, opts, scope, variant, undefined));
+            return [`{`, `    const ${obj} = ${slot} as Record<string, unknown>;`, ...body.map(l => `    ${l}`), `}`];
+        }
+
+        case 'intersection':
+            return type.members.flatMap(m => emit(slot, m, path, opts, scope, variant));
+
+        case 'union': {
+            // `validateDecimal` rejects a decimal in a union with more than one non-null member, so
+            // anything reaching here is `T | null`: hydrate the single real member behind a guard.
+            const real = type.members.filter(m => !(m.kind === 'scalar' && m.name === 'null'));
+            const target = real.find(m => typeReachesDecimal(m, opts));
+            if (!target) return [];
+            const inner = emit(slot, target, path, opts, scope, variant);
+            return [`if (${slot} != null) {`, ...inner.map(l => `    ${l}`), `}`];
+        }
+
+        case 'discriminatedUnion': {
+            const branches: string[] = [];
+            const disc = scope.next('d');
+            for (const member of type.members) {
+                if (!typeReachesDecimal(member, opts)) continue;
+                const tag = discriminatorTag(member, type.discriminator, opts);
+                const inner = emit(slot, member, path, opts, scope, variant);
+                if (inner.length === 0) continue;
+                if (tag === undefined) {
+                    // No resolvable literal: hydrating unconditionally could apply the wrong arm's
+                    // shape, so skip it rather than risk corrupting a sibling member's field.
+                    continue;
+                }
+                branches.push(`    if (${disc} === ${JSON.stringify(tag)}) {`, ...inner.map(l => `        ${l}`), `    }`);
+            }
+            if (branches.length === 0) return [];
+            return [`{`, `    const ${disc} = (${slot} as Record<string, unknown>)[${JSON.stringify(type.discriminator)}];`, ...branches, `}`];
+        }
+
+        default:
+            return [];
+    }
+}
+
+/** The literal value that selects `member` in a discriminated union, when it can be resolved. */
+function discriminatorTag(member: ContractTypeNode, discriminator: string, opts: ReviveCodegenOptions): string | number | boolean | undefined {
+    const fields: FieldNode[] | undefined =
+        member.kind === 'inlineObject' ? member.fields : member.kind === 'ref' ? opts.modelMap?.get(member.name)?.fields : undefined;
+    const field = fields?.find(f => f.name === discriminator);
+    if (field?.type.kind === 'literal') return field.type.value;
+    // A single-valued enum is the other way a discriminator gets written.
+    if (field?.type.kind === 'enum' && field.type.values.length === 1) return field.type.values[0];
+    return undefined;
+}
+
+/** Statements for one field of an object held in `objVar`. */
+function fieldStatements(
+    objVar: string,
+    field: FieldNode,
+    path: string,
+    opts: ReviveCodegenOptions,
+    scope: Scope,
+    variant: 'base' | 'output',
+    outputCase: 'camel' | 'snake' | 'pascal' | undefined,
+): string[] {
+    const key = variant === 'output' ? applyCase(field.name, outputCase) : field.name;
+    const slot = `${objVar}[${JSON.stringify(key)}]`;
+    const inner = emit(slot, field.type, `${path}.${key}`, opts, scope, variant);
+    if (inner.length === 0) return [];
+    // A union already emits its own null guard; adding a second would just nest.
+    if (field.type.kind === 'union') return inner;
+    if (field.optional || field.nullable) {
+        return [`if (${slot} != null) {`, ...inner.map(l => `    ${l}`), `}`];
+    }
+    return inner;
+}
+
+/**
+ * Pick the reviver for a referenced model.
+ *
+ * Mirrors `renderOutputTsType`: inside an output reviver, a referenced model uses its *own* output
+ * reviver only if it has one. `computeModelsWithOutput` propagates referrer→referenced, so a child
+ * of a transformed parent is not itself transformed and keeps camelCase keys.
+ */
+function reviveRefName(name: string, opts: ReviveCodegenOptions, variant: 'base' | 'output'): string {
+    if (variant === 'output' && opts.modelsWithOutput?.has(name)) return reviveFnName(name, 'output');
+    return reviveFnName(name, 'base');
+}
+
+/**
+ * A standalone reviver for an arbitrary type node — used for a response body that is not a plain
+ * model reference (an inline object, a record, a tuple), where there is no `reviveX` to call.
+ *
+ * Returns `null` when the type holds no decimal, so the caller emits nothing at all.
+ */
+export function renderInlineReviver(
+    fnName: string,
+    tsType: string,
+    type: ContractTypeNode,
+    opts: ReviveCodegenOptions,
+    variant: 'base' | 'output' = 'output',
+): string[] | null {
+    if (!typeReachesDecimal(type, opts)) return null;
+    const scope = new Scope();
+    const body = emit('__v[0]', type, fnName.replace(/^__revive/, ''), opts, scope, variant);
+    if (body.length === 0) return null;
+    return [
+        `/** Rehydrates the \`decimal\` fields of one response body. Mutates and returns \`raw\`. */`,
+        `function ${fnName}(raw: ${tsType}): ${tsType} {`,
+        `    const __v = [raw] as unknown[];`,
+        ...body.map(l => `    ${l}`),
+        `    return __v[0] as ${tsType};`,
+        `}`,
+    ];
+}
+
+/** The `reviveX` (and `reviveXOutput`) declarations for one model, or `[]` if it holds no decimal. */
+export function renderReviveFunctions(model: ModelNode, opts: ReviveCodegenOptions): string[] {
+    if (!opts.modelsWithDecimal.has(model.name)) return [];
+    const lines = renderOne(model, opts, 'base');
+    if (opts.modelsWithOutput?.has(model.name)) {
+        lines.push('');
+        lines.push(...renderOne(model, opts, 'output'));
+    }
+    return lines;
+}
+
+function renderOne(model: ModelNode, opts: ReviveCodegenOptions, variant: 'base' | 'output'): string[] {
+    const scope = new Scope();
+    const typeName = `${model.name}${variant === 'output' ? 'Output' : ''}`;
+    const fnName = reviveFnName(model.name, variant);
+
+    // A type-alias model has no fields — hydrate the aliased type as a whole.
+    if (model.type) {
+        const body = emit('__v[0]', model.type, model.name, opts, scope, variant);
+        if (body.length === 0) return [];
+        return [
+            `/** Rehydrates every \`decimal\` in a ${typeName} from its wire string. Mutates and returns \`raw\`. */`,
+            `export function ${fnName}(raw: ${typeName}): ${typeName} {`,
+            `    const __v = [raw] as unknown[];`,
+            ...body.map(l => `    ${l}`),
+            `    return __v[0] as ${typeName};`,
+            `}`,
+        ];
+    }
+
+    const obj = scope.next('o');
+    const body = model.fields.flatMap(f =>
+        typeReachesDecimal(f.type, opts) ? fieldStatements(obj, f, model.name, opts, scope, variant, model.outputCase) : [],
+    );
+    if (body.length === 0) return [];
+
+    return [
+        `/** Rehydrates every \`decimal\` in a ${typeName} from its wire string. Mutates and returns \`raw\`. */`,
+        `export function ${fnName}(raw: ${typeName}): ${typeName} {`,
+        `    const ${obj} = raw as unknown as Record<string, unknown>;`,
+        ...body.map(l => `    ${l}`),
+        `    return raw;`,
+        `}`,
+    ];
+}