jaz-cli 2.5.0 → 2.7.0

package/dist/__tests__/asset-disposal.test.js

@@ -0,0 +1,249 @@
+import { describe, it, expect } from 'vitest';
+import { calculateAssetDisposal } from '../calc/asset-disposal.js';
+import { CalcValidationError } from '../calc/validate.js';
+describe('calculateAssetDisposal (gain)', () => {
+    const base = {
+        cost: 50000,
+        salvageValue: 5000,
+        usefulLifeYears: 5,
+        acquisitionDate: '2022-01-01',
+        disposalDate: '2025-06-15',
+        proceeds: 20000,
+    };
+    it('NBV = cost - accumulated depreciation', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.netBookValue).toBe(r.inputs.cost - r.accumulatedDepreciation);
+    });
+    it('gainOrLoss = proceeds - NBV', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.gainOrLoss).toBe(r.inputs.proceeds - r.netBookValue);
+    });
+    it('isGain is true when proceeds > NBV', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.isGain).toBe(true);
+    });
+    it('monthsHeld is calculated correctly', () => {
+        const r = calculateAssetDisposal(base);
+        // Jan 2022 to Jun 2025 = 42 months, day 15 >= day 01 so +1 = 42
+        expect(r.monthsHeld).toBe(42);
+    });
+    it('journal is balanced', () => {
+        const r = calculateAssetDisposal(base);
+        const debits = r.disposalJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.disposalJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(Math.abs(debits - credits)).toBeLessThan(0.01);
+    });
+    it('journal includes Cash, Accum Dep, FA at cost, and Gain', () => {
+        const r = calculateAssetDisposal(base);
+        const accounts = r.disposalJournal.lines.map(l => l.account);
+        expect(accounts).toContain('Cash / Bank Account');
+        expect(accounts).toContain('Accumulated Depreciation');
+        expect(accounts).toContain('Fixed Asset (at cost)');
+        expect(accounts).toContain('Gain on Disposal');
+    });
+});
+describe('calculateAssetDisposal (loss)', () => {
+    const base = {
+        cost: 50000,
+        salvageValue: 5000,
+        usefulLifeYears: 5,
+        acquisitionDate: '2022-01-01',
+        disposalDate: '2023-06-15',
+        proceeds: 5000, // low proceeds = loss
+    };
+    it('isGain is false when proceeds < NBV', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.isGain).toBe(false);
+        expect(r.gainOrLoss).toBeLessThan(0);
+    });
+    it('journal includes Loss on Disposal', () => {
+        const r = calculateAssetDisposal(base);
+        const accounts = r.disposalJournal.lines.map(l => l.account);
+        expect(accounts).toContain('Loss on Disposal');
+        expect(accounts).not.toContain('Gain on Disposal');
+    });
+    it('journal is balanced', () => {
+        const r = calculateAssetDisposal(base);
+        const debits = r.disposalJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.disposalJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(Math.abs(debits - credits)).toBeLessThan(0.01);
+    });
+});
+describe('calculateAssetDisposal (scrap / write-off)', () => {
+    const base = {
+        cost: 50000,
+        salvageValue: 5000,
+        usefulLifeYears: 5,
+        acquisitionDate: '2022-01-01',
+        disposalDate: '2024-01-01',
+        proceeds: 0,
+    };
+    it('gainOrLoss is negative (loss) when proceeds = 0', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.isGain).toBe(false);
+        expect(r.gainOrLoss).toBeLessThan(0);
+    });
+    it('journal has no Cash line when proceeds = 0', () => {
+        const r = calculateAssetDisposal(base);
+        const accounts = r.disposalJournal.lines.map(l => l.account);
+        expect(accounts).not.toContain('Cash / Bank Account');
+    });
+    it('journal is still balanced', () => {
+        const r = calculateAssetDisposal(base);
+        const debits = r.disposalJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.disposalJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(Math.abs(debits - credits)).toBeLessThan(0.01);
+    });
+});
+describe('calculateAssetDisposal (at book value)', () => {
+    it('gainOrLoss = 0 and isGain = true when proceeds = NBV', () => {
+        // Fully depreciated over 5 years: NBV = salvage = 5000
+        const r = calculateAssetDisposal({
+            cost: 50000,
+            salvageValue: 5000,
+            usefulLifeYears: 5,
+            acquisitionDate: '2020-01-01',
+            disposalDate: '2025-01-01',
+            proceeds: 5000, // exactly = salvage (fully depreciated)
+        });
+        expect(r.gainOrLoss).toBe(0);
+        expect(r.isGain).toBe(true);
+    });
+});
+describe('calculateAssetDisposal (fully depreciated)', () => {
+    it('accum dep capped at depreciable base (held past useful life)', () => {
+        const r = calculateAssetDisposal({
+            cost: 50000,
+            salvageValue: 5000,
+            usefulLifeYears: 5,
+            acquisitionDate: '2018-01-01', // held 7+ years
+            disposalDate: '2025-06-01',
+            proceeds: 3000,
+        });
+        expect(r.accumulatedDepreciation).toBe(45000); // max = cost - salvage
+        expect(r.netBookValue).toBe(5000);
+    });
+});
+describe('calculateAssetDisposal (DDB method)', () => {
+    it('DDB accumulated dep is correct', () => {
+        const r = calculateAssetDisposal({
+            cost: 50000,
+            salvageValue: 5000,
+            usefulLifeYears: 5,
+            acquisitionDate: '2022-01-01',
+            disposalDate: '2022-12-31', // ~12 months (monthsBetween rounds up partial)
+            proceeds: 30000,
+            method: 'ddb',
+        });
+        // DDB year 1: 50000 * 2/5 = 20000
+        expect(r.accumulatedDepreciation).toBe(20000);
+        expect(r.netBookValue).toBe(30000);
+        expect(r.gainOrLoss).toBe(0); // proceeds = NBV
+    });
+    it('DDB journal is balanced', () => {
+        const r = calculateAssetDisposal({
+            cost: 50000,
+            salvageValue: 5000,
+            usefulLifeYears: 5,
+            acquisitionDate: '2022-01-01',
+            disposalDate: '2024-06-15',
+            proceeds: 10000,
+            method: 'ddb',
+        });
+        const debits = r.disposalJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.disposalJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(Math.abs(debits - credits)).toBeLessThan(0.01);
+    });
+});
+describe('calculateAssetDisposal (rounding)', () => {
+    it('normalizes inputs to 2dp and journals still balance', () => {
+        const r = calculateAssetDisposal({
+            cost: 50000.999,
+            salvageValue: 5000.111,
+            usefulLifeYears: 5,
+            acquisitionDate: '2022-01-01',
+            disposalDate: '2024-01-01',
+            proceeds: 20000.555,
+        });
+        // Inputs should be normalized
+        expect(r.inputs.cost).toBe(50001);
+        expect(r.inputs.salvageValue).toBe(5000.11);
+        expect(r.inputs.proceeds).toBe(20000.56);
+        // Journal must still balance
+        const debits = r.disposalJournal.lines.reduce((s, l) => s + l.debit, 0);
+        const credits = r.disposalJournal.lines.reduce((s, l) => s + l.credit, 0);
+        expect(Math.abs(debits - credits)).toBeLessThan(0.01);
+    });
+});
+describe('calculateAssetDisposal (blueprint)', () => {
+    const base = {
+        cost: 50000,
+        salvageValue: 5000,
+        usefulLifeYears: 5,
+        acquisitionDate: '2022-01-01',
+        disposalDate: '2025-06-15',
+        proceeds: 20000,
+    };
+    it('blueprint always present (no startDate needed)', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.blueprint).not.toBeNull();
+        expect(r.blueprint.capsuleDescription).toBeTruthy();
+    });
+    it('blueprint has 2 steps (journal + note)', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.blueprint.steps).toHaveLength(2);
+    });
+    it('step 1 = journal (disposal entry)', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.blueprint.steps[0].action).toBe('journal');
+    });
+    it('step 2 = note (FA register update)', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.blueprint.steps[1].action).toBe('note');
+    });
+    it('capsuleType is Asset Disposal', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.blueprint.capsuleType).toBe('Asset Disposal');
+    });
+    it('capsuleDescription contains IAS 16', () => {
+        const r = calculateAssetDisposal(base);
+        expect(r.blueprint.capsuleDescription).toContain('IAS 16');
+    });
+});
+describe('calculateAssetDisposal (validation)', () => {
+    const base = {
+        cost: 50000,
+        salvageValue: 5000,
+        usefulLifeYears: 5,
+        acquisitionDate: '2022-01-01',
+        disposalDate: '2025-06-15',
+        proceeds: 20000,
+    };
+    it('rejects zero cost', () => {
+        expect(() => calculateAssetDisposal({ ...base, cost: 0 })).toThrow(CalcValidationError);
+    });
+    it('rejects negative proceeds', () => {
+        expect(() => calculateAssetDisposal({ ...base, proceeds: -100 })).toThrow(CalcValidationError);
+    });
+    it('rejects salvage >= cost', () => {
+        expect(() => calculateAssetDisposal({ ...base, salvageValue: 50000 })).toThrow(CalcValidationError);
+    });
+    it('rejects disposal before acquisition', () => {
+        expect(() => calculateAssetDisposal({
+            ...base, acquisitionDate: '2025-01-01', disposalDate: '2024-01-01',
+        })).toThrow(CalcValidationError);
+    });
+    it('rejects invalid date format', () => {
+        expect(() => calculateAssetDisposal({
+            ...base, acquisitionDate: '01-01-2022',
+        })).toThrow(CalcValidationError);
+    });
+    it('allows zero salvage value', () => {
+        const r = calculateAssetDisposal({ ...base, salvageValue: 0 });
+        expect(r.accumulatedDepreciation).toBeGreaterThan(0);
+    });
+    it('allows zero proceeds (scrap)', () => {
+        const r = calculateAssetDisposal({ ...base, proceeds: 0 });
+        expect(r.isGain).toBe(false);
+    });
+});

package/dist/__tests__/blueprint.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import { journalStep, billStep, invoiceStep, cashOutStep, cashInStep, fixedAssetStep, noteStep, fmtCapsuleAmount, fmtAmt, } from '../calc/blueprint.js';
+describe('step builders', () => {
+    const lines = [
+        { account: 'Cash', debit: 100, credit: 0 },
+        { account: 'Loan', debit: 0, credit: 100 },
+    ];
+    it('journalStep sets action to journal', () => {
+        const s = journalStep(1, 'Test', '2025-01-01', lines);
+        expect(s.action).toBe('journal');
+        expect(s.step).toBe(1);
+        expect(s.description).toBe('Test');
+        expect(s.date).toBe('2025-01-01');
+        expect(s.lines).toBe(lines);
+    });
+    it('billStep sets action to bill', () => {
+        const s = billStep(1, 'Supplier bill', '2025-01-01', lines);
+        expect(s.action).toBe('bill');
+    });
+    it('invoiceStep sets action to invoice', () => {
+        const s = invoiceStep(1, 'Customer invoice', '2025-01-01', lines);
+        expect(s.action).toBe('invoice');
+    });
+    it('cashOutStep sets action to cash-out', () => {
+        const s = cashOutStep(1, 'Payment', '2025-01-01', lines);
+        expect(s.action).toBe('cash-out');
+    });
+    it('cashInStep sets action to cash-in', () => {
+        const s = cashInStep(1, 'Receipt', '2025-01-01', lines);
+        expect(s.action).toBe('cash-in');
+    });
+    it('fixedAssetStep sets action to fixed-asset with empty lines', () => {
+        const s = fixedAssetStep(2, 'Register ROU', '2025-01-01');
+        expect(s.action).toBe('fixed-asset');
+        expect(s.lines).toEqual([]);
+    });
+    it('noteStep sets action to note with empty lines', () => {
+        const s = noteStep(3, 'Update FA register');
+        expect(s.action).toBe('note');
+        expect(s.lines).toEqual([]);
+        expect(s.date).toBeNull();
+    });
+    it('null date passes through', () => {
+        const s = journalStep(1, 'Test', null, lines);
+        expect(s.date).toBeNull();
+    });
+});
+describe('fmtCapsuleAmount', () => {
+    it('formats with currency', () => {
+        expect(fmtCapsuleAmount(100000, 'SGD')).toBe('SGD 100,000');
+    });
+    it('formats without currency', () => {
+        expect(fmtCapsuleAmount(100000)).toBe('100,000');
+    });
+    it('formats small amounts', () => {
+        expect(fmtCapsuleAmount(50, 'USD')).toBe('USD 50');
+    });
+});
+describe('fmtAmt', () => {
+    it('formats with currency and 2dp', () => {
+        expect(fmtAmt(1234.5, 'SGD')).toBe('SGD 1,234.50');
+    });
+    it('formats without currency', () => {
+        expect(fmtAmt(1234.56)).toBe('1,234.56');
+    });
+    it('formats zero', () => {
+        expect(fmtAmt(0)).toBe('0.00');
+    });
+    it('handles null currency', () => {
+        expect(fmtAmt(100, null)).toBe('100.00');
+    });
+});

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