jaz-cli 2.5.0 → 2.7.0

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/amortization.js

@@ -4,7 +4,7 @@
  */
 import { round2, addMonths } from './types.js';
 import { validatePositive, validatePositiveInteger, validateDateFormat } from './validate.js';
-import { journalStep, fmtCapsuleAmount } from './blueprint.js';
+import { journalStep, billStep, invoiceStep, fmtCapsuleAmount, fmtAmt } from './blueprint.js';
 export function calculatePrepaidExpense(inputs) {
     const { amount, periods, frequency = 'monthly', startDate, currency } = inputs;
     validatePositive(amount, 'Amount');
@@ -14,15 +14,24 @@ export function calculatePrepaidExpense(inputs) {
     let blueprint = null;
     if (startDate) {
         const steps = [
-            journalStep(1, 'Initial prepaid payment (bill or cash-out entry)', startDate, [
+            billStep(1, 'Create bill from supplier coded to Prepaid Asset, then pay from Cash / Bank Account', startDate, [
                 { account: 'Prepaid Asset', debit: amount, credit: 0 },
                 { account: 'Cash / Bank Account', debit: 0, credit: amount },
             ]),
             ...schedule.map((row, idx) => journalStep(idx + 2, row.journal.description, row.date, row.journal.lines)),
         ];
+        const c = currency ?? undefined;
+        const workings = [
+            `Prepaid Expense Recognition Workings`,
+            `Total prepaid: ${fmtAmt(amount, c)} | Periods: ${periods} (${frequency})`,
+            `Per period: ${fmtAmt(round2(amount / periods), c)}`,
+            `Method: Straight-line recognition over ${periods} ${frequency} periods`,
+            `Rounding: 2dp per period, final period absorbs remainder`,
+        ].join('\n');
         blueprint = {
             capsuleType: 'Prepaid Expenses',
             capsuleName: `Prepaid Expense — ${fmtCapsuleAmount(amount, currency)} — ${periods} periods`,
+            capsuleDescription: workings,
             tags: ['Prepaid Expense'],
             customFields: { 'Policy / Contract #': null },
             steps,
@@ -46,15 +55,24 @@ export function calculateDeferredRevenue(inputs) {
     let blueprint = null;
     if (startDate) {
         const steps = [
-            journalStep(1, 'Initial deferred receipt (invoice or cash-in entry)', startDate, [
+            invoiceStep(1, 'Create invoice to customer coded to Deferred Revenue, record payment to Cash / Bank Account', startDate, [
                 { account: 'Cash / Bank Account', debit: amount, credit: 0 },
                 { account: 'Deferred Revenue', debit: 0, credit: amount },
             ]),
             ...schedule.map((row, idx) => journalStep(idx + 2, row.journal.description, row.date, row.journal.lines)),
         ];
+        const c2 = currency ?? undefined;
+        const workings2 = [
+            `Deferred Revenue Recognition Workings`,
+            `Total deferred: ${fmtAmt(amount, c2)} | Periods: ${periods} (${frequency})`,
+            `Per period: ${fmtAmt(round2(amount / periods), c2)}`,
+            `Method: Straight-line recognition over ${periods} ${frequency} periods`,
+            `Rounding: 2dp per period, final period absorbs remainder`,
+        ].join('\n');
         blueprint = {
             capsuleType: 'Deferred Revenue',
             capsuleName: `Deferred Revenue — ${fmtCapsuleAmount(amount, currency)} — ${periods} periods`,
+            capsuleDescription: workings2,
             tags: ['Deferred Revenue'],
             customFields: { 'Contract #': null },
             steps,

package/dist/calc/asset-disposal.js

@@ -0,0 +1,155 @@
+/**
+ * Asset disposal gain/loss calculator.
+ *
+ * Compliance references:
+ *  - IAS 16.67-72: Derecognition on disposal or when no future economic benefits expected
+ *  - IAS 16.68: Gain/loss = Net disposal proceeds - Carrying amount
+ *  - IAS 16.71: Gain ≠ revenue (classified separately in P&L)
+ *
+ * Computes depreciation to the disposal date (pro-rated partial period),
+ * then calculates NBV and gain/loss. Supports SL, DDB, and 150DB methods.
+ */
+import { round2 } from './types.js';
+import { CalcValidationError, validatePositive, validateNonNegative, validatePositiveInteger, validateSalvageLessThanCost, validateDateFormat, } from './validate.js';
+import { journalStep, noteStep, fmtCapsuleAmount, fmtAmt } from './blueprint.js';
+/**
+ * Count full months between two YYYY-MM-DD dates.
+ * Partial months are rounded up (any day in a month counts as a full month).
+ */
+function monthsBetween(from, to) {
+    const d1 = new Date(from + 'T00:00:00');
+    const d2 = new Date(to + 'T00:00:00');
+    const months = (d2.getFullYear() - d1.getFullYear()) * 12 + (d2.getMonth() - d1.getMonth());
+    // If disposal day > acquisition day, it's a partial month — round up
+    return d2.getDate() >= d1.getDate() ? months + 1 : Math.max(months, 0);
+}
+/**
+ * Compute accumulated depreciation from acquisition to disposal date.
+ */
+function computeAccumDepreciation(cost, salvageValue, usefulLifeYears, method, monthsHeld) {
+    const totalMonths = usefulLifeYears * 12;
+    const depreciableBase = round2(cost - salvageValue);
+    // Cap at useful life — asset is fully depreciated
+    const effectiveMonths = Math.min(monthsHeld, totalMonths);
+    if (method === 'sl') {
+        // Straight-line: pro-rate by months
+        const monthlyDep = depreciableBase / totalMonths;
+        return round2(Math.min(monthlyDep * effectiveMonths, depreciableBase));
+    }
+    // DDB / 150DB: compute year-by-year then pro-rate final partial year
+    const multiplier = method === 'ddb' ? 2 : 1.5;
+    const annualRate = multiplier / usefulLifeYears;
+    let bookValue = cost;
+    let totalDep = 0;
+    let monthsRemaining = effectiveMonths;
+    for (let year = 1; year <= usefulLifeYears && monthsRemaining > 0; year++) {
+        const remainingYears = usefulLifeYears - year + 1;
+        const ddbAmount = round2(bookValue * annualRate);
+        const slAmount = round2((bookValue - salvageValue) / remainingYears);
+        const useSL = slAmount >= ddbAmount || round2(bookValue - ddbAmount) < salvageValue;
+        let annualDep = useSL ? slAmount : ddbAmount;
+        // Don't breach salvage floor
+        if (round2(bookValue - annualDep) < salvageValue) {
+            annualDep = round2(bookValue - salvageValue);
+        }
+        if (monthsRemaining >= 12) {
+            // Full year
+            totalDep = round2(totalDep + annualDep);
+            bookValue = round2(bookValue - annualDep);
+            monthsRemaining -= 12;
+        }
+        else {
+            // Partial year: pro-rate
+            const partialDep = round2(annualDep * monthsRemaining / 12);
+            totalDep = round2(totalDep + partialDep);
+            monthsRemaining = 0;
+        }
+    }
+    return Math.min(totalDep, depreciableBase);
+}
+export function calculateAssetDisposal(inputs) {
+    const { cost, salvageValue, usefulLifeYears, acquisitionDate, disposalDate, proceeds, method = 'sl', currency, } = inputs;
+    validatePositive(cost, 'Asset cost');
+    validateNonNegative(salvageValue, 'Salvage value');
+    validatePositiveInteger(usefulLifeYears, 'Useful life (years)');
+    if (salvageValue > 0)
+        validateSalvageLessThanCost(salvageValue, cost);
+    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(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 (proceeds2 > 0) {
+        lines.push({ account: 'Cash / Bank Account', debit: proceeds2, credit: 0 });
+    }
+    if (accumulatedDepreciation > 0) {
+        lines.push({ account: 'Accumulated Depreciation', debit: accumulatedDepreciation, credit: 0 });
+    }
+    if (!isGain) {
+        lines.push({ account: 'Loss on Disposal', debit: Math.abs(gainOrLoss), credit: 0 });
+    }
+    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 });
+    }
+    const disposalJournal = {
+        description: `Asset disposal — ${isGain ? (gainOrLoss > 0 ? 'gain' : 'at book value') : 'loss'}`,
+        lines,
+    };
+    // Build blueprint
+    const c = currency ?? undefined;
+    const methodLabel = method === 'sl' ? 'Straight-line' : method === 'ddb' ? 'Double declining' : '150% declining';
+    const workings = [
+        `Asset Disposal Workings (IAS 16)`,
+        `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(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(cost2, currency)} asset — ${disposalDate}`,
+        capsuleDescription: workings,
+        tags: ['Asset Disposal'],
+        customFields: { 'Asset Description': null },
+        steps: [
+            journalStep(1, disposalJournal.description, disposalDate, disposalJournal.lines),
+            noteStep(2, `Update Jaz FA register: use POST /mark-as-sold/fixed-assets (if sold) or POST /discard-fixed-assets/:id (if scrapped).`, disposalDate),
+        ],
+    };
+    return {
+        type: 'asset-disposal',
+        currency: currency ?? null,
+        inputs: {
+            cost: cost2,
+            salvageValue: salvage2,
+            usefulLifeYears,
+            acquisitionDate,
+            disposalDate,
+            proceeds: proceeds2,
+            method,
+        },
+        monthsHeld,
+        accumulatedDepreciation,
+        netBookValue,
+        gainOrLoss,
+        isGain,
+        disposalJournal,
+        blueprint,
+    };
+}

package/dist/calc/blueprint.js

@@ -10,7 +10,27 @@
 export function journalStep(stepNum, description, date, lines) {
     return { step: stepNum, action: 'journal', description, date, lines };
 }
-/** Build a note step (instruction, not a journal — e.g. "register fixed asset"). */
+/** Build a bill step (create supplier bill, e.g. prepaid expense). Lines show net accounting effect. */
+export function billStep(stepNum, description, date, lines) {
+    return { step: stepNum, action: 'bill', description, date, lines };
+}
+/** Build an invoice step (create customer invoice, e.g. deferred revenue). Lines show net accounting effect. */
+export function invoiceStep(stepNum, description, date, lines) {
+    return { step: stepNum, action: 'invoice', description, date, lines };
+}
+/** Build a cash-out step (cash disbursement, e.g. deposit placement). */
+export function cashOutStep(stepNum, description, date, lines) {
+    return { step: stepNum, action: 'cash-out', description, date, lines };
+}
+/** Build a cash-in step (cash receipt, e.g. deposit maturity). */
+export function cashInStep(stepNum, description, date, lines) {
+    return { step: stepNum, action: 'cash-in', description, date, lines };
+}
+/** Build a fixed-asset registration step (e.g. register ROU asset in FA module). */
+export function fixedAssetStep(stepNum, description, date = null) {
+    return { step: stepNum, action: 'fixed-asset', description, date, lines: [] };
+}
+/** Build a note step (instruction, not a journal — e.g. "update FA register"). */
 export function noteStep(stepNum, description, date = null) {
     return { step: stepNum, action: 'note', description, date, lines: [] };
 }
@@ -19,3 +39,8 @@ export function fmtCapsuleAmount(amount, currency) {
     const formatted = amount.toLocaleString('en-US', { minimumFractionDigits: 0, maximumFractionDigits: 0 });
     return currency ? `${currency} ${formatted}` : formatted;
 }
+/** Format a currency amount for workings text (e.g. "SGD 100,000.00"). */
+export function fmtAmt(amount, currency) {
+    const formatted = amount.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+    return currency ? `${currency} ${formatted}` : formatted;
+}

package/dist/calc/depreciation.js

@@ -11,7 +11,7 @@
  */
 import { round2 } from './types.js';
 import { validatePositive, validateNonNegative, validatePositiveInteger, validateSalvageLessThanCost } from './validate.js';
-import { journalStep } from './blueprint.js';
+import { journalStep, fmtAmt } from './blueprint.js';
 export function calculateDepreciation(inputs) {
     const { cost, salvageValue, usefulLifeYears, method = 'ddb', frequency = 'annual', currency, } = inputs;
     validatePositive(cost, 'Asset cost');
@@ -105,6 +105,16 @@ function buildStraightLineResult(cost, salvageValue, usefulLifeYears, depreciabl
         });
     }
     const blueprintSteps = schedule.map((row, idx) => journalStep(idx + 1, row.journal.description, row.date, row.journal.lines));
+    const c = currency ?? undefined;
+    const workings = [
+        `Straight-Line Depreciation Workings`,
+        `Cost: ${fmtAmt(cost, c)} | Salvage: ${fmtAmt(salvageValue, c)} | Depreciable base: ${fmtAmt(depreciableBase, c)}`,
+        `Useful life: ${usefulLifeYears} years | Frequency: ${frequency}`,
+        `Per ${frequency === 'monthly' ? 'month' : 'year'}: ${fmtAmt(perPeriod, c)}`,
+        `Total depreciation: ${fmtAmt(depreciableBase, c)}`,
+        `Method: (Cost − Salvage) ÷ Life = ${fmtAmt(depreciableBase, c)} ÷ ${totalPeriods} = ${fmtAmt(perPeriod, c)}`,
+        `Rounding: 2dp per period, final period closes to salvage value`,
+    ].join('\n');
     return {
         type: 'depreciation',
         currency: currency ?? null,
@@ -114,6 +124,7 @@ function buildStraightLineResult(cost, salvageValue, usefulLifeYears, depreciabl
         blueprint: {
             capsuleType: 'Depreciation',
             capsuleName: `SL Depreciation — ${usefulLifeYears} years`,
+            capsuleDescription: workings,
             tags: ['Depreciation'],
             customFields: { 'Asset ID': null },
             steps: blueprintSteps,
@@ -160,6 +171,17 @@ function buildDecliningSchedule(cost, salvageValue, usefulLifeYears, annualRate,
         });
     }
     const blueprintSteps = schedule.map((row, idx) => journalStep(idx + 1, row.journal.description, row.date, row.journal.lines));
+    const c = currency ?? undefined;
+    const methodLabel = method === 'ddb' ? 'Double Declining Balance' : '150% Declining Balance';
+    const ratePercent = round2(annualRate * 100);
+    const workings = [
+        `${methodLabel} Depreciation Workings`,
+        `Cost: ${fmtAmt(cost, c)} | Salvage: ${fmtAmt(salvageValue, c)} | Depreciable base: ${fmtAmt(depreciableBase, c)}`,
+        `Useful life: ${usefulLifeYears} years | Rate: ${ratePercent}% (${method === 'ddb' ? '2' : '1.5'} ÷ ${usefulLifeYears})`,
+        `Total depreciation: ${fmtAmt(depreciableBase, c)}`,
+        `Method: ${method.toUpperCase()} with auto switch to SL when SL ≥ declining or floor hit`,
+        `Rounding: 2dp per period, book value never falls below salvage`,
+    ].join('\n');
     return {
         type: 'depreciation',
         currency: currency ?? null,
@@ -169,6 +191,7 @@ function buildDecliningSchedule(cost, salvageValue, usefulLifeYears, annualRate,
         blueprint: {
             capsuleType: 'Depreciation',
             capsuleName: `${method.toUpperCase()} Depreciation — ${usefulLifeYears} years`,
+            capsuleDescription: workings,
             tags: ['Depreciation'],
             customFields: { 'Asset ID': null },
             steps: blueprintSteps,

package/dist/calc/ecl.js

@@ -15,7 +15,7 @@
  */
 import { round2 } from './types.js';
 import { validateNonNegative } from './validate.js';
-import { journalStep, fmtCapsuleAmount } from './blueprint.js';
+import { journalStep, fmtCapsuleAmount, fmtAmt } from './blueprint.js';
 export function calculateEcl(inputs) {
     const { buckets, existingProvision = 0, currency } = inputs;
     // Validate each bucket
@@ -61,9 +61,21 @@ export function calculateEcl(inputs) {
         };
     }
     // Blueprint
+    const c = currency ?? undefined;
+    const bucketWorkings = bucketDetails.map(b => `  ${b.bucket}: ${fmtAmt(b.balance, c)} × ${b.lossRate}% = ${fmtAmt(b.ecl, c)}`).join('\n');
+    const workings = [
+        `ECL Provision Matrix Workings (IFRS 9)`,
+        `Total receivables: ${fmtAmt(totalReceivables, c)} | Weighted avg loss rate: ${weightedRate}%`,
+        `Provision matrix:`,
+        bucketWorkings,
+        `Total ECL required: ${fmtAmt(totalEcl, c)} | Existing provision: ${fmtAmt(existingProvision, c)}`,
+        `Adjustment: ${fmtAmt(Math.abs(adjustmentRequired), c)} (${isIncrease ? 'increase' : 'release'})`,
+        `Method: IFRS 9.5.5.15 simplified approach — lifetime ECL, provision matrix`,
+    ].join('\n');
     const blueprint = {
         capsuleType: 'ECL Provision',
         capsuleName: `ECL Provision — ${fmtCapsuleAmount(totalEcl, currency)} — ${buckets.length} buckets`,
+        capsuleDescription: workings,
         tags: ['ECL', 'Bad Debt'],
         customFields: { 'Reporting Period': null, 'Aged Receivables Report Date': null },
         steps: [

package/dist/calc/fixed-deposit.js

@@ -0,0 +1,178 @@
+/**
+ * Fixed deposit interest accrual calculator.
+ *
+ * Compliance references:
+ *  - IFRS 9.4.1.2: Classification at amortized cost (hold-to-collect, passes SPPI)
+ *  - IFRS 9.5.4.1: Interest revenue via effective interest rate method
+ *
+ * Supports simple interest (default) and compound interest (monthly/quarterly/annually).
+ * Final period absorbs rounding — maturity value is exact.
+ */
+import { fv } from 'financial';
+import { round2, addMonths } from './types.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;
+    validatePositive(principal, 'Principal');
+    validateRate(annualRate, 'Annual rate');
+    validatePositiveInteger(termMonths, 'Term (months)');
+    validateDateFormat(startDate);
+    // 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() — one consistent periodic rate
+        const periodsPerYear = 12 / compIntervalMonths;
+        const compoundRate = annualRate / 100 / periodsPerYear;
+        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 accrual schedule — accrue at compound intervals using the same periodic rate
+    const schedule = [];
+    let accruedTotal = 0;
+    if (compounding === 'none') {
+        // Simple interest: equal accrual each month
+        const monthlyInterest = round2(totalInterest / termMonths);
+        let balance = principal;
+        for (let i = 1; i <= termMonths; i++) {
+            const isFinal = i === termMonths;
+            const interest = isFinal ? round2(totalInterest - accruedTotal) : monthlyInterest;
+            accruedTotal = round2(accruedTotal + interest);
+            const date = startDate ? addMonths(startDate, i) : null;
+            const journal = {
+                description: `Interest accrual — Month ${i} of ${termMonths}`,
+                lines: [
+                    { account: 'Accrued Interest Receivable', debit: interest, credit: 0 },
+                    { account: 'Interest Income', debit: 0, credit: interest },
+                ],
+            };
+            schedule.push({
+                period: i,
+                date,
+                openingBalance: balance,
+                interest,
+                closingBalance: balance, // simple interest: principal unchanged
+                journal,
+            });
+        }
+    }
+    else {
+        // 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;
+        const totalPeriods = termMonths / compIntervalMonths;
+        for (let p = 1; p <= totalPeriods; p++) {
+            const openingBalance = round2(balance);
+            const isFinal = p === totalPeriods;
+            let interest;
+            if (isFinal) {
+                // Final period: close to exact maturity value
+                interest = round2(maturityValue - openingBalance);
+            }
+            else {
+                interest = round2(openingBalance * periodicRate);
+            }
+            balance = round2(openingBalance + interest);
+            accruedTotal = round2(accruedTotal + interest);
+            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 — ${periodLabel} of ${totalPeriods}`,
+                lines: [
+                    { account: 'Accrued Interest Receivable', debit: interest, credit: 0 },
+                    { account: 'Interest Income', debit: 0, credit: interest },
+                ],
+            };
+            schedule.push({
+                period: p,
+                date,
+                openingBalance,
+                interest,
+                closingBalance: balance,
+                journal,
+            });
+        }
+    }
+    const placementJournal = {
+        description: 'Fixed deposit placement',
+        lines: [
+            { account: 'Fixed Deposit', debit: principal, credit: 0 },
+            { account: 'Cash / Bank Account', debit: 0, credit: principal },
+        ],
+    };
+    const maturityJournal = {
+        description: 'Fixed deposit maturity',
+        lines: [
+            { account: 'Cash / Bank Account', debit: maturityValue, credit: 0 },
+            { account: 'Fixed Deposit', debit: 0, credit: principal },
+            { account: 'Accrued Interest Receivable', debit: 0, credit: totalInterest },
+        ],
+    };
+    // Build blueprint
+    let blueprint = null;
+    if (startDate) {
+        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(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}`;
+        const monthlyAccrual = compounding === 'none' ? round2(totalInterest / termMonths) : null;
+        const workingsLines = [
+            `Fixed Deposit Interest Accrual Workings (IFRS 9)`,
+            `Principal: ${fmtAmt(principal, c)} | Rate: ${annualRate}% p.a. | Term: ${termMonths} months`,
+            `Method: ${compoundLabel}`,
+        ];
+        if (compounding === 'none') {
+            workingsLines.push(`Interest: ${fmtAmt(principal, c)} × ${annualRate}% × ${termMonths}/12 = ${fmtAmt(totalInterest, c)}`, `Monthly accrual: ${fmtAmt(monthlyAccrual, c)}`);
+        }
+        else {
+            const periodsPerYear = compounding === 'monthly' ? 12 : compounding === 'quarterly' ? 4 : 1;
+            workingsLines.push(`Compounding: ${periodsPerYear}× per year | Effective annual rate: ${effectiveRate}%`, `Total interest: ${fmtAmt(totalInterest, c)}`);
+        }
+        workingsLines.push(`Maturity value: ${fmtAmt(maturityValue, c)}`, `Classification: Amortized cost (hold-to-collect, passes SPPI)`, `Rounding: 2dp per period, final period closes to exact maturity value`);
+        blueprint = {
+            capsuleType: 'Fixed Deposit',
+            capsuleName: `Fixed Deposit — ${fmtCapsuleAmount(principal, currency)} — ${annualRate}% — ${termMonths} months`,
+            capsuleDescription: workingsLines.join('\n'),
+            tags: ['Fixed Deposit'],
+            customFields: { 'Deposit Reference': null, 'Bank Name': null },
+            steps,
+        };
+    }
+    return {
+        type: 'fixed-deposit',
+        currency: currency ?? null,
+        inputs: {
+            principal,
+            annualRate,
+            termMonths,
+            compounding,
+            startDate: startDate ?? null,
+        },
+        maturityValue,
+        totalInterest,
+        effectiveRate,
+        schedule,
+        placementJournal,
+        maturityJournal,
+        blueprint,
+    };
+}