jaz-cli 2.6.0 → 2.7.0

package/dist/__tests__/depreciation.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest';
+import { calculateDepreciation } from '../calc/depreciation.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateDepreciation (straight-line)', () => {
+    const base = { cost: 50000, salvageValue: 5000, usefulLifeYears: 5, method: 'sl' };
+    it('total depreciation = cost - salvage', () => {
+        const r = calculateDepreciation(base);
+        expect(r.totalDepreciation).toBe(45000);
+    });
+    it('correct period count (annual)', () => {
+        const r = calculateDepreciation(base);
+        expect(r.schedule).toHaveLength(5);
+    });
+    it('equal depreciation per year (except final rounding)', () => {
+        const r = calculateDepreciation(base);
+        // 45000 / 5 = 9000 exactly, no rounding needed
+        for (const row of r.schedule) {
+            expect(row.depreciation).toBe(9000);
+        }
+    });
+    it('final book value = salvage', () => {
+        const r = calculateDepreciation(base);
+        expect(r.schedule[r.schedule.length - 1].closingBookValue).toBe(5000);
+    });
+    it('all methodUsed = SL', () => {
+        const r = calculateDepreciation(base);
+        for (const row of r.schedule) {
+            expect(row.methodUsed).toBe('SL');
+        }
+    });
+    it('monthly frequency produces 60 periods', () => {
+        const r = calculateDepreciation({ ...base, frequency: 'monthly' });
+        expect(r.schedule).toHaveLength(60);
+    });
+    it('monthly: final book value = salvage', () => {
+        const r = calculateDepreciation({ ...base, frequency: 'monthly' });
+        expect(r.schedule[r.schedule.length - 1].closingBookValue).toBe(5000);
+    });
+    it('every journal entry balanced', () => {
+        const r = calculateDepreciation(base);
+        for (const row of r.schedule) {
+            const debits = row.journal.lines.reduce((s, l) => s + l.debit, 0);
+            const credits = row.journal.lines.reduce((s, l) => s + l.credit, 0);
+            expect(debits).toBe(credits);
+        }
+    });
+});
+describe('calculateDepreciation (DDB)', () => {
+    const base = { cost: 50000, salvageValue: 5000, usefulLifeYears: 5, method: 'ddb' };
+    it('total depreciation = cost - salvage', () => {
+        const r = calculateDepreciation(base);
+        const totalDep = r.schedule.reduce((s, row) => s + row.depreciation, 0);
+        expect(Math.round(totalDep * 100) / 100).toBe(45000);
+    });
+    it('starts with DDB, switches to SL', () => {
+        const r = calculateDepreciation(base);
+        expect(r.schedule[0].methodUsed).toBe('DDB');
+        expect(r.schedule[r.schedule.length - 1].methodUsed).toBe('SL');
+    });
+    it('first year DDB amount = cost * 2/life', () => {
+        const r = calculateDepreciation(base);
+        expect(r.schedule[0].ddbAmount).toBe(20000); // 50000 * 0.4
+    });
+    it('book value never falls below salvage', () => {
+        const r = calculateDepreciation(base);
+        for (const row of r.schedule) {
+            expect(row.closingBookValue).toBeGreaterThanOrEqual(5000);
+        }
+    });
+    it('final book value = salvage', () => {
+        const r = calculateDepreciation(base);
+        expect(r.schedule[r.schedule.length - 1].closingBookValue).toBe(5000);
+    });
+    it('correct period count', () => {
+        const r = calculateDepreciation(base);
+        expect(r.schedule).toHaveLength(5);
+    });
+});
+describe('calculateDepreciation (150DB)', () => {
+    const base = { cost: 50000, salvageValue: 5000, usefulLifeYears: 5, method: '150db' };
+    it('total depreciation = cost - salvage', () => {
+        const r = calculateDepreciation(base);
+        const totalDep = r.schedule.reduce((s, row) => s + row.depreciation, 0);
+        expect(Math.round(totalDep * 100) / 100).toBe(45000);
+    });
+    it('first year uses 150DB rate (1.5/life)', () => {
+        const r = calculateDepreciation(base);
+        expect(r.schedule[0].ddbAmount).toBe(15000); // 50000 * 0.3
+    });
+    it('final book value = salvage', () => {
+        const r = calculateDepreciation(base);
+        expect(r.schedule[r.schedule.length - 1].closingBookValue).toBe(5000);
+    });
+});
+describe('calculateDepreciation (blueprint)', () => {
+    it('blueprint always present (no startDate needed for depreciation)', () => {
+        const r = calculateDepreciation({ cost: 50000, salvageValue: 5000, usefulLifeYears: 5, method: 'sl' });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('step count matches schedule length', () => {
+        const r = calculateDepreciation({ cost: 50000, salvageValue: 5000, usefulLifeYears: 5, method: 'ddb' });
+        expect(r.blueprint.steps).toHaveLength(r.schedule.length);
+    });
+    it('all steps are journal type', () => {
+        const r = calculateDepreciation({ cost: 50000, salvageValue: 5000, usefulLifeYears: 5, method: 'sl' });
+        for (const step of r.blueprint.steps) {
+            expect(step.action).toBe('journal');
+        }
+    });
+});
+describe('calculateDepreciation (validation)', () => {
+    it('rejects zero cost', () => {
+        expect(() => calculateDepreciation({ cost: 0, salvageValue: 0, usefulLifeYears: 5, method: 'sl' }))
+            .toThrow(CalcValidationError);
+    });
+    it('rejects salvage >= cost', () => {
+        expect(() => calculateDepreciation({ cost: 50000, salvageValue: 50000, usefulLifeYears: 5, method: 'sl' }))
+            .toThrow(CalcValidationError);
+    });
+    it('allows zero salvage', () => {
+        const r = calculateDepreciation({ cost: 50000, salvageValue: 0, usefulLifeYears: 5, method: 'sl' });
+        expect(r.totalDepreciation).toBe(50000);
+    });
+});

package/dist/__tests__/ecl.test.js

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import { calculateEcl } from '../calc/ecl.js';
+import { CalcValidationError } from '../calc/validate.js';
+const standardBuckets = [
+    { name: 'Current', balance: 100000, rate: 0.5 },
+    { name: '1-30 days', balance: 50000, rate: 2 },
+    { name: '31-60 days', balance: 20000, rate: 5 },
+    { name: '61-90 days', balance: 10000, rate: 10 },
+    { name: '91+ days', balance: 5000, rate: 50 },
+];
+describe('calculateEcl (standard)', () => {
+    it('bucket ECL = balance * rate / 100', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.bucketDetails[0].ecl).toBe(500); // 100000 * 0.5%
+        expect(r.bucketDetails[1].ecl).toBe(1000); // 50000 * 2%
+        expect(r.bucketDetails[2].ecl).toBe(1000); // 20000 * 5%
+        expect(r.bucketDetails[3].ecl).toBe(1000); // 10000 * 10%
+        expect(r.bucketDetails[4].ecl).toBe(2500); // 5000 * 50%
+    });
+    it('totalEcl = sum of bucket ECLs', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.totalEcl).toBe(6000); // 500+1000+1000+1000+2500
+    });
+    it('totalReceivables = sum of balances', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.totalReceivables).toBe(185000);
+    });
+    it('adjustmentRequired = totalEcl - existingProvision', () => {
+        const r = calculateEcl({ buckets: standardBuckets, existingProvision: 4000 });
+        expect(r.adjustmentRequired).toBe(2000);
+        expect(r.isIncrease).toBe(true);
+    });
+    it('negative adjustment when over-provisioned', () => {
+        const r = calculateEcl({ buckets: standardBuckets, existingProvision: 8000 });
+        expect(r.adjustmentRequired).toBe(-2000);
+        expect(r.isIncrease).toBe(false);
+    });
+    it('zero adjustment when existing = required', () => {
+        const r = calculateEcl({ buckets: standardBuckets, existingProvision: 6000 });
+        expect(r.adjustmentRequired).toBe(0);
+        expect(r.isIncrease).toBe(true); // >= 0
+    });
+    it('existingProvision defaults to 0', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.adjustmentRequired).toBe(6000); // totalEcl - 0
+    });
+});
+describe('calculateEcl (journal)', () => {
+    it('increase: debits Bad Debt Expense, credits Allowance', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.journal.lines[0].account).toBe('Bad Debt Expense');
+        expect(r.journal.lines[0].debit).toBe(6000);
+        expect(r.journal.lines[1].account).toBe('Allowance for Doubtful Debts');
+        expect(r.journal.lines[1].credit).toBe(6000);
+    });
+    it('release: debits Allowance, credits Bad Debt Expense', () => {
+        const r = calculateEcl({ buckets: standardBuckets, existingProvision: 8000 });
+        expect(r.journal.lines[0].account).toBe('Allowance for Doubtful Debts');
+        expect(r.journal.lines[0].debit).toBe(2000);
+        expect(r.journal.lines[1].account).toBe('Bad Debt Expense');
+        expect(r.journal.lines[1].credit).toBe(2000);
+    });
+    it('journal is balanced', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        const debits = r.journal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.journal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+});
+describe('calculateEcl (blueprint)', () => {
+    it('blueprint always present', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint has 1 step (journal)', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.blueprint.steps).toHaveLength(1);
+        expect(r.blueprint.steps[0].action).toBe('journal');
+    });
+    it('capsuleType is ECL Provision', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.blueprint.capsuleType).toBe('ECL Provision');
+    });
+    it('capsuleDescription contains IFRS 9', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.blueprint.capsuleDescription).toContain('IFRS 9');
+    });
+});
+describe('calculateEcl (currency)', () => {
+    it('currency passes through', () => {
+        const r = calculateEcl({ buckets: standardBuckets, currency: 'SGD' });
+        expect(r.currency).toBe('SGD');
+    });
+    it('currency null when not provided', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        expect(r.currency).toBeNull();
+    });
+});
+describe('calculateEcl (weighted rate)', () => {
+    it('weighted average loss rate is correct', () => {
+        const r = calculateEcl({ buckets: standardBuckets });
+        // round2(6000/185000 * 100 * 100) / 100 = 3.2432%
+        expect(r.weightedRate).toBe(3.2432);
+    });
+    it('weighted rate is 0 when all balances are zero', () => {
+        const r = calculateEcl({ buckets: [{ name: 'Current', balance: 0, rate: 5 }] });
+        expect(r.weightedRate).toBe(0);
+    });
+});
+describe('calculateEcl (validation)', () => {
+    it('rejects negative balance', () => {
+        expect(() => calculateEcl({
+            buckets: [{ name: 'Current', balance: -100, rate: 5 }],
+        })).toThrow(CalcValidationError);
+    });
+    it('rejects negative loss rate', () => {
+        expect(() => calculateEcl({
+            buckets: [{ name: 'Current', balance: 100, rate: -5 }],
+        })).toThrow(CalcValidationError);
+    });
+    it('rejects negative existing provision', () => {
+        expect(() => calculateEcl({
+            buckets: [{ name: 'Current', balance: 100, rate: 5 }],
+            existingProvision: -1000,
+        })).toThrow(CalcValidationError);
+    });
+    it('allows zero balance and zero rate', () => {
+        const r = calculateEcl({
+            buckets: [{ name: 'Current', balance: 0, rate: 0 }],
+        });
+        expect(r.totalEcl).toBe(0);
+    });
+});

package/dist/__tests__/fixed-deposit.test.js

@@ -0,0 +1,214 @@
+import { describe, it, expect } from 'vitest';
+import { calculateFixedDeposit } from '../calc/fixed-deposit.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateFixedDeposit (simple interest)', () => {
+    const base = { principal: 100000, annualRate: 3.5, termMonths: 12 };
+    it('maturity = principal + simple interest', () => {
+        const r = calculateFixedDeposit(base);
+        // 100000 * 3.5% * 12/12 = 3500
+        expect(r.maturityValue).toBe(103500);
+    });
+    it('totalInterest = maturity - principal', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.totalInterest).toBe(3500);
+    });
+    it('schedule has termMonths periods', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.schedule).toHaveLength(12);
+    });
+    it('equal monthly accrual (except final rounding)', () => {
+        const r = calculateFixedDeposit(base);
+        const monthlyAccrual = Math.round(3500 / 12 * 100) / 100; // 291.67
+        for (let i = 0; i < 11; i++) {
+            expect(r.schedule[i].interest).toBe(monthlyAccrual);
+        }
+    });
+    it('total accrued interest = totalInterest exactly', () => {
+        const r = calculateFixedDeposit(base);
+        const totalAccrued = r.schedule.reduce((s, row) => s + row.interest, 0);
+        expect(Math.round(totalAccrued * 100) / 100).toBe(3500);
+    });
+    it('opening balance stays at principal (simple interest)', () => {
+        const r = calculateFixedDeposit(base);
+        for (const row of r.schedule) {
+            expect(row.openingBalance).toBe(100000);
+        }
+    });
+    it('every journal entry is balanced', () => {
+        const r = calculateFixedDeposit(base);
+        for (const row of r.schedule) {
+            const debits = row.journal.lines.reduce((s, l) => s + l.debit, 0);
+            const credits = row.journal.lines.reduce((s, l) => s + l.credit, 0);
+            expect(debits).toBe(credits);
+        }
+    });
+    it('accrual journals use Accrued Interest / Interest Income', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.schedule[0].journal.lines[0].account).toBe('Accrued Interest Receivable');
+        expect(r.schedule[0].journal.lines[1].account).toBe('Interest Income');
+    });
+});
+describe('calculateFixedDeposit (compound quarterly)', () => {
+    const base = { principal: 100000, annualRate: 4, termMonths: 12, compounding: 'quarterly' };
+    it('schedule has 4 periods (quarterly)', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.schedule).toHaveLength(4);
+    });
+    it('maturity > simple interest equivalent', () => {
+        const simple = calculateFixedDeposit({ principal: 100000, annualRate: 4, termMonths: 12 });
+        const compound = calculateFixedDeposit(base);
+        expect(compound.maturityValue).toBeGreaterThan(simple.maturityValue);
+    });
+    it('final closing balance = maturity value', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.schedule[r.schedule.length - 1].closingBalance).toBe(r.maturityValue);
+    });
+    it('opening balance = previous closing balance', () => {
+        const r = calculateFixedDeposit(base);
+        for (let i = 1; i < r.schedule.length; i++) {
+            expect(r.schedule[i].openingBalance).toBe(r.schedule[i - 1].closingBalance);
+        }
+    });
+    it('total accrued = totalInterest', () => {
+        const r = calculateFixedDeposit(base);
+        const totalAccrued = r.schedule.reduce((s, row) => s + row.interest, 0);
+        expect(Math.round(totalAccrued * 100) / 100).toBe(r.totalInterest);
+    });
+    it('every journal entry is balanced', () => {
+        const r = calculateFixedDeposit(base);
+        for (const row of r.schedule) {
+            const debits = row.journal.lines.reduce((s, l) => s + l.debit, 0);
+            const credits = row.journal.lines.reduce((s, l) => s + l.credit, 0);
+            expect(debits).toBe(credits);
+        }
+    });
+});
+describe('calculateFixedDeposit (compound monthly)', () => {
+    it('monthly compound: 12 periods', () => {
+        const r = calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 12, compounding: 'monthly',
+        });
+        expect(r.schedule).toHaveLength(12);
+    });
+});
+describe('calculateFixedDeposit (compound annually)', () => {
+    it('annual compound: 1 period for 12 months', () => {
+        const r = calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 12, compounding: 'annually',
+        });
+        expect(r.schedule).toHaveLength(1);
+        expect(r.maturityValue).toBe(104000); // 100000 * 1.04
+    });
+});
+describe('calculateFixedDeposit (placement/maturity journals)', () => {
+    const base = { principal: 100000, annualRate: 3.5, termMonths: 12 };
+    it('placement journal: debit Fixed Deposit, credit Cash', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.placementJournal.lines[0].account).toBe('Fixed Deposit');
+        expect(r.placementJournal.lines[0].debit).toBe(100000);
+        expect(r.placementJournal.lines[1].account).toBe('Cash / Bank Account');
+        expect(r.placementJournal.lines[1].credit).toBe(100000);
+    });
+    it('maturity journal: debit Cash, credit FD + Accrued Interest', () => {
+        const r = calculateFixedDeposit(base);
+        expect(r.maturityJournal.lines[0].account).toBe('Cash / Bank Account');
+        expect(r.maturityJournal.lines[0].debit).toBe(103500);
+        expect(r.maturityJournal.lines[1].account).toBe('Fixed Deposit');
+        expect(r.maturityJournal.lines[1].credit).toBe(100000);
+        expect(r.maturityJournal.lines[2].account).toBe('Accrued Interest Receivable');
+        expect(r.maturityJournal.lines[2].credit).toBe(3500);
+    });
+    it('placement journal is balanced', () => {
+        const r = calculateFixedDeposit(base);
+        const debits = r.placementJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.placementJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+    it('maturity journal is balanced', () => {
+        const r = calculateFixedDeposit(base);
+        const debits = r.maturityJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.maturityJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+});
+describe('calculateFixedDeposit (blueprint)', () => {
+    it('blueprint present when startDate given', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint null without startDate', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12 });
+        expect(r.blueprint).toBeNull();
+    });
+    it('step 1 = cash-out (placement)', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.steps[0].action).toBe('cash-out');
+    });
+    it('last step = cash-in (maturity)', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        const lastStep = r.blueprint.steps[r.blueprint.steps.length - 1];
+        expect(lastStep.action).toBe('cash-in');
+    });
+    it('step count = 1 placement + N accruals + 1 maturity', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.steps).toHaveLength(14); // 1 + 12 + 1
+    });
+    it('compound quarterly: step count uses compound periods', () => {
+        const r = calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 12,
+            compounding: 'quarterly', startDate: '2025-01-01',
+        });
+        expect(r.blueprint.steps).toHaveLength(6); // 1 + 4 + 1
+    });
+    it('capsuleType is Fixed Deposit', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleType).toBe('Fixed Deposit');
+    });
+    it('capsuleDescription contains IFRS 9', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleDescription).toContain('IFRS 9');
+    });
+});
+describe('calculateFixedDeposit (currency)', () => {
+    it('currency passes through', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12, currency: 'SGD' });
+        expect(r.currency).toBe('SGD');
+    });
+    it('currency null when not provided', () => {
+        const r = calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 12 });
+        expect(r.currency).toBeNull();
+    });
+});
+describe('calculateFixedDeposit (validation)', () => {
+    it('rejects zero principal', () => {
+        expect(() => calculateFixedDeposit({ principal: 0, annualRate: 3.5, termMonths: 12 })).toThrow(CalcValidationError);
+    });
+    it('rejects negative rate', () => {
+        expect(() => calculateFixedDeposit({ principal: 100000, annualRate: -1, termMonths: 12 })).toThrow(CalcValidationError);
+    });
+    it('rejects zero term', () => {
+        expect(() => calculateFixedDeposit({ principal: 100000, annualRate: 3.5, termMonths: 0 })).toThrow(CalcValidationError);
+    });
+    it('rejects non-multiple term for quarterly compounding', () => {
+        expect(() => calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 7, compounding: 'quarterly',
+        })).toThrow(CalcValidationError);
+    });
+    it('rejects non-multiple term for annual compounding', () => {
+        expect(() => calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 18, compounding: 'annually',
+        })).toThrow(CalcValidationError);
+    });
+    it('allows any term for monthly compounding', () => {
+        const r = calculateFixedDeposit({
+            principal: 100000, annualRate: 4, termMonths: 7, compounding: 'monthly',
+        });
+        expect(r.schedule).toHaveLength(7);
+    });
+    it('rejects invalid date format', () => {
+        expect(() => calculateFixedDeposit({
+            principal: 100000, annualRate: 3.5, termMonths: 12, startDate: '01-01-2025',
+        })).toThrow(CalcValidationError);
+    });
+});

package/dist/__tests__/fx-reval.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { calculateFxReval } from '../calc/fx-reval.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateFxReval (gain)', () => {
+    const base = { amount: 50000, bookRate: 1.35, closingRate: 1.38 };
+    it('bookValue = amount * bookRate', () => {
+        const r = calculateFxReval(base);
+        expect(r.bookValue).toBe(67500); // 50000 * 1.35
+    });
+    it('closingValue = amount * closingRate', () => {
+        const r = calculateFxReval(base);
+        expect(r.closingValue).toBe(69000); // 50000 * 1.38
+    });
+    it('gain = closingValue - bookValue', () => {
+        const r = calculateFxReval(base);
+        expect(r.gainOrLoss).toBe(1500);
+        expect(r.isGain).toBe(true);
+    });
+    it('journal debits Monetary Item, credits FX Unrealized Gain', () => {
+        const r = calculateFxReval(base);
+        expect(r.journal.lines[0].account).toContain('Monetary Item');
+        expect(r.journal.lines[0].debit).toBe(1500);
+        expect(r.journal.lines[1].account).toBe('FX Unrealized Gain');
+        expect(r.journal.lines[1].credit).toBe(1500);
+    });
+    it('journal is balanced', () => {
+        const r = calculateFxReval(base);
+        const debits = r.journal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.journal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+    it('reversal is exact negative of revaluation', () => {
+        const r = calculateFxReval(base);
+        for (let i = 0; i < r.journal.lines.length; i++) {
+            expect(r.reversalJournal.lines[i].debit).toBe(r.journal.lines[i].credit);
+            expect(r.reversalJournal.lines[i].credit).toBe(r.journal.lines[i].debit);
+        }
+    });
+    it('reversal journal is balanced', () => {
+        const r = calculateFxReval(base);
+        const debits = r.reversalJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.reversalJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+});
+describe('calculateFxReval (loss)', () => {
+    const base = { amount: 50000, bookRate: 1.38, closingRate: 1.35 };
+    it('loss is negative gainOrLoss', () => {
+        const r = calculateFxReval(base);
+        expect(r.gainOrLoss).toBe(-1500);
+        expect(r.isGain).toBe(false);
+    });
+    it('journal debits FX Unrealized Loss, credits Monetary Item', () => {
+        const r = calculateFxReval(base);
+        expect(r.journal.lines[0].account).toBe('FX Unrealized Loss');
+        expect(r.journal.lines[0].debit).toBe(1500);
+        expect(r.journal.lines[1].account).toContain('Monetary Item');
+        expect(r.journal.lines[1].credit).toBe(1500);
+    });
+});
+describe('calculateFxReval (zero movement)', () => {
+    it('zero gain/loss when rates equal', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.35 });
+        expect(r.gainOrLoss).toBe(0);
+        expect(r.isGain).toBe(true); // >= 0 treated as gain
+    });
+});
+describe('calculateFxReval (blueprint)', () => {
+    it('blueprint always present (no startDate needed)', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint has 2 steps (reval + reversal)', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        expect(r.blueprint.steps).toHaveLength(2);
+    });
+    it('both steps are journal type', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        for (const step of r.blueprint.steps) {
+            expect(step.action).toBe('journal');
+        }
+    });
+    it('capsuleType is FX Revaluation', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        expect(r.blueprint.capsuleType).toBe('FX Revaluation');
+    });
+    it('capsuleDescription contains IAS 21', () => {
+        const r = calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 1.38 });
+        expect(r.blueprint.capsuleDescription).toContain('IAS 21');
+    });
+});
+describe('calculateFxReval (defaults + passthrough)', () => {
+    it('defaults to USD/SGD', () => {
+        const r = calculateFxReval({ amount: 1000, bookRate: 1.3, closingRate: 1.4 });
+        expect(r.currency).toBe('USD');
+        expect(r.inputs.baseCurrency).toBe('SGD');
+    });
+    it('custom currency passes through', () => {
+        const r = calculateFxReval({ amount: 1000, bookRate: 1.3, closingRate: 1.4, currency: 'EUR', baseCurrency: 'PHP' });
+        expect(r.currency).toBe('EUR');
+        expect(r.inputs.baseCurrency).toBe('PHP');
+    });
+});
+describe('calculateFxReval (validation)', () => {
+    it('rejects zero amount', () => {
+        expect(() => calculateFxReval({ amount: 0, bookRate: 1.35, closingRate: 1.38 })).toThrow(CalcValidationError);
+    });
+    it('rejects negative bookRate', () => {
+        expect(() => calculateFxReval({ amount: 50000, bookRate: -1, closingRate: 1.38 })).toThrow(CalcValidationError);
+    });
+    it('rejects zero closingRate', () => {
+        expect(() => calculateFxReval({ amount: 50000, bookRate: 1.35, closingRate: 0 })).toThrow(CalcValidationError);
+    });
+});