@contractkit/plugin-typescript 0.32.0 → 0.33.1

package/src/index.ts

@@ -21,6 +21,7 @@ import {
     collectTransitiveModelRefs,
     collectTypeRefs,
     computeModelsWithCaseTransform,
+    computeModelsWithDecimal,
 } from '@contractkit/core';
 import {
     generateSdk,
@@ -102,7 +103,8 @@ export interface SdkConfig {
      * write-once: the files are created only when absent and are never overwritten or
      * cleaned up on later builds, so any edits you make to them are preserved.
      * Dependency ranges are derived from the contracts (always `zod` when `zod: true`;
-     * `luxon` when any covered model uses a date/time/datetime/interval scalar).
+     * `luxon` when any covered model uses a date/time/datetime/duration/interval scalar;
+     * `decimal.js` when any uses a decimal).
      */
     scaffold?: boolean;
 }
@@ -463,6 +465,9 @@ function collectSdkOutput(
 
     const modelsWithInput = inputs.modelsWithInput as Set<string>;
     const modelsWithOutput = inputs.modelsWithOutput as Set<string>;
+    // Computed across every contract root, not per file: one decimal below a model taints it, and
+    // the reference that reaches it may live in another .ck file entirely.
+    const modelsWithDecimal = computeModelsWithDecimal(inputs.contractRoots.flatMap(r => r.models));
     const modelMap = buildModelMap(inputs.contractRoots);
     const allFiles = [...inputs.contractRoots.map(r => r.file), ...inputs.opRoots.map(r => r.file)];
     const ckCommonRoot = commonDir(allFiles, rootDir);
@@ -501,6 +506,9 @@ function collectSdkOutput(
             outPathSlice: sliceOutPathMap(refs, sdkModelOutPaths, modelsWithInput, modelsWithOutput),
             modelsWithInput: sliceModelSet(refs, ownNames, modelsWithInput),
             modelsWithOutput: sliceModelSet(refs, ownNames, modelsWithOutput),
+            // Not covered by `root`: adding a decimal to a model in a *different* .ck file changes
+            // this file's revivers with no change to `root` or the config.
+            modelsWithDecimal: sliceModelSet(refs, ownNames, modelsWithDecimal),
             sdkOptionsPath,
             sub: subConfigKey,
         });
@@ -509,12 +517,16 @@ function collectSdkOutput(
             fingerprint,
             render: () => {
                 let content: string;
+                // `emitRevivers` is set for SDK type files only: a server handler receives decimals
+                // already parsed by `_ZodDecimal`, so it has nothing to rehydrate.
                 if (config.zod) {
                     content = generateContract(ast, {
                         modelOutPaths: sdkModelOutPaths,
                         currentOutPath: typeOutPath,
                         modelsWithInput,
                         modelsWithOutput,
+                        modelsWithDecimal,
+                        emitRevivers: true,
                     });
                 } else {
                     let rel = relative(dirname(typeOutPath), sdkOptionsPath).replace(/\.ts$/, '.js');
@@ -524,6 +536,8 @@ function collectSdkOutput(
                         currentOutPath: typeOutPath,
                         modelsWithInput,
                         modelsWithOutput,
+                        modelsWithDecimal,
+                        emitRevivers: true,
                         jsonValueImportPath: rel,
                     });
                 }
@@ -572,6 +586,7 @@ function collectSdkOutput(
                     outPathSlice: sliceOutPathMap(refs, sdkModelOutPaths, modelsWithInput, modelsWithOutput),
                     modelsWithInput: sliceModelSet(refs, new Set(), modelsWithInput),
                     modelsWithOutput: sliceModelSet(refs, new Set(), modelsWithOutput),
+                    modelsWithDecimal: sliceModelSet(refs, new Set(), modelsWithDecimal),
                     sdkOptionsPath,
                     className,
                     includeInternal: config.includeInternal ?? false,
@@ -590,6 +605,8 @@ function collectSdkOutput(
                                 sdkOptionsPath,
                                 modelsWithInput,
                                 modelsWithOutput,
+                                modelsWithDecimal,
+                                modelMap,
                                 includeInternal: config.includeInternal,
                                 clientClassName: className,
                             }),
@@ -612,6 +629,7 @@ function collectSdkOutput(
                 outPathSlice: sliceOutPathMap(refs, sdkModelOutPaths, modelsWithInput, modelsWithOutput),
                 modelsWithInput: sliceModelSet(refs, new Set(), modelsWithInput),
                 modelsWithOutput: sliceModelSet(refs, new Set(), modelsWithOutput),
+                modelsWithDecimal: sliceModelSet(refs, new Set(), modelsWithDecimal),
                 sdkOptionsPath,
                 includeInternal: config.includeInternal ?? false,
                 sub: subConfigKey,
@@ -629,6 +647,8 @@ function collectSdkOutput(
                             sdkOptionsPath,
                             modelsWithInput,
                             modelsWithOutput,
+                            modelsWithDecimal,
+                            modelMap,
                             includeInternal: config.includeInternal,
                         }),
                     },
@@ -710,6 +730,7 @@ function collectSdkOutput(
                 outPathSlice: sliceOutPathMap(allInlineRefs, sdkModelOutPaths, modelsWithInput, modelsWithOutput),
                 modelsWithInput: sliceModelSet(allInlineRefs, new Set(), modelsWithInput),
                 modelsWithOutput: sliceModelSet(allInlineRefs, new Set(), modelsWithOutput),
+                modelsWithDecimal: sliceModelSet(allInlineRefs, new Set(), modelsWithDecimal),
                 sdkOptionsPath,
                 includeInternal: config.includeInternal ?? false,
                 sub: subConfigKey,
@@ -724,6 +745,8 @@ function collectSdkOutput(
                     sdkOptionsPath,
                     modelsWithInput,
                     modelsWithOutput,
+                    modelsWithDecimal,
+                    modelMap,
                     includeInternal: config.includeInternal,
                 },
             }));
@@ -787,9 +810,13 @@ function collectSdkOutput(
         const coveredRoots = sdkContractEntries.map(e => e.ast);
         const deps: SdkScaffoldDeps = {
             zod: !!config.zod,
-            luxon: coveredRoots.some(
-                r => rootNeedsScalar(r, 'datetime') || rootNeedsScalar(r, 'date') || rootNeedsScalar(r, 'time') || rootNeedsScalar(r, 'interval'),
+            // `duration` belongs here too: `generateContract` imports `Duration` from luxon for it,
+            // so a contract whose only temporal scalar is a duration used to scaffold a package.json
+            // with no luxon dependency and fail to compile.
+            luxon: coveredRoots.some(r =>
+                (['datetime', 'date', 'time', 'duration', 'interval'] as const).some(name => rootNeedsScalar(r, name)),
             ),
+            decimal: coveredRoots.some(r => rootNeedsScalar(r, 'decimal')),
         };
         globalFiles.push({
             relativePath: join(sdkBase, 'package.json'),

package/src/ts-render.ts

@@ -96,6 +96,12 @@ function renderTsScalar(name: ScalarTypeNode['name'], target: TsRenderTarget): s
             return 'number';
         case 'bigint':
             return 'bigint';
+        case 'decimal':
+            // The one scalar whose wire view and server view agree — see the note on this
+            // function and on `serverTsScalar`. A `decimal` travels as a quoted string, and both
+            // the router (via `_ZodDecimal`) and the SDK (via the generated `reviveX` functions)
+            // hand the developer a real `Decimal`, so there is no `target` split to make.
+            return 'Decimal';
         case 'boolean':
             return 'boolean';
         case 'date':

package/tests/codegen-contract.test.ts

@@ -27,7 +27,7 @@ describe('renderType', () => {
         });
 
         it('throws on an unmapped scalar name', () => {
-            expect(() => renderType({ kind: 'scalar', name: 'decimal' } as any)).toThrow(/unmapped scalar 'decimal'/);
+            expect(() => renderType({ kind: 'scalar', name: 'quaternion' } as any)).toThrow(/unmapped scalar 'quaternion'/);
         });
 
         it('renders z.string() with min/max', () => {
@@ -101,6 +101,36 @@ describe('renderType', () => {
             expect(result).toBe(`z.preprocess((val) => typeof val === 'string' ? BigInt(val.replace(/n$/, '')) : val, z.bigint().min(0n).max(100n))`);
         });
 
+        it('renders bare _ZodDecimal for an unconstrained decimal', () => {
+            expect(renderType(scalarType('decimal'))).toBe('_ZodDecimal');
+        });
+
+        it('renders a scale refinement on decimal', () => {
+            expect(renderType(scalarType('decimal', { scale: 2 }))).toBe(
+                `_ZodDecimal.refine((v) => v.decimalPlaces() <= 2, { message: 'Must be at most 2 decimal places' })`,
+            );
+        });
+
+        it('compares decimal bounds as exact strings, never as floats', () => {
+            // `0.01` through `Number()` is the precision loss this scalar exists to prevent, so the
+            // bound is emitted as a quoted string for decimal.js to parse.
+            const result = renderType(scalarType('decimal', { min: '0.01', max: '999999.99' }));
+            expect(result).toBe(
+                `_ZodDecimal.refine((v) => v.gte('0.01') && v.lte('999999.99'), { message: 'Must be at least 0.01, at most 999999.99' })`,
+            );
+        });
+
+        it('renders scale and bounds together', () => {
+            const result = renderType(scalarType('decimal', { min: '0', scale: 2 }));
+            expect(result).toBe(
+                `_ZodDecimal.refine((v) => v.decimalPlaces() <= 2 && v.gte('0'), { message: 'Must be at most 2 decimal places, at least 0' })`,
+            );
+        });
+
+        it('singularises the scale message at 1', () => {
+            expect(renderType(scalarType('decimal', { scale: 1 }))).toContain(`message: 'Must be at most 1 decimal place'`);
+        });
+
         it('renders z.boolean() with string coercion preprocess', () => {
             expect(renderType(scalarType('boolean'))).toBe(`z.preprocess((v) => v === 'true' ? true : v === 'false' ? false : v, z.boolean())`);
         });
@@ -329,6 +359,99 @@ describe('generateContract', () => {
             );
         });
 
+        it('emits the decimal.js import and _ZodDecimal helper when a decimal field is present', () => {
+            const root = contractRoot([model('M', [field('amount', scalarType('decimal'))])]);
+            const output = generateContract(root);
+            // Named, not default: under NodeNext the default export resolves to decimal.js's
+            // namespace declaration and the generated SDK fails to compile.
+            expect(output).toContain(`import { Decimal } from 'decimal.js';`);
+            expect(output).toContain(`Decimal.set({ toExpNeg: -9e15, toExpPos: 9e15 });`);
+            expect(output).toContain(`const _ZodDecimal = z.preprocess(`);
+            // No output `.transform()` — `isRevalidatable` treats every scalar as idempotent under
+            // re-parse, which `server.validateResponses` depends on.
+            expect(output).not.toContain('_ZodDecimal = z.preprocess(...).transform');
+        });
+
+        it('omits the decimal runtime entirely when no decimal field is present', () => {
+            const root = contractRoot([model('M', [field('n', scalarType('number'))])]);
+            const output = generateContract(root);
+            expect(output).not.toContain('decimal.js');
+            expect(output).not.toContain('_ZodDecimal');
+            expect(output).not.toContain('Decimal.set');
+        });
+
+        it('emits revivers only when asked, and only for decimal-carrying models', () => {
+            const root = contractRoot([
+                model('Money', [field('amount', scalarType('decimal'))]),
+                model('Plain', [field('name', scalarType('string'))]),
+            ]);
+            const ctx = { modelOutPaths: new Map(), currentOutPath: '/out/t.ts' };
+
+            // Server-side schemas get decimals already parsed by `_ZodDecimal`, so no revivers.
+            const withoutRevivers = generateContract(root, ctx);
+            expect(withoutRevivers).not.toContain('reviveMoney');
+            expect(withoutRevivers).not.toContain('__dec');
+
+            const withRevivers = generateContract(root, { ...ctx, modelsWithDecimal: new Set(['Money']), emitRevivers: true });
+            expect(withRevivers).toContain('export function reviveMoney(raw: Money): Money {');
+            expect(withRevivers).toContain(`__o0["amount"] = __dec(__o0["amount"], 'Money.amount');`);
+            expect(withRevivers).not.toContain('revivePlain');
+        });
+
+        it('guards an optional or nullable decimal instead of coercing null', () => {
+            const root = contractRoot([
+                model('M', [
+                    field('a', scalarType('decimal'), { optional: true }),
+                    field('b', unionType(scalarType('decimal'), scalarType('null'))),
+                ]),
+            ]);
+            const out = generateContract(root, {
+                modelOutPaths: new Map(),
+                currentOutPath: '/out/t.ts',
+                modelsWithDecimal: new Set(['M']),
+                emitRevivers: true,
+            });
+            expect(out).toContain(`if (__o0["a"] != null) {`);
+            expect(out).toContain(`if (__o0["b"] != null) {`);
+        });
+
+        it('keys the Output reviver by the output casing while children stay camel', () => {
+            const root = contractRoot([
+                model('Money', [field('amount', scalarType('decimal'))]),
+                model('Snake', [field('grossPay', scalarType('decimal')), field('childRef', refType('Money'))], { outputCase: 'snake' }),
+            ]);
+            const out = generateContract(root, {
+                modelOutPaths: new Map(),
+                currentOutPath: '/out/t.ts',
+                modelsWithDecimal: new Set(['Money', 'Snake']),
+                emitRevivers: true,
+            });
+            expect(out).toContain('export function reviveSnakeOutput(raw: SnakeOutput): SnakeOutput {');
+            expect(out).toContain(`__o0["gross_pay"] = __dec(__o0["gross_pay"], 'Snake.gross_pay');`);
+            // `computeModelsWithOutput` propagates referrer→referenced, so Money is NOT transformed
+            // and keeps its camelCase keys — it must use the base reviver, not an Output one.
+            expect(out).toContain(`reviveMoney(__o0["child_ref"] as never);`);
+            expect(out).not.toContain('reviveMoneyOutput');
+        });
+
+        it('recurses through a self-referential model without looping', () => {
+            const root = contractRoot([
+                model('Category', [field('subtotal', scalarType('decimal')), field('children', arrayType(refType('Category')))]),
+            ]);
+            const out = generateContract(root, {
+                modelOutPaths: new Map(),
+                currentOutPath: '/out/t.ts',
+                modelsWithDecimal: new Set(['Category']),
+                emitRevivers: true,
+            });
+            expect(out).toContain('reviveCategory(__a1[__i2] as never);');
+        });
+
+        it('detects a decimal nested in an array', () => {
+            const root = contractRoot([model('M', [field('amounts', arrayType(scalarType('decimal')))])]);
+            expect(generateContract(root)).toContain(`import { Decimal } from 'decimal.js';`);
+        });
+
         it('detects DateTime in nested array types', () => {
             const root = contractRoot([model('M', [field('d', arrayType(scalarType('datetime')))])]);
             const output = generateContract(root);

package/tests/codegen-operation.test.ts

@@ -1095,6 +1095,20 @@ describe('generateOperation', () => {
             expect(generateOp(respRoot('User'), V)).toContain('ctx.body = await parseAndValidate(result, User, 500);');
         });
 
+        it('re-validates a decimal body, which `isRevalidatable` assumes is idempotent', () => {
+            // `isRevalidatable` returns true for every scalar on the grounds that scalars are
+            // idempotent under re-parse. `_ZodDecimal` satisfies that only because it has no output
+            // `.transform()` — preprocess passes an already-`Decimal` value straight through. If it
+            // were modelled on `_ZodInterval`, which does transform, this would 500 at runtime.
+            const root = respRoot(inlineObjectType([field('amount', scalarType('decimal', { scale: 2 }))]));
+            const output = generateOp(root, V);
+            expect(output).toContain('await parseAndValidate(result,');
+            expect(output).toContain('_ZodDecimal');
+            expect(output).not.toMatch(/_ZodDecimal[^\n]*\.transform\(/);
+            // The helper references `Decimal`, so the import has to come with it.
+            expect(output).toContain(`import { Decimal } from 'decimal.js';`);
+        });
+
         // A service returning a shape its own contract rejects is a server fault, not a client one.
         // 500 also diverts the field-level detail to `internalDetails`, keeping it off the wire.
         it('throws 500, not the parseAndValidate default of 400', () => {

package/tests/codegen-sdk.test.ts

@@ -1294,7 +1294,7 @@ describe('renderTsType', () => {
         });
 
         it('throws on an unmapped scalar name', () => {
-            expect(() => renderTsType({ kind: 'scalar', name: 'decimal' } as any)).toThrow(/unmapped scalar 'decimal'/);
+            expect(() => renderTsType({ kind: 'scalar', name: 'quaternion' } as any)).toThrow(/unmapped scalar 'quaternion'/);
         });
     });
 
@@ -1857,9 +1857,72 @@ describe('generateAreaClient — <Area>Client emission', () => {
     });
 });
 
+describe('decimal rehydration', () => {
+    const withDecimal = (extra: Partial<Parameters<typeof generateSdk>[1]> = {}) => ({
+        modelsWithDecimal: new Set(['Invoice']),
+        modelOutPaths: new Map([['Invoice', '/out/types/models.ts']]),
+        outPath: '/out/clients/inv.client.ts',
+        sdkOptionsPath: '/out/sdk-options.ts',
+        ...extra,
+    });
+
+    it('wraps a model-ref response body in its reviver', () => {
+        const root = opRoot([opRoute('/invoices/{id}', [opOperation('get', { responses: [opResponse(200, 'Invoice')] })])], 'inv.op');
+        const out = generateSdk(root, withDecimal());
+        expect(out).toContain('return reviveInvoice(await parseJson<Invoice>(result));');
+        // The reviver is a value, so it needs a second import beside the `import type`.
+        expect(out).toContain(`import { reviveInvoice } from '../types/models.js';`);
+    });
+
+    it('maps over an array body rather than emitting a wrapper', () => {
+        const root = opRoot([opRoute('/invoices', [opOperation('get', { responses: [opResponse(200, 'array(Invoice)')] })])], 'inv.op');
+        const out = generateSdk(root, withDecimal());
+        // Safe because the reviver returns the object it mutated.
+        expect(out).toContain('return (await parseJson<Invoice[]>(result)).map(reviveInvoice);');
+    });
+
+    it('emits a local wrapper for a body with no reviveX of its own', () => {
+        const bodyType = inlineObjectType([field('grand', scalarType('decimal', { scale: 2 }))]);
+        const root = opRoot([opRoute('/totals', [opOperation('get', { sdk: 'getTotals', responses: [opResponse(200, bodyType)] })])], 'tot.op');
+        const out = generateSdk(root, withDecimal({ modelsWithDecimal: new Set(['Invoice']) }));
+        expect(out).toMatch(/function __reviveGetTotals200\(/);
+        // The wrapper calls `__dec`, which is file-local to the types module, so the client file
+        // needs its own copy plus the decimal.js import and global config.
+        expect(out).toContain(`import { Decimal } from 'decimal.js';`);
+        expect(out).toContain('Decimal.set({ toExpNeg: -9e15, toExpPos: 9e15 });');
+        expect(out).toContain('const __dec = (v: unknown, path: string): Decimal =>');
+    });
+
+    it('picks the Output reviver when the model has an Output variant', () => {
+        const root = opRoot([opRoute('/invoices/{id}', [opOperation('get', { responses: [opResponse(200, 'Invoice')] })])], 'inv.op');
+        const out = generateSdk(root, withDecimal({ modelsWithOutput: new Set(['Invoice']) }));
+        expect(out).toContain('reviveInvoiceOutput(');
+    });
+
+    it('leaves a decimal-free SDK byte-identical', () => {
+        const root = opRoot([opRoute('/users', [opOperation('get', { responses: [opResponse(200, 'User')] })])], 'users.op');
+        const base = generateSdk(root, { modelOutPaths: new Map([['User', '/out/types/models.ts']]), outPath: '/out/clients/u.client.ts' });
+        const withEmptySet = generateSdk(root, {
+            modelOutPaths: new Map([['User', '/out/types/models.ts']]),
+            outPath: '/out/clients/u.client.ts',
+            modelsWithDecimal: new Set(),
+        });
+        expect(withEmptySet).toBe(base);
+        expect(base).not.toContain('revive');
+        expect(base).not.toContain('decimal.js');
+    });
+
+    it('does not revive a body whose model carries no decimal', () => {
+        const root = opRoot([opRoute('/users', [opOperation('get', { responses: [opResponse(200, 'User')] })])], 'users.op');
+        const out = generateSdk(root, withDecimal({ modelOutPaths: new Map([['User', '/out/types/models.ts']]) }));
+        expect(out).toContain('return await parseJson<User>(result);');
+        expect(out).not.toContain('revive');
+    });
+});
+
 describe('generateSdkPackageJson', () => {
     it('emits a valid package.json with the given name and standard fields', () => {
-        const pkg = JSON.parse(generateSdkPackageJson({ name: 'my-sdk', deps: { zod: false, luxon: false } }));
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'my-sdk', deps: { zod: false, luxon: false, decimal: false } }));
         expect(pkg.name).toBe('my-sdk');
         expect(pkg.type).toBe('module');
         expect(pkg.exports['.'].types).toBe('./dist/index.d.ts');
@@ -1868,25 +1931,33 @@ describe('generateSdkPackageJson', () => {
     });
 
     it('omits the dependencies block entirely when neither zod nor luxon is used', () => {
-        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false } }));
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false, decimal: false } }));
         expect(pkg.dependencies).toBeUndefined();
         expect(pkg.devDependencies['@types/luxon']).toBeUndefined();
     });
 
     it('adds zod as a runtime dependency when zod output is enabled', () => {
-        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: true, luxon: false } }));
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: true, luxon: false, decimal: false } }));
         expect(pkg.dependencies.zod).toBeDefined();
         expect(pkg.dependencies.luxon).toBeUndefined();
     });
 
     it('adds luxon (runtime) and @types/luxon (dev) when a date/time scalar is used', () => {
-        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: true } }));
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: true, decimal: false } }));
         expect(pkg.dependencies.luxon).toBeDefined();
         expect(pkg.devDependencies['@types/luxon']).toBeDefined();
     });
 
+    it('adds decimal.js, with no @types half, when a decimal scalar is used', () => {
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false, decimal: true } }));
+        expect(pkg.dependencies['decimal.js']).toBeDefined();
+        // decimal.js ships its own declarations, unlike luxon.
+        expect(pkg.devDependencies['@types/decimal.js']).toBeUndefined();
+        expect(pkg.dependencies.luxon).toBeUndefined();
+    });
+
     it('ends with a trailing newline', () => {
-        expect(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false } }).endsWith('}\n')).toBe(true);
+        expect(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false, decimal: false } }).endsWith('}\n')).toBe(true);
     });
 });
 

package/tests/pipeline.test.ts

@@ -33,6 +33,30 @@ describe('Contract pipeline (source -> parse -> codegen)', () => {
         expect(output).toContain(`active: z.preprocess((v) => v === 'true' ? true : v === 'false' ? false : v, z.boolean()).default(true)`);
     });
 
+    it('compiles a decimal contract end to end, keeping bounds as exact strings', () => {
+        // Exercises the real parse path rather than a hand-built AST: `buildScalarWithModifiers`
+        // has to keep `0.01` as a string instead of routing it through `Number()`.
+        const { output, root, diag } = compileContractSource(`
+contract Payslip: {
+    gross: decimal(min=0.01, max=999999.99, scale=2)
+    rate: decimal
+}
+`);
+        expect(diag.hasErrors()).toBe(false);
+
+        const gross = root.models[0]!.fields[0]!.type as { min: unknown; max: unknown; scale: unknown };
+        expect(gross.min).toBe('0.01');
+        expect(gross.max).toBe('999999.99');
+        expect(gross.scale).toBe(2);
+
+        expect(output).toContain("import { Decimal } from 'decimal.js';");
+        expect(output).toContain('Decimal.set({ toExpNeg: -9e15, toExpPos: 9e15 });');
+        expect(output).toContain(
+            `gross: _ZodDecimal.refine((v) => v.decimalPlaces() <= 2 && v.gte('0.01') && v.lte('999999.99'), { message: 'Must be at most 2 decimal places, at least 0.01, at most 999999.99' })`,
+        );
+        expect(output).toContain('rate: _ZodDecimal');
+    });
+
     it('compiles a contract with visibility to three-schema pattern', () => {
         const { output, diag } = compileContractSource(VISIBILITY_CONTRACT);
         expect(diag.hasErrors()).toBe(false);