jaz-cli 2.3.0 → 2.6.0

package/assets/skills/transaction-recipes/references/provisions.md

@@ -0,0 +1,142 @@
+# Recipe: Provisions with PV Unwinding (IAS 37)
+
+## Scenario
+
+Your company has a product warranty obligation. Based on historical claims data, you estimate $500,000 in warranty costs over the next 5 years. Because the time value of money is material (IAS 37.45), you recognize the provision at its present value using a 4% discount rate. Each month, the discount unwinds as a finance cost, gradually increasing the provision balance until it reaches the full $500,000 at settlement.
+
+**Pattern:** Manual journals + capsule (interest amounts change each period, same as loan/lease unwinding)
+
+---
+
+## Accounts Involved
+
+| Account | Type | Subtype | Role |
+|---|---|---|---|
+| Provision Expense | Expense | Expense | Initial recognition at PV |
+| Provision for Obligations | Liability | Non-Current Liability | Holds the discounted obligation |
+| Finance Cost — Unwinding | Expense | Expense | Monthly discount unwinding charge |
+| Cash / Bank Account | Asset | Bank | Settlement when obligation is paid |
+
+---
+
+## Journal Entries
+
+### Step 1: Initial Recognition (at PV)
+
+| Line | Account | Debit | Credit |
+|---|---|---|---|
+| 1 | Provision Expense | *present value* | |
+| 2 | Provision for Obligations | | *present value* |
+
+### Step 2: Monthly Unwinding (each month)
+
+```
+Interest = Opening Provision Balance × Monthly Rate
+Monthly Rate = Annual Rate / 12
+```
+
+| Line | Account | Debit | Credit |
+|---|---|---|---|
+| 1 | Finance Cost — Unwinding | *interest amount* | |
+| 2 | Provision for Obligations | | *interest amount* |
+
+The provision balance grows each month until it reaches the nominal amount at settlement.
+
+### Step 3: Settlement (when obligation is paid)
+
+| Line | Account | Debit | Credit |
+|---|---|---|---|
+| 1 | Provision for Obligations | *nominal amount* | |
+| 2 | Cash / Bank Account | | *actual amount paid* |
+| 3 | Provision Expense (or Revenue) | difference | (if actual ≠ estimate) |
+
+---
+
+## Capsule Structure
+
+**Capsule:** "Warranty Provision — Product X — 2025"
+**Capsule Type:** "Provisions"
+
+Contents:
+- 1 initial recognition journal
+- 60 monthly unwinding journals (5 years)
+- Settlement journal(s) when claims are paid
+- Revision journals if estimate changes
+- **Total entries:** 62+
+
+---
+
+## Worked Example
+
+**Setup:**
+- Estimated future outflow: $500,000
+- Discount rate: 4% annual (0.333% monthly)
+- Settlement term: 60 months
+- Present value: $409,501.55
+
+**Calculation:**
+```
+PV = 500,000 / (1 + 0.04/12)^60 = $409,501.55
+Total unwinding = $500,000 − $409,501.55 = $90,498.45
+```
+
+**Jan 1, 2025 — Initial recognition:**
+- Dr Provision Expense $409,501.55
+- Cr Provision for Obligations $409,501.55
+- Description: "Initial provision recognition at PV (IAS 37)"
+
+**Jan 31, 2025 — Month 1 unwinding:**
+- Opening balance: $409,501.55
+- Interest: $409,501.55 × 0.00333 = $1,365.01
+- Closing balance: $410,866.56
+- Dr Finance Cost — Unwinding $1,365.01
+- Cr Provision for Obligations $1,365.01
+
+**Feb 28, 2025 — Month 2 unwinding:**
+- Opening balance: $410,866.56
+- Interest: $410,866.56 × 0.00333 = $1,369.56
+- Closing balance: $412,236.12
+
+**Dec 31, 2029 — Month 60 (final):**
+- Closing balance reaches exactly $500,000.00
+
+**Settlement:**
+- Dr Provision for Obligations $500,000
+- Cr Cash $500,000
+
+**Use the calculator:** `jaz calc provision --amount 500000 --rate 4 --term 60 --start-date 2025-01-01`
+
+---
+
+## Enrichment Suggestions
+
+| Enrichment | Value | Why |
+|---|---|---|
+| Tracking Tag | "Provision" | Filter all provision-related entries |
+| Tracking Tag | "IAS 37" | Mark IFRS-specific adjustments |
+| Custom Field | "Obligation Type" → "Warranty" | Identify the type of provision |
+| Custom Field | "Expected Settlement Date" → "2029-12-31" | Record the estimated settlement date |
+
+---
+
+## Verification
+
+1. **Trial Balance at Jan 31** → Provision for Obligations shows $410,866.56 credit. Finance Cost shows $1,365.01.
+2. **Trial Balance at Dec 31, Year 1** → Provision balance should match the year-end closing balance from the unwinding schedule (~$426,185).
+3. **Final period** → Provision balance reaches exactly $500,000.00 (the calculator's final-period adjustment ensures this).
+4. **P&L per year** → Finance Cost — Unwinding increases each year (compounding effect), totaling $90,498.45 over 5 years.
+5. **Group General Ledger by Capsule** → Complete history from recognition through every unwinding entry.
+
+---
+
+## Variations
+
+**Revision of estimate:** If the estimated outflow changes (e.g., from $500,000 to $550,000), adjust the provision and recalculate the unwinding schedule. The change in estimate goes to Provision Expense, not Finance Cost.
+
+**Short-term provision (no discounting):** If settlement is within 12 months, PV discounting is not required (IAS 37.45 — "effect of time value not material"). Simply recognize at the nominal amount with no unwinding schedule.
+
+**Decommissioning provision:** Same pattern, but the initial recognition is capitalized to the related asset (Dr Asset / Cr Provision) instead of expensed. The asset is then depreciated over its useful life.
+
+**Legal claim provision:** If the outcome is uncertain, provision is recognized only when "probable" (>50% likelihood). If only "possible," disclose as a contingent liability but do not recognize. Use the provision calculator once the amount and timing are estimable.
+
+**Multiple payment dates:** If the obligation will be settled in tranches (e.g., warranty claims over 5 years), model as multiple provisions or use a weighted average settlement period.

package/dist/calc/amortization.js

@@ -0,0 +1,122 @@
+/**
+ * Prepaid expense & deferred revenue recognition calculators.
+ * Equal-period division. Final period absorbs rounding remainder.
+ */
+import { round2, addMonths } from './types.js';
+import { validatePositive, validatePositiveInteger, validateDateFormat } from './validate.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');
+    validatePositiveInteger(periods, 'Periods');
+    validateDateFormat(startDate);
+    const schedule = buildSchedule(amount, periods, frequency, startDate, 'prepaid');
+    let blueprint = null;
+    if (startDate) {
+        const steps = [
+            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,
+        };
+    }
+    return {
+        type: 'prepaid-expense',
+        currency: currency ?? null,
+        inputs: { amount, periods, frequency, startDate: startDate ?? null },
+        perPeriodAmount: round2(amount / periods),
+        schedule,
+        blueprint,
+    };
+}
+export function calculateDeferredRevenue(inputs) {
+    const { amount, periods, frequency = 'monthly', startDate, currency } = inputs;
+    validatePositive(amount, 'Amount');
+    validatePositiveInteger(periods, 'Periods');
+    validateDateFormat(startDate);
+    const schedule = buildSchedule(amount, periods, frequency, startDate, 'deferred');
+    let blueprint = null;
+    if (startDate) {
+        const steps = [
+            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,
+        };
+    }
+    return {
+        type: 'deferred-revenue',
+        currency: currency ?? null,
+        inputs: { amount, periods, frequency, startDate: startDate ?? null },
+        perPeriodAmount: round2(amount / periods),
+        schedule,
+        blueprint,
+    };
+}
+function buildSchedule(amount, periods, frequency, startDate, kind) {
+    const perPeriod = round2(amount / periods);
+    const schedule = [];
+    let remaining = amount;
+    const monthsPerPeriod = frequency === 'quarterly' ? 3 : 1;
+    for (let i = 1; i <= periods; i++) {
+        const isFinal = i === periods;
+        const amortized = isFinal ? round2(remaining) : perPeriod;
+        remaining = round2(remaining - amortized);
+        const date = startDate ? addMonths(startDate, i * monthsPerPeriod) : null;
+        let journal;
+        if (kind === 'prepaid') {
+            journal = {
+                description: `Prepaid expense recognition — Period ${i} of ${periods}`,
+                lines: [
+                    { account: 'Expense', debit: amortized, credit: 0 },
+                    { account: 'Prepaid Asset', debit: 0, credit: amortized },
+                ],
+            };
+        }
+        else {
+            journal = {
+                description: `Deferred revenue recognition — Period ${i} of ${periods}`,
+                lines: [
+                    { account: 'Deferred Revenue', debit: amortized, credit: 0 },
+                    { account: 'Revenue', debit: 0, credit: amortized },
+                ],
+            };
+        }
+        schedule.push({ period: i, date, amortized, remainingBalance: remaining, journal });
+    }
+    return schedule;
+}

package/dist/calc/asset-disposal.js

@@ -0,0 +1,151 @@
+/**
+ * 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);
+    // 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 isGain = gainOrLoss >= 0;
+    // Build disposal journal entry
+    const lines = [];
+    if (proceeds > 0) {
+        lines.push({ account: 'Cash / Bank Account', debit: proceeds, 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: cost });
+    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(cost, c)} | Salvage: ${fmtAmt(salvageValue, 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)}`,
+    ].join('\n');
+    let blueprint = null;
+    blueprint = {
+        capsuleType: 'Asset Disposal',
+        capsuleName: `Asset Disposal — ${fmtCapsuleAmount(cost, 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,
+            salvageValue,
+            usefulLifeYears,
+            acquisitionDate,
+            disposalDate,
+            proceeds,
+            method,
+        },
+        monthsHeld,
+        accumulatedDepreciation,
+        netBookValue,
+        gainOrLoss,
+        isGain,
+        disposalJournal,
+        blueprint,
+    };
+}

package/dist/calc/blueprint.js

@@ -0,0 +1,46 @@
+/**
+ * Blueprint builder — translates calculator output into a
+ * capsule + transaction execution plan for Jaz.
+ *
+ * The blueprint gives an AI agent or human everything needed to
+ * create the capsule and post all journal entries in Jaz without
+ * any manual translation from the schedule.
+ */
+/** Build a blueprint step from a journal entry with a date. */
+export function journalStep(stepNum, description, date, lines) {
+    return { step: stepNum, action: 'journal', description, date, lines };
+}
+/** 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: [] };
+}
+/** Format a currency amount for capsule names (e.g. "SGD 100,000"). */
+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

@@ -0,0 +1,200 @@
+/**
+ * Depreciation schedule calculator.
+ *
+ * Methods:
+ *  - sl:    Straight-line (cost - salvage) / life
+ *  - ddb:   Double declining balance (2 / life), auto switch-to-SL
+ *  - 150db: 150% declining balance (1.5 / life), auto switch-to-SL
+ *
+ * Book value never goes below salvage value.
+ * Total depreciation always equals (cost - salvage).
+ */
+import { round2 } from './types.js';
+import { validatePositive, validateNonNegative, validatePositiveInteger, validateSalvageLessThanCost } from './validate.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');
+    validateNonNegative(salvageValue, 'Salvage value');
+    validatePositiveInteger(usefulLifeYears, 'Useful life (years)');
+    if (salvageValue > 0)
+        validateSalvageLessThanCost(salvageValue, cost);
+    const depreciableBase = round2(cost - salvageValue);
+    if (method === 'sl') {
+        return buildStraightLineResult(cost, salvageValue, usefulLifeYears, depreciableBase, frequency, currency);
+    }
+    const multiplier = method === 'ddb' ? 2 : 1.5;
+    const annualRate = multiplier / usefulLifeYears;
+    if (frequency === 'annual') {
+        return buildDecliningSchedule(cost, salvageValue, usefulLifeYears, annualRate, depreciableBase, method, currency);
+    }
+    // Monthly: compute annual schedule then subdivide each year into 12 equal months
+    const annual = buildDecliningSchedule(cost, salvageValue, usefulLifeYears, annualRate, depreciableBase, method, currency);
+    const monthlySchedule = [];
+    let periodNum = 0;
+    for (const yearRow of annual.schedule) {
+        const monthlyAmount = round2(yearRow.depreciation / 12);
+        let yearRemaining = yearRow.depreciation;
+        for (let m = 1; m <= 12; m++) {
+            periodNum++;
+            const isLastMonth = m === 12;
+            const dep = isLastMonth ? round2(yearRemaining) : monthlyAmount;
+            yearRemaining = round2(yearRemaining - dep);
+            const openingBV = periodNum === 1
+                ? cost
+                : round2(monthlySchedule[periodNum - 2].closingBookValue);
+            const closingBV = round2(openingBV - dep);
+            const journal = {
+                description: `${yearRow.methodUsed} depreciation — Month ${periodNum} of ${usefulLifeYears * 12}`,
+                lines: [
+                    { account: 'Depreciation Expense', debit: dep, credit: 0 },
+                    { account: 'Accumulated Depreciation', debit: 0, credit: dep },
+                ],
+            };
+            monthlySchedule.push({
+                period: periodNum,
+                date: null,
+                openingBookValue: openingBV,
+                ddbAmount: round2(yearRow.ddbAmount / 12),
+                slAmount: round2(yearRow.slAmount / 12),
+                methodUsed: yearRow.methodUsed,
+                depreciation: dep,
+                closingBookValue: closingBV,
+                journal,
+            });
+        }
+    }
+    return {
+        type: 'depreciation',
+        currency: currency ?? null,
+        inputs: { cost, salvageValue, usefulLifeYears, method, frequency },
+        totalDepreciation: depreciableBase,
+        schedule: monthlySchedule,
+        blueprint: annual.blueprint, // reuse annual blueprint (monthly is just subdivision)
+    };
+}
+function buildStraightLineResult(cost, salvageValue, usefulLifeYears, depreciableBase, frequency, currency) {
+    const totalPeriods = frequency === 'monthly' ? usefulLifeYears * 12 : usefulLifeYears;
+    const perPeriod = round2(depreciableBase / totalPeriods);
+    const periodLabel = frequency === 'monthly' ? 'Month' : 'Year';
+    const totalLabel = frequency === 'monthly' ? usefulLifeYears * 12 : usefulLifeYears;
+    const schedule = [];
+    let bookValue = cost;
+    for (let i = 1; i <= totalPeriods; i++) {
+        const openingBV = round2(bookValue);
+        const isFinal = i === totalPeriods;
+        const dep = isFinal ? round2(openingBV - salvageValue) : perPeriod;
+        bookValue = round2(openingBV - dep);
+        const journal = {
+            description: `SL depreciation — ${periodLabel} ${i} of ${totalLabel}`,
+            lines: [
+                { account: 'Depreciation Expense', debit: dep, credit: 0 },
+                { account: 'Accumulated Depreciation', debit: 0, credit: dep },
+            ],
+        };
+        schedule.push({
+            period: i,
+            date: null,
+            openingBookValue: openingBV,
+            ddbAmount: 0,
+            slAmount: dep,
+            methodUsed: 'SL',
+            depreciation: dep,
+            closingBookValue: bookValue,
+            journal,
+        });
+    }
+    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,
+        inputs: { cost, salvageValue, usefulLifeYears, method: 'sl', frequency },
+        totalDepreciation: depreciableBase,
+        schedule,
+        blueprint: {
+            capsuleType: 'Depreciation',
+            capsuleName: `SL Depreciation — ${usefulLifeYears} years`,
+            capsuleDescription: workings,
+            tags: ['Depreciation'],
+            customFields: { 'Asset ID': null },
+            steps: blueprintSteps,
+        },
+    };
+}
+function buildDecliningSchedule(cost, salvageValue, usefulLifeYears, annualRate, depreciableBase, method, currency) {
+    const schedule = [];
+    let bookValue = cost;
+    for (let year = 1; year <= usefulLifeYears; year++) {
+        const openingBV = round2(bookValue);
+        const remainingYears = usefulLifeYears - year + 1;
+        // DDB amount (rate × opening book value)
+        const ddbAmount = round2(openingBV * annualRate);
+        // SL for remaining life: (book value - salvage) / remaining years
+        const slAmount = round2((openingBV - salvageValue) / remainingYears);
+        // Switch to SL when SL >= DDB, or when DDB would push below salvage
+        const ddbCapped = round2(openingBV - ddbAmount) < salvageValue;
+        const useSL = slAmount >= ddbAmount || ddbCapped;
+        const methodUsed = useSL ? 'SL' : (method === '150db' ? '150DB' : 'DDB');
+        // Depreciation cannot push book value below salvage
+        let depreciation = useSL ? slAmount : ddbAmount;
+        if (round2(openingBV - depreciation) < salvageValue) {
+            depreciation = round2(openingBV - salvageValue);
+        }
+        bookValue = round2(openingBV - depreciation);
+        const journal = {
+            description: `${methodUsed} depreciation — Year ${year} of ${usefulLifeYears}`,
+            lines: [
+                { account: 'Depreciation Expense', debit: depreciation, credit: 0 },
+                { account: 'Accumulated Depreciation', debit: 0, credit: depreciation },
+            ],
+        };
+        schedule.push({
+            period: year,
+            date: null,
+            openingBookValue: openingBV,
+            ddbAmount,
+            slAmount,
+            methodUsed,
+            depreciation,
+            closingBookValue: bookValue,
+            journal,
+        });
+    }
+    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,
+        inputs: { cost, salvageValue, usefulLifeYears, method, frequency: 'annual' },
+        totalDepreciation: depreciableBase,
+        schedule,
+        blueprint: {
+            capsuleType: 'Depreciation',
+            capsuleName: `${method.toUpperCase()} Depreciation — ${usefulLifeYears} years`,
+            capsuleDescription: workings,
+            tags: ['Depreciation'],
+            customFields: { 'Asset ID': null },
+            steps: blueprintSteps,
+        },
+    };
+}