jaz-cli 2.5.0 → 2.7.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);
+    });
+});

package/dist/__tests__/lease.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import { calculateLease } from '../calc/lease.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateLease (standard)', () => {
+    const base = { monthlyPayment: 5000, termMonths: 36, annualRate: 5 };
+    it('produces correct schedule length', () => {
+        const r = calculateLease(base);
+        expect(r.schedule).toHaveLength(36);
+    });
+    it('final closing balance is exactly zero', () => {
+        const r = calculateLease(base);
+        expect(r.schedule[r.schedule.length - 1].closingBalance).toBe(0);
+    });
+    it('PV is less than total cash payments', () => {
+        const r = calculateLease(base);
+        expect(r.presentValue).toBeLessThan(r.totalCashPayments);
+    });
+    it('ROU depreciation = PV / term', () => {
+        const r = calculateLease(base);
+        const expected = Math.round(r.presentValue / 36 * 100) / 100;
+        expect(r.monthlyRouDepreciation).toBe(expected);
+    });
+    it('isHirePurchase is false without usefulLifeMonths', () => {
+        const r = calculateLease(base);
+        expect(r.isHirePurchase).toBe(false);
+    });
+    it('opening balance = previous closing balance', () => {
+        const r = calculateLease(base);
+        for (let i = 1; i < r.schedule.length; i++) {
+            expect(r.schedule[i].openingBalance).toBe(r.schedule[i - 1].closingBalance);
+        }
+    });
+    it('every journal entry is balanced', () => {
+        const r = calculateLease(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(Math.abs(debits - credits)).toBeLessThan(0.01);
+        }
+    });
+    // Blueprint
+    it('blueprint step 1 = journal (initial recognition)', () => {
+        const r = calculateLease({ ...base, startDate: '2025-01-01' });
+        expect(r.blueprint.steps[0].action).toBe('journal');
+    });
+    it('blueprint step 2 = fixed-asset (ROU registration)', () => {
+        const r = calculateLease({ ...base, startDate: '2025-01-01' });
+        expect(r.blueprint.steps[1].action).toBe('fixed-asset');
+    });
+    it('blueprint has correct step count (1 recognition + 1 FA + N payments)', () => {
+        const r = calculateLease({ ...base, startDate: '2025-01-01' });
+        expect(r.blueprint.steps).toHaveLength(38); // 1 + 1 + 36
+    });
+    it('blueprint null without startDate', () => {
+        const r = calculateLease(base);
+        expect(r.blueprint).toBeNull();
+    });
+    it('capsuleDescription contains IFRS 16', () => {
+        const r = calculateLease({ ...base, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleDescription).toContain('IFRS 16');
+    });
+});
+describe('calculateLease (hire purchase)', () => {
+    it('isHirePurchase is true when usefulLifeMonths provided', () => {
+        const r = calculateLease({ monthlyPayment: 5000, termMonths: 36, annualRate: 5, usefulLifeMonths: 60 });
+        expect(r.isHirePurchase).toBe(true);
+    });
+    it('depreciation months = useful life (not term)', () => {
+        const r = calculateLease({ monthlyPayment: 5000, termMonths: 36, annualRate: 5, usefulLifeMonths: 60 });
+        expect(r.depreciationMonths).toBe(60);
+    });
+    it('treats usefulLifeMonths == termMonths as HP', () => {
+        const r = calculateLease({ monthlyPayment: 5000, termMonths: 36, annualRate: 5, usefulLifeMonths: 36 });
+        expect(r.isHirePurchase).toBe(true);
+        expect(r.depreciationMonths).toBe(36);
+    });
+    it('rejects usefulLifeMonths < termMonths', () => {
+        expect(() => calculateLease({
+            monthlyPayment: 5000, termMonths: 36, annualRate: 5, usefulLifeMonths: 24,
+        })).toThrow(CalcValidationError);
+    });
+    it('HP blueprint capsuleType is Hire Purchase', () => {
+        const r = calculateLease({
+            monthlyPayment: 5000, termMonths: 36, annualRate: 5, usefulLifeMonths: 60, startDate: '2025-01-01',
+        });
+        expect(r.blueprint.capsuleType).toBe('Hire Purchase');
+    });
+});
+describe('calculateLease (validation)', () => {
+    it('rejects negative payment', () => {
+        expect(() => calculateLease({ monthlyPayment: -5000, termMonths: 36, annualRate: 5 })).toThrow(CalcValidationError);
+    });
+    it('rejects zero term', () => {
+        expect(() => calculateLease({ monthlyPayment: 5000, termMonths: 0, annualRate: 5 })).toThrow(CalcValidationError);
+    });
+});

package/dist/__tests__/loan.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import { calculateLoan } from '../calc/loan.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateLoan', () => {
+    const base = { principal: 100000, annualRate: 6, termMonths: 12 };
+    it('produces correct schedule length', () => {
+        const r = calculateLoan(base);
+        expect(r.schedule).toHaveLength(12);
+    });
+    it('final closing balance is exactly zero', () => {
+        const r = calculateLoan(base);
+        expect(r.schedule[r.schedule.length - 1].closingBalance).toBe(0);
+    });
+    it('total principal equals loan principal', () => {
+        const r = calculateLoan(base);
+        expect(r.totalPrincipal).toBe(100000);
+    });
+    it('total payments = principal + interest', () => {
+        const r = calculateLoan(base);
+        expect(r.totalPayments).toBe(r.totalPrincipal + r.totalInterest);
+    });
+    it('opening balance = previous closing balance', () => {
+        const r = calculateLoan({ ...base, termMonths: 60 });
+        for (let i = 1; i < r.schedule.length; i++) {
+            expect(r.schedule[i].openingBalance).toBe(r.schedule[i - 1].closingBalance);
+        }
+    });
+    it('every journal entry is balanced (debits = credits)', () => {
+        const r = calculateLoan({ ...base, termMonths: 60 });
+        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(Math.abs(debits - credits)).toBeLessThan(0.01);
+        }
+    });
+    it('all amounts are 2dp (round2 invariant)', () => {
+        const r = calculateLoan(base);
+        const round2 = (n) => Math.round(n * 100) / 100;
+        for (const row of r.schedule) {
+            expect(round2(row.interest)).toBe(row.interest);
+            expect(round2(row.principal)).toBe(row.principal);
+        }
+    });
+    // Blueprint
+    it('blueprint is null when no startDate', () => {
+        const r = calculateLoan(base);
+        expect(r.blueprint).toBeNull();
+    });
+    it('blueprint present when startDate given', () => {
+        const r = calculateLoan({ ...base, startDate: '2025-01-01' });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint step 1 is cash-in (loan disbursement)', () => {
+        const r = calculateLoan({ ...base, startDate: '2025-01-01' });
+        expect(r.blueprint.steps[0].action).toBe('cash-in');
+    });
+    it('blueprint has correct step count (1 disbursement + N payments)', () => {
+        const r = calculateLoan({ ...base, startDate: '2025-01-01' });
+        expect(r.blueprint.steps).toHaveLength(13); // 1 + 12
+    });
+    it('currency passes through to result', () => {
+        const r = calculateLoan({ ...base, currency: 'SGD' });
+        expect(r.currency).toBe('SGD');
+    });
+    it('currency null when not provided', () => {
+        const r = calculateLoan(base);
+        expect(r.currency).toBeNull();
+    });
+    // Validation
+    it('rejects negative principal', () => {
+        expect(() => calculateLoan({ ...base, principal: -100 })).toThrow(CalcValidationError);
+    });
+    it('rejects zero term', () => {
+        expect(() => calculateLoan({ ...base, termMonths: 0 })).toThrow(CalcValidationError);
+    });
+    it('rejects invalid date format', () => {
+        expect(() => calculateLoan({ ...base, startDate: '01-01-2025' })).toThrow(CalcValidationError);
+    });
+});

package/dist/__tests__/provision.test.js

@@ -0,0 +1,141 @@
+import { describe, it, expect } from 'vitest';
+import { calculateProvision } from '../calc/provision.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateProvision (standard)', () => {
+    const base = { amount: 500000, annualRate: 4, termMonths: 60 };
+    it('PV < nominal amount', () => {
+        const r = calculateProvision(base);
+        expect(r.presentValue).toBeLessThan(r.nominalAmount);
+    });
+    it('totalUnwinding = nominal - PV', () => {
+        const r = calculateProvision(base);
+        expect(r.totalUnwinding).toBe(Math.round((r.nominalAmount - r.presentValue) * 100) / 100);
+    });
+    it('schedule length = termMonths', () => {
+        const r = calculateProvision(base);
+        expect(r.schedule).toHaveLength(60);
+    });
+    it('final closing balance = nominal amount exactly', () => {
+        const r = calculateProvision(base);
+        expect(r.schedule[r.schedule.length - 1].closingBalance).toBe(500000);
+    });
+    it('opening balance = previous closing balance', () => {
+        const r = calculateProvision(base);
+        for (let i = 1; i < r.schedule.length; i++) {
+            expect(r.schedule[i].openingBalance).toBe(r.schedule[i - 1].closingBalance);
+        }
+    });
+    it('first opening balance = PV', () => {
+        const r = calculateProvision(base);
+        expect(r.schedule[0].openingBalance).toBe(r.presentValue);
+    });
+    it('all interest amounts are positive', () => {
+        const r = calculateProvision(base);
+        for (const row of r.schedule) {
+            expect(row.interest).toBeGreaterThan(0);
+        }
+    });
+    it('closing balance increases monotonically (unwinding)', () => {
+        const r = calculateProvision(base);
+        for (let i = 1; i < r.schedule.length; i++) {
+            expect(r.schedule[i].closingBalance).toBeGreaterThan(r.schedule[i - 1].openingBalance);
+        }
+    });
+});
+describe('calculateProvision (journal entries)', () => {
+    const base = { amount: 500000, annualRate: 4, termMonths: 60 };
+    it('initial journal: debits Provision Expense, credits Provision for Obligations', () => {
+        const r = calculateProvision(base);
+        expect(r.initialJournal.lines[0].account).toBe('Provision Expense');
+        expect(r.initialJournal.lines[0].debit).toBe(r.presentValue);
+        expect(r.initialJournal.lines[1].account).toBe('Provision for Obligations');
+        expect(r.initialJournal.lines[1].credit).toBe(r.presentValue);
+    });
+    it('initial journal is balanced', () => {
+        const r = calculateProvision(base);
+        const debits = r.initialJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.initialJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(debits).toBe(credits);
+    });
+    it('unwinding journals: debits Finance Cost, credits Provision', () => {
+        const r = calculateProvision(base);
+        for (const row of r.schedule) {
+            expect(row.journal.lines[0].account).toBe('Finance Cost \u2014 Unwinding');
+            expect(row.journal.lines[1].account).toBe('Provision for Obligations');
+        }
+    });
+    it('every unwinding journal is balanced', () => {
+        const r = calculateProvision(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('calculateProvision (blueprint)', () => {
+    it('blueprint present when startDate given', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 60, startDate: '2025-01-01' });
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint null without startDate', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 60 });
+        expect(r.blueprint).toBeNull();
+    });
+    it('step count = 1 recognition + N unwinding + 1 settlement', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.steps).toHaveLength(14); // 1 + 12 + 1
+    });
+    it('step 1 = journal (initial recognition)', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.steps[0].action).toBe('journal');
+    });
+    it('last step = cash-out (settlement)', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        const lastStep = r.blueprint.steps[r.blueprint.steps.length - 1];
+        expect(lastStep.action).toBe('cash-out');
+    });
+    it('settlement amount = nominal obligation', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        const lastStep = r.blueprint.steps[r.blueprint.steps.length - 1];
+        const debits = lastStep.lines.reduce((s, l) => s + l.debit, 0);
+        expect(debits).toBe(500000);
+    });
+    it('capsuleType is Provisions', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleType).toBe('Provisions');
+    });
+    it('capsuleDescription contains IAS 37', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, startDate: '2025-01-01' });
+        expect(r.blueprint.capsuleDescription).toContain('IAS 37');
+    });
+});
+describe('calculateProvision (currency)', () => {
+    it('currency passes through', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12, currency: 'SGD' });
+        expect(r.currency).toBe('SGD');
+    });
+    it('currency null when not provided', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 4, termMonths: 12 });
+        expect(r.currency).toBeNull();
+    });
+});
+describe('calculateProvision (validation)', () => {
+    it('rejects zero amount', () => {
+        expect(() => calculateProvision({ amount: 0, annualRate: 4, termMonths: 60 })).toThrow(CalcValidationError);
+    });
+    it('rejects negative rate', () => {
+        expect(() => calculateProvision({ amount: 500000, annualRate: -1, termMonths: 60 })).toThrow(CalcValidationError);
+    });
+    it('rejects zero term', () => {
+        expect(() => calculateProvision({ amount: 500000, annualRate: 4, termMonths: 0 })).toThrow(CalcValidationError);
+    });
+    it('rejects invalid date format', () => {
+        expect(() => calculateProvision({ amount: 500000, annualRate: 4, termMonths: 60, startDate: '01-01-2025' })).toThrow(CalcValidationError);
+    });
+    it('allows zero discount rate', () => {
+        const r = calculateProvision({ amount: 500000, annualRate: 0, termMonths: 12 });
+        expect(r.presentValue).toBe(500000); // no discounting
+    });
+});