jaz-cli 2.6.0 → 2.7.0

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

package/dist/__tests__/validate.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { CalcValidationError, validatePositive, validateNonNegative, validatePositiveInteger, validateSalvageLessThanCost, validateDateFormat, validateRate, } from '../calc/validate.js';
+describe('validatePositive', () => {
+    it('passes for positive values', () => {
+        expect(() => validatePositive(1, 'x')).not.toThrow();
+        expect(() => validatePositive(0.01, 'x')).not.toThrow();
+        expect(() => validatePositive(1_000_000, 'x')).not.toThrow();
+    });
+    it('rejects zero', () => {
+        expect(() => validatePositive(0, 'Amount')).toThrow(CalcValidationError);
+        expect(() => validatePositive(0, 'Amount')).toThrow('positive number');
+    });
+    it('rejects negative', () => {
+        expect(() => validatePositive(-5, 'Principal')).toThrow(CalcValidationError);
+    });
+    it('rejects NaN and Infinity', () => {
+        expect(() => validatePositive(NaN, 'x')).toThrow(CalcValidationError);
+        expect(() => validatePositive(Infinity, 'x')).toThrow(CalcValidationError);
+    });
+});
+describe('validateNonNegative', () => {
+    it('passes for zero and positive', () => {
+        expect(() => validateNonNegative(0, 'x')).not.toThrow();
+        expect(() => validateNonNegative(100, 'x')).not.toThrow();
+    });
+    it('rejects negative', () => {
+        expect(() => validateNonNegative(-1, 'Salvage')).toThrow(CalcValidationError);
+        expect(() => validateNonNegative(-1, 'Salvage')).toThrow('zero or positive');
+    });
+});
+describe('validatePositiveInteger', () => {
+    it('passes for positive integers', () => {
+        expect(() => validatePositiveInteger(1, 'x')).not.toThrow();
+        expect(() => validatePositiveInteger(60, 'x')).not.toThrow();
+    });
+    it('rejects zero', () => {
+        expect(() => validatePositiveInteger(0, 'Term')).toThrow(CalcValidationError);
+    });
+    it('rejects non-integers', () => {
+        expect(() => validatePositiveInteger(1.5, 'Term')).toThrow(CalcValidationError);
+    });
+    it('rejects negative integers', () => {
+        expect(() => validatePositiveInteger(-3, 'Term')).toThrow(CalcValidationError);
+    });
+});
+describe('validateSalvageLessThanCost', () => {
+    it('passes when salvage < cost', () => {
+        expect(() => validateSalvageLessThanCost(5000, 50000)).not.toThrow();
+    });
+    it('rejects when salvage >= cost', () => {
+        expect(() => validateSalvageLessThanCost(50000, 50000)).toThrow(CalcValidationError);
+        expect(() => validateSalvageLessThanCost(60000, 50000)).toThrow(CalcValidationError);
+    });
+});
+describe('validateDateFormat', () => {
+    it('passes for valid YYYY-MM-DD', () => {
+        expect(() => validateDateFormat('2025-01-01')).not.toThrow();
+        expect(() => validateDateFormat('2025-12-31')).not.toThrow();
+    });
+    it('passes for undefined (optional)', () => {
+        expect(() => validateDateFormat(undefined)).not.toThrow();
+    });
+    it('rejects wrong format', () => {
+        expect(() => validateDateFormat('01-01-2025')).toThrow(CalcValidationError);
+        expect(() => validateDateFormat('2025/01/01')).toThrow(CalcValidationError);
+        expect(() => validateDateFormat('Jan 1 2025')).toThrow(CalcValidationError);
+    });
+    it('rejects invalid dates', () => {
+        expect(() => validateDateFormat('2025-13-01')).toThrow(CalcValidationError);
+    });
+});
+describe('validateRate', () => {
+    it('passes for normal rates', () => {
+        expect(() => validateRate(0, 'Rate')).not.toThrow();
+        expect(() => validateRate(6, 'Rate')).not.toThrow();
+        expect(() => validateRate(100, 'Rate')).not.toThrow();
+    });
+    it('rejects negative rates', () => {
+        expect(() => validateRate(-1, 'Rate')).toThrow(CalcValidationError);
+    });
+});

package/dist/calc/asset-disposal.js

@@ -77,19 +77,23 @@ export function calculateAssetDisposal(inputs) {
     validateNonNegative(proceeds, 'Disposal proceeds');
     validateDateFormat(acquisitionDate);
     validateDateFormat(disposalDate);
+    // Normalize monetary inputs to 2dp to guarantee balanced journals
+    const cost2 = round2(cost);
+    const salvage2 = round2(salvageValue);
+    const proceeds2 = round2(proceeds);
     // Validate disposal is after acquisition
     if (disposalDate <= acquisitionDate) {
         throw new CalcValidationError('Disposal date must be after acquisition date.');
     }
     const monthsHeld = monthsBetween(acquisitionDate, disposalDate);
-    const accumulatedDepreciation = computeAccumDepreciation(cost, salvageValue, usefulLifeYears, method, monthsHeld);
-    const netBookValue = round2(cost - accumulatedDepreciation);
-    const gainOrLoss = round2(proceeds - netBookValue);
+    const accumulatedDepreciation = computeAccumDepreciation(cost2, salvage2, usefulLifeYears, method, monthsHeld);
+    const netBookValue = round2(cost2 - accumulatedDepreciation);
+    const gainOrLoss = round2(proceeds2 - netBookValue);
     const isGain = gainOrLoss >= 0;
     // Build disposal journal entry
     const lines = [];
-    if (proceeds > 0) {
-        lines.push({ account: 'Cash / Bank Account', debit: proceeds, credit: 0 });
+    if (proceeds2 > 0) {
+        lines.push({ account: 'Cash / Bank Account', debit: proceeds2, credit: 0 });
     }
     if (accumulatedDepreciation > 0) {
         lines.push({ account: 'Accumulated Depreciation', debit: accumulatedDepreciation, credit: 0 });
@@ -97,7 +101,7 @@ export function calculateAssetDisposal(inputs) {
     if (!isGain) {
         lines.push({ account: 'Loss on Disposal', debit: Math.abs(gainOrLoss), credit: 0 });
     }
-    lines.push({ account: 'Fixed Asset (at cost)', debit: 0, credit: cost });
+    lines.push({ account: 'Fixed Asset (at cost)', debit: 0, credit: cost2 });
     if (isGain && gainOrLoss > 0) {
         lines.push({ account: 'Gain on Disposal', debit: 0, credit: gainOrLoss });
     }
@@ -110,16 +114,16 @@ export function calculateAssetDisposal(inputs) {
     const methodLabel = method === 'sl' ? 'Straight-line' : method === 'ddb' ? 'Double declining' : '150% declining';
     const workings = [
         `Asset Disposal Workings (IAS 16)`,
-        `Cost: ${fmtAmt(cost, c)} | Salvage: ${fmtAmt(salvageValue, c)} | Life: ${usefulLifeYears} years (${methodLabel})`,
+        `Cost: ${fmtAmt(cost2, c)} | Salvage: ${fmtAmt(salvage2, c)} | Life: ${usefulLifeYears} years (${methodLabel})`,
         `Acquired: ${acquisitionDate} | Disposed: ${disposalDate} | Held: ${monthsHeld} months`,
         `Accumulated depreciation: ${fmtAmt(accumulatedDepreciation, c)} | NBV: ${fmtAmt(netBookValue, c)}`,
-        `Proceeds: ${fmtAmt(proceeds, c)} | ${isGain ? (gainOrLoss > 0 ? `Gain: ${fmtAmt(gainOrLoss, c)}` : 'At book value (no gain/loss)') : `Loss: ${fmtAmt(Math.abs(gainOrLoss), c)}`}`,
-        `Method: IAS 16.68 — Gain/Loss = Proceeds − NBV = ${fmtAmt(proceeds, c)} − ${fmtAmt(netBookValue, c)} = ${fmtAmt(gainOrLoss, c)}`,
+        `Proceeds: ${fmtAmt(proceeds2, c)} | ${isGain ? (gainOrLoss > 0 ? `Gain: ${fmtAmt(gainOrLoss, c)}` : 'At book value (no gain/loss)') : `Loss: ${fmtAmt(Math.abs(gainOrLoss), c)}`}`,
+        `Method: IAS 16.68 — Gain/Loss = Proceeds − NBV = ${fmtAmt(proceeds2, c)} − ${fmtAmt(netBookValue, c)} = ${fmtAmt(gainOrLoss, c)}`,
     ].join('\n');
     let blueprint = null;
     blueprint = {
         capsuleType: 'Asset Disposal',
-        capsuleName: `Asset Disposal — ${fmtCapsuleAmount(cost, currency)} asset — ${disposalDate}`,
+        capsuleName: `Asset Disposal — ${fmtCapsuleAmount(cost2, currency)} asset — ${disposalDate}`,
         capsuleDescription: workings,
         tags: ['Asset Disposal'],
         customFields: { 'Asset Description': null },
@@ -132,12 +136,12 @@ export function calculateAssetDisposal(inputs) {
         type: 'asset-disposal',
         currency: currency ?? null,
         inputs: {
-            cost,
-            salvageValue,
+            cost: cost2,
+            salvageValue: salvage2,
             usefulLifeYears,
             acquisitionDate,
             disposalDate,
-            proceeds,
+            proceeds: proceeds2,
             method,
         },
         monthsHeld,

package/dist/calc/fixed-deposit.js

@@ -10,7 +10,7 @@
  */
 import { fv } from 'financial';
 import { round2, addMonths } from './types.js';
-import { validatePositive, validatePositiveInteger, validateDateFormat, validateRate } from './validate.js';
+import { CalcValidationError, validatePositive, validatePositiveInteger, validateDateFormat, validateRate } from './validate.js';
 import { journalStep, cashOutStep, cashInStep, fmtCapsuleAmount, fmtAmt } from './blueprint.js';
 export function calculateFixedDeposit(inputs) {
     const { principal, annualRate, termMonths, compounding = 'none', startDate, currency, } = inputs;
@@ -18,26 +18,28 @@ export function calculateFixedDeposit(inputs) {
     validateRate(annualRate, 'Annual rate');
     validatePositiveInteger(termMonths, 'Term (months)');
     validateDateFormat(startDate);
-    const monthlyRate = annualRate / 100 / 12;
-    // Compute total interest based on compounding method
+    // Compound interval validation — term must align with compounding frequency
+    const compIntervalMonths = compounding === 'monthly' ? 1 : compounding === 'quarterly' ? 3 : compounding === 'annually' ? 12 : 0;
+    if (compounding !== 'none' && termMonths % compIntervalMonths !== 0) {
+        throw new CalcValidationError(`Term (${termMonths} months) must be a multiple of ${compIntervalMonths} for ${compounding} compounding.`);
+    }
+    // Compute maturity value
     let maturityValue;
     if (compounding === 'none') {
         // Simple interest: Principal × Rate × Time
         maturityValue = round2(principal + principal * (annualRate / 100) * (termMonths / 12));
     }
     else {
-        // Compound interest using fv() from financial package
-        // fv(rate, nper, pmt, pv) — returns negative, negate
-        const periodsPerYear = compounding === 'monthly' ? 12 : compounding === 'quarterly' ? 4 : 1;
+        // Compound interest using fv() — one consistent periodic rate
+        const periodsPerYear = 12 / compIntervalMonths;
         const compoundRate = annualRate / 100 / periodsPerYear;
-        const totalCompoundPeriods = Math.floor(termMonths / (12 / periodsPerYear));
-        // fv() with negative pv (outflow) returns positive (inflow at maturity)
+        const totalCompoundPeriods = termMonths / compIntervalMonths;
         maturityValue = round2(fv(compoundRate, totalCompoundPeriods, 0, -principal));
     }
     const totalInterest = round2(maturityValue - principal);
     // Effective annual rate (for display)
     const effectiveRate = round2((Math.pow(maturityValue / principal, 12 / termMonths) - 1) * 100 * 100) / 100;
-    // Build monthly accrual schedule
+    // Build accrual schedule — accrue at compound intervals using the same periodic rate
     const schedule = [];
     let accruedTotal = 0;
     if (compounding === 'none') {
@@ -67,31 +69,38 @@ export function calculateFixedDeposit(inputs) {
         }
     }
     else {
-        // Compound interest: effective interest on growing carrying amount
+        // Compound interest: accrue at compound intervals using the periodic rate
+        // e.g. quarterly = every 3 months, interest accrues on the growing carrying amount
+        const periodicRate = annualRate / 100 / (12 / compIntervalMonths);
         let balance = principal;
-        for (let i = 1; i <= termMonths; i++) {
+        const totalPeriods = termMonths / compIntervalMonths;
+        for (let p = 1; p <= totalPeriods; p++) {
             const openingBalance = round2(balance);
-            const isFinal = i === termMonths;
+            const isFinal = p === totalPeriods;
             let interest;
             if (isFinal) {
                 // Final period: close to exact maturity value
                 interest = round2(maturityValue - openingBalance);
             }
             else {
-                interest = round2(openingBalance * monthlyRate);
+                interest = round2(openingBalance * periodicRate);
             }
             balance = round2(openingBalance + interest);
             accruedTotal = round2(accruedTotal + interest);
-            const date = startDate ? addMonths(startDate, i) : null;
+            const monthOffset = p * compIntervalMonths;
+            const date = startDate ? addMonths(startDate, monthOffset) : null;
+            const periodLabel = compounding === 'monthly'
+                ? `Month ${p}` : compounding === 'quarterly'
+                ? `Quarter ${p}` : `Year ${p}`;
             const journal = {
-                description: `Interest accrual — Month ${i} of ${termMonths}`,
+                description: `Interest accrual — ${periodLabel} of ${totalPeriods}`,
                 lines: [
                     { account: 'Accrued Interest Receivable', debit: interest, credit: 0 },
                     { account: 'Interest Income', debit: 0, credit: interest },
                 ],
             };
             schedule.push({
-                period: i,
+                period: p,
                 date,
                 openingBalance,
                 interest,
@@ -121,7 +130,7 @@ export function calculateFixedDeposit(inputs) {
         const steps = [
             cashOutStep(1, 'Transfer funds from operating account to fixed deposit', startDate, placementJournal.lines),
             ...schedule.map((row, idx) => journalStep(idx + 2, row.journal.description, row.date, row.journal.lines)),
-            cashInStep(termMonths + 2, 'Fixed deposit maturity — principal + accrued interest returned to Cash', addMonths(startDate, termMonths), maturityJournal.lines),
+            cashInStep(schedule.length + 2, 'Fixed deposit maturity — principal + accrued interest returned to Cash', addMonths(startDate, termMonths), maturityJournal.lines),
         ];
         const c = currency ?? undefined;
         const compoundLabel = compounding === 'none' ? 'Simple interest' : `Compound ${compounding}`;

package/dist/calc/lease.js

@@ -11,17 +11,21 @@
  */
 import { pv } from 'financial';
 import { round2, addMonths } from './types.js';
-import { validatePositive, validatePositiveInteger, validateDateFormat, validateRate } from './validate.js';
+import { CalcValidationError, validatePositive, validatePositiveInteger, validateDateFormat, validateRate } from './validate.js';
 import { journalStep, fixedAssetStep, fmtCapsuleAmount, fmtAmt } from './blueprint.js';
 export function calculateLease(inputs) {
     const { monthlyPayment, termMonths, annualRate, usefulLifeMonths, startDate, currency } = inputs;
     validatePositive(monthlyPayment, 'Monthly payment');
     validateRate(annualRate, 'Annual rate (IBR)');
     validatePositiveInteger(termMonths, 'Term (months)');
-    if (usefulLifeMonths !== undefined)
+    if (usefulLifeMonths !== undefined) {
         validatePositiveInteger(usefulLifeMonths, 'Useful life (months)');
+        if (usefulLifeMonths < termMonths) {
+            throw new CalcValidationError(`Useful life (${usefulLifeMonths} months) must be >= lease term (${termMonths} months) for hire purchase.`);
+        }
+    }
     validateDateFormat(startDate);
-    const isHirePurchase = usefulLifeMonths !== undefined && usefulLifeMonths > termMonths;
+    const isHirePurchase = usefulLifeMonths !== undefined;
     const monthlyRate = annualRate / 100 / 12;
     // PV of an ordinary annuity (payments at end of period)
     // pv() returns negative, negate for positive value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaz-cli",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "CLI to install Jaz AI skills for Claude Code",
   "type": "module",
   "bin": {
@@ -13,6 +13,8 @@
   "scripts": {
     "build": "tsc && node --input-type=module -e \"import{readFileSync,writeFileSync}from'fs';const c=readFileSync('dist/index.js','utf8');if(!c.startsWith('#!')){writeFileSync('dist/index.js','#!/usr/bin/env node\\n'+c)}\"",
     "dev": "node --loader ts-node/esm src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -45,6 +47,7 @@
   "devDependencies": {
     "@types/node": "^22.10.1",
     "@types/prompts": "^2.4.9",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.18"
   }
 }