@classytic/stage 0.2.0 → 0.4.0

package/dist/finance/accounting/adjustments.mjs

@@ -0,0 +1,202 @@
+import { DEFAULT_ACCOUNTING_POLICY, fromMinor, toMinor } from "./precision.mjs";
+import { solveJournal } from "./solve.mjs";
+
+//#region src/finance/accounting/adjustments.ts
+function invalid(fact, message) {
+	return {
+		factId: fact.id,
+		entries: [],
+		diagnostics: [{
+			code: "invalid-adjustment",
+			severity: "error",
+			entryId: fact.id,
+			message
+		}],
+		trace: [],
+		values: {}
+	};
+}
+function entry(id, narration, debit, credit, amount) {
+	return {
+		id,
+		narration,
+		lines: [{
+			accountId: debit,
+			side: "debit",
+			amount
+		}, {
+			accountId: credit,
+			side: "credit",
+			amount
+		}]
+	};
+}
+function explanation(fact, rule, working, result) {
+	return {
+		id: `${fact.id}:adjust`,
+		kind: "derive",
+		rule,
+		working,
+		result
+	};
+}
+function rounded(amount, policy) {
+	return fromMinor(toMinor(amount, policy), policy);
+}
+function produceAdjustment(fact, policy = DEFAULT_ACCOUNTING_POLICY) {
+	switch (fact.type) {
+		case "expense-period-end": {
+			if (fact.recognizedExpense < 0 || fact.recordedExpense < 0) return invalid(fact, "Expense amounts cannot be negative.");
+			const difference = rounded(fact.recognizedExpense - fact.recordedExpense, policy);
+			const trace = [explanation(fact, "Match expense to the period in which it was incurred.", `${fact.recognizedExpense} recognized − ${fact.recordedExpense} recorded`, difference)];
+			if (difference === 0) return {
+				factId: fact.id,
+				entries: [],
+				diagnostics: [],
+				trace,
+				values: {
+					difference: 0,
+					treatment: "none"
+				}
+			};
+			const adjustment = difference > 0 ? entry(fact.id, fact.narration ?? "Accrued expense", fact.expenseAccountId, fact.accrualAccountId, difference) : entry(fact.id, fact.narration ?? "Prepaid expense", fact.prepaymentAccountId, fact.expenseAccountId, Math.abs(difference));
+			return {
+				factId: fact.id,
+				entries: [adjustment],
+				diagnostics: [],
+				trace,
+				values: {
+					difference: Math.abs(difference),
+					treatment: difference > 0 ? "accrual" : "prepayment"
+				}
+			};
+		}
+		case "depreciation": {
+			const fraction = fact.periodFraction ?? 1;
+			if (!(fraction > 0 && fraction <= 1)) return invalid(fact, "Depreciation periodFraction must be greater than 0 and no more than 1.");
+			let amount;
+			let working;
+			if (fact.method === "straight-line") {
+				if (!(fact.cost >= 0 && fact.residualValue >= 0 && fact.residualValue <= fact.cost && fact.usefulLifeYears > 0)) return invalid(fact, "Straight-line depreciation requires cost ≥ residual value and a positive useful life.");
+				amount = rounded((fact.cost - fact.residualValue) / fact.usefulLifeYears * fraction, policy);
+				working = `(${fact.cost} − ${fact.residualValue}) ÷ ${fact.usefulLifeYears} × ${fraction}`;
+			} else {
+				if (!(fact.openingBookValue >= 0 && fact.rate >= 0 && fact.rate <= 1)) return invalid(fact, "Reducing-balance depreciation requires a non-negative book value and a rate from 0 to 1.");
+				amount = rounded(fact.openingBookValue * fact.rate * fraction, policy);
+				working = `${fact.openingBookValue} × ${fact.rate} × ${fraction}`;
+			}
+			if (amount <= 0) return invalid(fact, "The depreciation charge must be positive.");
+			return {
+				factId: fact.id,
+				entries: [entry(fact.id, fact.narration ?? "Depreciation charge", fact.expenseAccountId, fact.accumulatedDepreciationAccountId, amount)],
+				diagnostics: [],
+				trace: [explanation(fact, `${fact.method} depreciation allocates asset cost systematically.`, working, amount)],
+				values: {
+					depreciation: amount,
+					method: fact.method
+				}
+			};
+		}
+		case "irrecoverable-debt": {
+			if (!(fact.amount > 0)) return invalid(fact, "An irrecoverable debt must be positive.");
+			const amount = rounded(fact.amount, policy);
+			return {
+				factId: fact.id,
+				entries: [entry(fact.id, fact.narration ?? "Write off irrecoverable debt", fact.expenseAccountId, fact.receivableAccountId, amount)],
+				diagnostics: [],
+				trace: [explanation(fact, "Remove a receivable that is no longer recoverable.", `${amount} leaves receivables and becomes an expense`, amount)],
+				values: { writtenOff: amount }
+			};
+		}
+		case "allowance-change": {
+			if (fact.openingAllowance < 0 || fact.requiredAllowance < 0) return invalid(fact, "Allowance balances cannot be negative.");
+			const change = rounded(fact.requiredAllowance - fact.openingAllowance, policy);
+			const trace = [explanation(fact, "Charge only the change in the allowance to the current period.", `${fact.requiredAllowance} required − ${fact.openingAllowance} opening`, change)];
+			if (change === 0) return {
+				factId: fact.id,
+				entries: [],
+				diagnostics: [],
+				trace,
+				values: {
+					change: 0,
+					treatment: "none"
+				}
+			};
+			const adjustment = change > 0 ? entry(fact.id, fact.narration ?? "Increase receivables allowance", fact.expenseAccountId, fact.allowanceAccountId, change) : entry(fact.id, fact.narration ?? "Decrease receivables allowance", fact.allowanceAccountId, fact.expenseAccountId, Math.abs(change));
+			return {
+				factId: fact.id,
+				entries: [adjustment],
+				diagnostics: [],
+				trace,
+				values: {
+					change: Math.abs(change),
+					treatment: change > 0 ? "increase" : "decrease"
+				}
+			};
+		}
+		case "closing-inventory": {
+			if (fact.currentInventory < 0 || fact.requiredInventory < 0) return invalid(fact, "Inventory balances cannot be negative.");
+			const change = rounded(fact.requiredInventory - fact.currentInventory, policy);
+			const trace = [explanation(fact, "Adjust inventory to the measured closing amount; the other side changes cost of sales.", `${fact.requiredInventory} required − ${fact.currentInventory} current`, change)];
+			if (change === 0) return {
+				factId: fact.id,
+				entries: [],
+				diagnostics: [],
+				trace,
+				values: {
+					change: 0,
+					treatment: "none"
+				}
+			};
+			const adjustment = change > 0 ? entry(fact.id, fact.narration ?? "Increase closing inventory", fact.inventoryAccountId, fact.costOfSalesAccountId, change) : entry(fact.id, fact.narration ?? "Reduce closing inventory", fact.costOfSalesAccountId, fact.inventoryAccountId, Math.abs(change));
+			return {
+				factId: fact.id,
+				entries: [adjustment],
+				diagnostics: [],
+				trace,
+				values: {
+					change: Math.abs(change),
+					treatment: change > 0 ? "increase" : "decrease"
+				}
+			};
+		}
+		case "correct-entry": {
+			const reverseLines = fact.wrongEntry.lines.map((line) => ({
+				...line,
+				side: line.side === "debit" ? "credit" : "debit"
+			}));
+			const reversal = {
+				id: `${fact.id}:reverse`,
+				narration: fact.narration ?? `Reverse ${fact.wrongEntry.narration}`,
+				lines: reverseLines
+			};
+			const correction = {
+				...fact.correctEntry,
+				id: `${fact.id}:correct`
+			};
+			return {
+				factId: fact.id,
+				entries: [reversal, correction],
+				diagnostics: [],
+				trace: [explanation(fact, "Preserve the audit trail: reverse the wrong entry, then post the correct entry.", `${fact.wrongEntry.id} reversed; ${fact.correctEntry.id} restated`, "two-step correction")],
+				values: { treatment: "reverse-and-repost" }
+			};
+		}
+	}
+}
+function applyAdjustments({ accounts, baseEntries, adjustments, policy = DEFAULT_ACCOUNTING_POLICY }) {
+	const produced = adjustments.map((fact) => produceAdjustment(fact, policy));
+	const adjustmentEntries = produced.flatMap((result) => result.entries);
+	const diagnostics = produced.flatMap((result) => result.diagnostics);
+	const trace = produced.flatMap((result) => result.trace);
+	return solveJournal({
+		accounts,
+		entries: [...baseEntries, ...adjustmentEntries],
+		policy,
+		initialDiagnostics: diagnostics,
+		trace
+	});
+}
+
+//#endregion
+export { applyAdjustments, produceAdjustment };

package/dist/finance/accounting/analysis.d.mts

@@ -0,0 +1,8 @@
+import { FinancialAnalysisComparison, FinancialAnalysisFacts, FinancialAnalysisResult, FinancialRatioAssessment, FinancialRatioBenchmark } from "./types.mjs";
+
+//#region src/finance/accounting/analysis.d.ts
+declare function analyzeFinancialPerformance(facts: FinancialAnalysisFacts): FinancialAnalysisResult;
+declare function assessFinancialPerformance(analysis: FinancialAnalysisResult, benchmarks: readonly FinancialRatioBenchmark[]): FinancialRatioAssessment[];
+declare function compareFinancialPerformance(currentFacts: FinancialAnalysisFacts, priorFacts: FinancialAnalysisFacts): FinancialAnalysisComparison;
+//#endregion
+export { analyzeFinancialPerformance, assessFinancialPerformance, compareFinancialPerformance };

package/dist/finance/accounting/analysis.mjs

@@ -0,0 +1,205 @@
+//#region src/finance/accounting/analysis.ts
+function analyzeFinancialPerformance(facts) {
+	const inputDiagnostics = [];
+	for (const [name, value] of Object.entries(facts)) {
+		if (value == null) continue;
+		if (!Number.isFinite(value) || value < 0) inputDiagnostics.push({
+			code: "invalid-analysis",
+			severity: "error",
+			message: `${name} must be a finite non-negative amount.`
+		});
+	}
+	if (facts.inventory > facts.currentAssets) inputDiagnostics.push({
+		code: "invalid-analysis",
+		severity: "error",
+		message: "Inventory cannot exceed current assets."
+	});
+	if (inputDiagnostics.length > 0) return {
+		values: {
+			workingCapital: 0,
+			grossProfit: 0,
+			netProfit: 0,
+			capitalEmployed: 0
+		},
+		metrics: [],
+		diagnostics: inputDiagnostics,
+		trace: []
+	};
+	const grossProfit = facts.grossProfit ?? facts.revenue - facts.costOfSales;
+	const netProfit = facts.netProfit ?? grossProfit - (facts.expenses ?? 0);
+	const capitalEmployed = facts.capitalEmployed ?? facts.equity + facts.nonCurrentLiabilities;
+	const days = facts.daysInPeriod ?? 365;
+	const definitions = [
+		{
+			key: "current",
+			label: "Current ratio",
+			family: "liquidity",
+			unit: "ratio",
+			numerator: facts.currentAssets,
+			denominator: facts.currentLiabilities,
+			formula: "current assets ÷ current liabilities"
+		},
+		{
+			key: "quick",
+			label: "Quick ratio",
+			family: "liquidity",
+			unit: "ratio",
+			numerator: facts.currentAssets - facts.inventory,
+			denominator: facts.currentLiabilities,
+			formula: "(current assets − inventory) ÷ current liabilities"
+		},
+		{
+			key: "inventoryDependence",
+			label: "Inventory dependence",
+			family: "liquidity",
+			unit: "ratio",
+			numerator: facts.inventory,
+			denominator: facts.currentLiabilities,
+			formula: "inventory ÷ current liabilities"
+		},
+		{
+			key: "grossMargin",
+			label: "Gross margin",
+			family: "profitability",
+			unit: "percent",
+			numerator: grossProfit,
+			denominator: facts.revenue,
+			formula: "gross profit ÷ revenue"
+		},
+		{
+			key: "markup",
+			label: "Mark-up",
+			family: "profitability",
+			unit: "percent",
+			numerator: grossProfit,
+			denominator: facts.costOfSales,
+			formula: "gross profit ÷ cost of sales"
+		},
+		{
+			key: "netMargin",
+			label: "Net margin",
+			family: "profitability",
+			unit: "percent",
+			numerator: netProfit,
+			denominator: facts.revenue,
+			formula: "profit for the period ÷ revenue"
+		},
+		{
+			key: "roce",
+			label: "Return on capital employed",
+			family: "capital",
+			unit: "percent",
+			numerator: netProfit,
+			denominator: capitalEmployed,
+			formula: "profit for the period ÷ capital employed"
+		},
+		{
+			key: "gearing",
+			label: "Gearing",
+			family: "capital",
+			unit: "percent",
+			numerator: facts.nonCurrentLiabilities,
+			denominator: capitalEmployed,
+			formula: "non-current liabilities ÷ capital employed"
+		},
+		{
+			key: "inventoryTurnover",
+			label: "Inventory turnover",
+			family: "efficiency",
+			unit: "times",
+			numerator: facts.costOfSales,
+			denominator: facts.averageInventory ?? facts.inventory,
+			formula: "cost of sales ÷ average inventory"
+		},
+		{
+			key: "inventoryDays",
+			label: "Inventory holding period",
+			family: "efficiency",
+			unit: "days",
+			numerator: (facts.averageInventory ?? facts.inventory) * days,
+			denominator: facts.costOfSales,
+			formula: "average inventory ÷ cost of sales × days"
+		}
+	];
+	if (facts.tradeReceivables != null) definitions.push({
+		key: "receivablesDays",
+		label: "Receivables collection period",
+		family: "efficiency",
+		unit: "days",
+		numerator: facts.tradeReceivables * days,
+		denominator: facts.creditRevenue ?? facts.revenue,
+		formula: "trade receivables ÷ credit revenue × days"
+	});
+	if (facts.tradePayables != null && facts.creditPurchases != null) definitions.push({
+		key: "payablesDays",
+		label: "Payables payment period",
+		family: "efficiency",
+		unit: "days",
+		numerator: facts.tradePayables * days,
+		denominator: facts.creditPurchases,
+		formula: "trade payables ÷ credit purchases × days"
+	});
+	const diagnostics = [];
+	const trace = [];
+	const metrics = definitions.map((definition) => {
+		const value = definition.denominator === 0 ? null : definition.numerator / definition.denominator;
+		if (value == null) diagnostics.push({
+			code: "invalid-analysis",
+			severity: "warning",
+			message: `${definition.label} is undefined because its denominator is zero.`
+		});
+		trace.push({
+			id: `ratio:${definition.key}`,
+			kind: "derive",
+			rule: definition.formula,
+			working: `${definition.numerator} ÷ ${definition.denominator}`,
+			result: value ?? "undefined"
+		});
+		return {
+			...definition,
+			value
+		};
+	});
+	return {
+		values: {
+			workingCapital: facts.currentAssets - facts.currentLiabilities,
+			grossProfit,
+			netProfit,
+			capitalEmployed
+		},
+		metrics,
+		diagnostics,
+		trace
+	};
+}
+function assessFinancialPerformance(analysis, benchmarks) {
+	return benchmarks.map((benchmark) => {
+		const value = analysis.metrics.find((metric) => metric.key === benchmark.key)?.value ?? null;
+		return {
+			key: benchmark.key,
+			value,
+			passes: value != null && (benchmark.minimum == null || value >= benchmark.minimum) && (benchmark.maximum == null || value <= benchmark.maximum),
+			benchmark
+		};
+	});
+}
+function compareFinancialPerformance(currentFacts, priorFacts) {
+	const current = analyzeFinancialPerformance(currentFacts);
+	const prior = analyzeFinancialPerformance(priorFacts);
+	return {
+		current,
+		prior,
+		deltas: current.metrics.map((metric) => {
+			const priorValue = prior.metrics.find((candidate) => candidate.key === metric.key)?.value ?? null;
+			return {
+				key: metric.key,
+				current: metric.value,
+				prior: priorValue,
+				absolute: metric.value == null || priorValue == null ? null : metric.value - priorValue
+			};
+		})
+	};
+}
+
+//#endregion
+export { analyzeFinancialPerformance, assessFinancialPerformance, compareFinancialPerformance };

package/dist/finance/accounting/clubs.d.mts

@@ -0,0 +1,21 @@
+import { AccountingPolicy, ClubMemberState, ClubMemberTiming, ClubStatementFacts, ClubStatementResult, ClubSubscriptionResult } from "./types.mjs";
+
+//#region src/finance/accounting/clubs.d.ts
+declare const CLUB_MEMBER_STATES: readonly ["paid", "arrearsSettled", "prepaidLastYear", "owesThisYear", "prepaidNextYear"];
+declare function clubMemberTiming(state: ClubMemberState): ClubMemberTiming;
+declare function clubMemberCrossesYear(state: ClubMemberState): boolean;
+declare function solveClubSubscriptions({
+  members,
+  subscription,
+  policy
+}: {
+  members: readonly {
+    name: string;
+    state: ClubMemberState;
+  }[];
+  subscription: number;
+  policy?: AccountingPolicy;
+}): ClubSubscriptionResult;
+declare function solveClubStatements(facts: ClubStatementFacts, policy?: AccountingPolicy): ClubStatementResult;
+//#endregion
+export { CLUB_MEMBER_STATES, clubMemberCrossesYear, clubMemberTiming, solveClubStatements, solveClubSubscriptions };

package/dist/finance/accounting/clubs.mjs

@@ -0,0 +1,217 @@
+import { DEFAULT_ACCOUNTING_POLICY, fromMinor, toMinor } from "./precision.mjs";
+
+//#region src/finance/accounting/clubs.ts
+const CLUB_MEMBER_STATES = [
+	"paid",
+	"arrearsSettled",
+	"prepaidLastYear",
+	"owesThisYear",
+	"prepaidNextYear"
+];
+function clubMemberTiming(state) {
+	if (state === "paid") return {
+		belongsTo: 0,
+		arrived: 0
+	};
+	if (state === "arrearsSettled") return {
+		belongsTo: -1,
+		arrived: 0
+	};
+	if (state === "prepaidLastYear") return {
+		belongsTo: 0,
+		arrived: -1
+	};
+	if (state === "owesThisYear") return {
+		belongsTo: 0,
+		arrived: null
+	};
+	return {
+		belongsTo: 1,
+		arrived: 0
+	};
+}
+function clubMemberCrossesYear(state) {
+	const timing = clubMemberTiming(state);
+	return timing.arrived !== timing.belongsTo;
+}
+function solveClubSubscriptions({ members, subscription, policy = DEFAULT_ACCOUNTING_POLICY }) {
+	const diagnostics = [];
+	if (!Number.isFinite(subscription) || subscription <= 0) diagnostics.push({
+		code: "invalid-adjustment",
+		severity: "error",
+		message: "Annual subscription must be a finite positive amount."
+	});
+	if (members.length === 0) diagnostics.push({
+		code: "invalid-adjustment",
+		severity: "error",
+		message: "At least one club member is required."
+	});
+	if (diagnostics.length > 0) return {
+		members: members.length,
+		cashReceived: 0,
+		subscriptionIncome: 0,
+		gap: 0,
+		accruedIncome: 0,
+		prepaidIncome: 0,
+		arrearsSettled: 0,
+		broughtForwardPrepaid: 0,
+		accountRows: [],
+		accountDebitTotal: 0,
+		accountCreditTotal: 0,
+		accountBalances: false,
+		diagnostics,
+		trace: []
+	};
+	const unit = toMinor(subscription, policy);
+	const count = (state) => members.filter((member) => member.state === state).length;
+	const cash = (count("paid") + count("arrearsSettled") + count("prepaidNextYear")) * unit;
+	const income = (count("paid") + count("prepaidLastYear") + count("owesThisYear")) * unit;
+	const arrears = count("arrearsSettled") * unit, broughtPrepaid = count("prepaidLastYear") * unit, accrued = count("owesThisYear") * unit, prepaid = count("prepaidNextYear") * unit;
+	const rows = [];
+	if (arrears) rows.push({
+		label: "Balance b/d (owing by members)",
+		debit: fromMinor(arrears, policy),
+		from: "arrearsSettled"
+	});
+	if (broughtPrepaid) rows.push({
+		label: "Balance b/d (paid in advance)",
+		credit: fromMinor(broughtPrepaid, policy),
+		from: "prepaidLastYear"
+	});
+	rows.push({
+		label: "Income and expenditure account",
+		debit: fromMinor(income, policy)
+	}, {
+		label: "Cash received",
+		credit: fromMinor(cash, policy)
+	});
+	if (prepaid) rows.push({
+		label: "Balance c/d (paid in advance)",
+		debit: fromMinor(prepaid, policy),
+		from: "prepaidNextYear"
+	});
+	if (accrued) rows.push({
+		label: "Balance c/d (owing by members)",
+		credit: fromMinor(accrued, policy),
+		from: "owesThisYear"
+	});
+	const debit = rows.reduce((sum, row) => sum + toMinor(row.debit ?? 0, policy), 0), credit = rows.reduce((sum, row) => sum + toMinor(row.credit ?? 0, policy), 0);
+	const reconciled = cash - arrears - prepaid + accrued + broughtPrepaid;
+	const trace = [{
+		id: "club:subscription-income",
+		kind: "derive",
+		rule: "Subscription income = cash received − opening arrears − closing prepayments + closing arrears + opening prepayments.",
+		working: `${fromMinor(cash, policy)} − ${fromMinor(arrears, policy)} − ${fromMinor(prepaid, policy)} + ${fromMinor(accrued, policy)} + ${fromMinor(broughtPrepaid, policy)}`,
+		result: fromMinor(reconciled, policy)
+	}, {
+		id: "club:subscription-account",
+		kind: "check",
+		rule: "The subscriptions account must have equal debit and credit totals.",
+		working: `${fromMinor(debit, policy)} = ${fromMinor(credit, policy)}`,
+		result: debit === credit
+	}];
+	return {
+		members: members.length,
+		cashReceived: fromMinor(cash, policy),
+		subscriptionIncome: fromMinor(income, policy),
+		gap: fromMinor(cash - income, policy),
+		accruedIncome: fromMinor(accrued, policy),
+		prepaidIncome: fromMinor(prepaid, policy),
+		arrearsSettled: fromMinor(arrears, policy),
+		broughtForwardPrepaid: fromMinor(broughtPrepaid, policy),
+		accountRows: rows,
+		accountDebitTotal: fromMinor(debit, policy),
+		accountCreditTotal: fromMinor(credit, policy),
+		accountBalances: debit === credit && reconciled === income,
+		diagnostics,
+		trace
+	};
+}
+const line = (id, label, amount, kind = "detail", treatment) => ({
+	id,
+	label,
+	amount,
+	kind,
+	...treatment ? { treatment } : {}
+});
+const section = (id, title, lines) => ({
+	id,
+	title,
+	lines
+});
+function solveClubStatements(facts, policy = DEFAULT_ACCOUNTING_POLICY) {
+	const diagnostics = [];
+	for (const [name, value] of Object.entries(facts)) if (!Number.isFinite(value) || value < 0) diagnostics.push({
+		code: "invalid-adjustment",
+		severity: "error",
+		message: `${name} must be a finite non-negative amount.`
+	});
+	if (diagnostics.length > 0) return {
+		openingAccumulatedFund: 0,
+		surplus: 0,
+		expectedClosingFund: 0,
+		closingNetAssets: 0,
+		difference: 0,
+		reconciles: false,
+		incomeAndExpenditure: [],
+		statementOfFinancialPosition: [],
+		diagnostics,
+		trace: []
+	};
+	const m = (value) => toMinor(value, policy), out = (value) => fromMinor(value, policy);
+	const openingFund = m(facts.openingAssets) - m(facts.openingLiabilities);
+	const surplus = m(facts.subscriptionIncome) + m(facts.otherIncome) - m(facts.expenses);
+	const expectedClosingFund = openingFund + surplus;
+	const closingNetAssets = m(facts.closingAssets) - m(facts.closingLiabilities);
+	const difference = closingNetAssets - expectedClosingFund;
+	return {
+		openingAccumulatedFund: out(openingFund),
+		surplus: out(surplus),
+		expectedClosingFund: out(expectedClosingFund),
+		closingNetAssets: out(closingNetAssets),
+		difference: out(difference),
+		reconciles: difference === 0,
+		incomeAndExpenditure: [section("income-expenditure", "Income and expenditure", [
+			line("subscriptions", "Subscriptions", facts.subscriptionIncome, "detail", "add"),
+			line("other-income", "Other income", facts.otherIncome, "detail", "add"),
+			line("expenses", "Expenses", facts.expenses, "detail", "subtract"),
+			line("surplus", "Surplus for the year", out(surplus), "total", "result")
+		])],
+		statementOfFinancialPosition: [section("fund", "Accumulated fund", [
+			line("opening-fund", "Opening accumulated fund", out(openingFund), "detail", "add"),
+			line("surplus-fund", "Surplus for the year", out(surplus), "detail", "add"),
+			line("closing-fund", "Closing accumulated fund", out(expectedClosingFund), "total", "result")
+		]), section("net-assets", "Net assets", [
+			line("closing-assets", "Closing assets", facts.closingAssets),
+			line("closing-liabilities", "Closing liabilities", facts.closingLiabilities, "detail", "subtract"),
+			line("closing-net-assets", "Closing net assets", out(closingNetAssets), "total", "result")
+		])],
+		diagnostics,
+		trace: [
+			{
+				id: "club:opening-fund",
+				kind: "derive",
+				rule: "Opening accumulated fund = opening assets − opening liabilities.",
+				working: `${facts.openingAssets} − ${facts.openingLiabilities}`,
+				result: out(openingFund)
+			},
+			{
+				id: "club:surplus",
+				kind: "derive",
+				rule: "Surplus = income − expenditure.",
+				working: `${facts.subscriptionIncome} + ${facts.otherIncome} − ${facts.expenses}`,
+				result: out(surplus)
+			},
+			{
+				id: "club:fund-check",
+				kind: "check",
+				rule: "Closing accumulated fund should equal closing net assets.",
+				working: `${out(expectedClosingFund)} compared with ${out(closingNetAssets)}`,
+				result: difference === 0
+			}
+		]
+	};
+}
+
+//#endregion
+export { CLUB_MEMBER_STATES, clubMemberCrossesYear, clubMemberTiming, solveClubStatements, solveClubSubscriptions };

package/dist/finance/accounting/company-statements.d.mts

@@ -0,0 +1,7 @@
+import { AccountingPolicy, LimitedCompanyStatementFacts, LimitedCompanyStatementResult } from "./types.mjs";
+
+//#region src/finance/accounting/company-statements.d.ts
+declare function solveLimitedCompanyStatements(facts: LimitedCompanyStatementFacts, policy?: AccountingPolicy): LimitedCompanyStatementResult;
+declare function solveDividendSettledCompanyScenario(base: LimitedCompanyStatementFacts, dividendsDeclared: number, policy?: AccountingPolicy): LimitedCompanyStatementResult;
+//#endregion
+export { solveDividendSettledCompanyScenario, solveLimitedCompanyStatements };