@classytic/stage 0.3.0 → 0.4.0

package/dist/finance/accounting/company-statements.mjs

@@ -0,0 +1,150 @@
+import { DEFAULT_ACCOUNTING_POLICY, fromMinor, toMinor } from "./precision.mjs";
+
+//#region src/finance/accounting/company-statements.ts
+const line = (id, label, amount, kind = "detail", treatment) => ({
+	id,
+	label,
+	amount,
+	kind,
+	...treatment ? { treatment } : {}
+});
+const section = (id, title, lines) => ({
+	id,
+	title,
+	lines
+});
+function solveLimitedCompanyStatements(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.`
+	});
+	const zero = {
+		grossProfit: 0,
+		operatingProfit: 0,
+		profitBeforeTax: 0,
+		profitForYear: 0,
+		closingRetainedEarnings: 0,
+		totalEquity: 0,
+		totalLiabilities: 0,
+		totalAssets: 0,
+		totalEquityAndLiabilities: 0,
+		balanceDifference: 0
+	};
+	if (diagnostics.length > 0) return {
+		incomeStatement: [],
+		statementOfChangesInEquity: [],
+		statementOfFinancialPosition: [],
+		values: zero,
+		balances: false,
+		diagnostics,
+		trace: []
+	};
+	const m = (value) => toMinor(value, policy);
+	const out = (value) => fromMinor(value, policy);
+	const grossProfit = m(facts.revenue) - m(facts.costOfSales);
+	const operatingProfit = grossProfit - m(facts.operatingExpenses);
+	const profitBeforeTax = operatingProfit - m(facts.financeCosts);
+	const profitForYear = profitBeforeTax - m(facts.taxExpense);
+	const closingRetainedEarnings = m(facts.openingRetainedEarnings) + profitForYear - m(facts.dividendsDeclared);
+	const totalEquity = m(facts.ordinaryShareCapital) + m(facts.sharePremium ?? 0) + m(facts.generalReserve ?? 0) + closingRetainedEarnings;
+	const totalLiabilities = m(facts.debentures) + m(facts.currentLiabilities);
+	const totalAssets = m(facts.nonCurrentAssets) + m(facts.currentAssets);
+	const totalEquityAndLiabilities = totalEquity + totalLiabilities;
+	const balanceDifference = totalAssets - totalEquityAndLiabilities;
+	const values = {
+		grossProfit: out(grossProfit),
+		operatingProfit: out(operatingProfit),
+		profitBeforeTax: out(profitBeforeTax),
+		profitForYear: out(profitForYear),
+		closingRetainedEarnings: out(closingRetainedEarnings),
+		totalEquity: out(totalEquity),
+		totalLiabilities: out(totalLiabilities),
+		totalAssets: out(totalAssets),
+		totalEquityAndLiabilities: out(totalEquityAndLiabilities),
+		balanceDifference: out(balanceDifference)
+	};
+	return {
+		incomeStatement: [section("trading", "Trading", [
+			line("revenue", "Revenue", facts.revenue, "detail", "add"),
+			line("cost-of-sales", "Cost of sales", facts.costOfSales, "detail", "subtract"),
+			line("gross-profit", "Gross profit", values.grossProfit, "subtotal", "result")
+		]), section("operations", "Operations and finance", [
+			line("operating-expenses", "Operating expenses", facts.operatingExpenses, "detail", "subtract"),
+			line("operating-profit", "Operating profit", values.operatingProfit, "subtotal", "result"),
+			line("finance-costs", "Finance costs", facts.financeCosts, "detail", "subtract"),
+			line("profit-before-tax", "Profit before tax", values.profitBeforeTax, "subtotal", "result"),
+			line("tax-expense", "Income tax expense", facts.taxExpense, "detail", "subtract"),
+			line("profit-for-year", "Profit for the year", values.profitForYear, "total", "result")
+		])],
+		statementOfChangesInEquity: [section("retained-earnings", "Retained earnings", [
+			line("opening-retained", "Opening retained earnings", facts.openingRetainedEarnings, "detail", "add"),
+			line("profit-for-year-equity", "Profit for the year", values.profitForYear, "detail", "add"),
+			line("dividends", "Dividends declared", facts.dividendsDeclared, "detail", "subtract"),
+			line("closing-retained", "Closing retained earnings", values.closingRetainedEarnings, "total", "result")
+		])],
+		statementOfFinancialPosition: [
+			section("assets", "Assets", [
+				line("non-current-assets", "Non-current assets", facts.nonCurrentAssets),
+				line("current-assets", "Current assets", facts.currentAssets),
+				line("total-assets", "Total assets", values.totalAssets, "total", "result")
+			]),
+			section("equity", "Equity", [
+				line("ordinary-share-capital", "Ordinary share capital", facts.ordinaryShareCapital),
+				line("share-premium", "Share premium", facts.sharePremium ?? 0),
+				line("general-reserve", "General reserve", facts.generalReserve ?? 0),
+				line("retained-earnings-position", "Retained earnings", values.closingRetainedEarnings),
+				line("total-equity", "Total equity", values.totalEquity, "subtotal", "result")
+			]),
+			section("liabilities", "Liabilities", [
+				line("debentures", "Debentures", facts.debentures),
+				line("current-liabilities", "Current liabilities", facts.currentLiabilities),
+				line("equity-and-liabilities", "Total equity and liabilities", values.totalEquityAndLiabilities, "total", "result")
+			])
+		],
+		values,
+		balances: balanceDifference === 0,
+		diagnostics,
+		trace: [
+			{
+				id: "company:profit",
+				kind: "derive",
+				rule: "Profit for the year follows trading, operating, finance and tax stages.",
+				working: `${facts.revenue} − ${facts.costOfSales} − ${facts.operatingExpenses} − ${facts.financeCosts} − ${facts.taxExpense}`,
+				result: values.profitForYear
+			},
+			{
+				id: "company:retained",
+				kind: "derive",
+				rule: "Closing retained earnings = opening retained earnings + profit for the year − dividends.",
+				working: `${facts.openingRetainedEarnings} + ${values.profitForYear} − ${facts.dividendsDeclared}`,
+				result: values.closingRetainedEarnings
+			},
+			{
+				id: "company:dividend",
+				kind: "classify",
+				rule: "A dividend is a distribution of profit, not an operating expense.",
+				working: `${facts.dividendsDeclared} deducted in changes in equity`,
+				result: "appropriation of retained earnings"
+			},
+			{
+				id: "company:position",
+				kind: "check",
+				rule: "Assets must equal equity plus liabilities; debentures are liabilities, not share capital.",
+				working: `${values.totalAssets} − ${values.totalEquityAndLiabilities}`,
+				result: balanceDifference === 0
+			}
+		]
+	};
+}
+function solveDividendSettledCompanyScenario(base, dividendsDeclared, policy = DEFAULT_ACCOUNTING_POLICY) {
+	return solveLimitedCompanyStatements({
+		...base,
+		dividendsDeclared,
+		currentAssets: base.currentAssets - (dividendsDeclared - base.dividendsDeclared)
+	}, policy);
+}
+
+//#endregion
+export { solveDividendSettledCompanyScenario, solveLimitedCompanyStatements };

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

@@ -0,0 +1,7 @@
+import { AccountingCase, AccountingCaseResult } from "./types.mjs";
+
+//#region src/finance/accounting/harness.d.ts
+/** Runs a curriculum case through the same engine used by interactive labs. */
+declare function runAccountingCase(problem: AccountingCase): AccountingCaseResult;
+//#endregion
+export { runAccountingCase };

package/dist/finance/accounting/harness.mjs

@@ -0,0 +1,45 @@
+import { solveBusinessProblem, solveJournal } from "./solve.mjs";
+
+//#region src/finance/accounting/harness.ts
+function check(name, actual, expected) {
+	return {
+		name,
+		passed: Array.isArray(actual) && Array.isArray(expected) ? actual.length === expected.length && actual.every((value, index) => value === expected[index]) : actual === expected,
+		expected,
+		actual
+	};
+}
+/** Runs a curriculum case through the same engine used by interactive labs. */
+function runAccountingCase(problem) {
+	if (problem.events == null === (problem.entries == null)) throw new Error(`Accounting case ${problem.id} must define exactly one of events or entries.`);
+	const solution = problem.events ? solveBusinessProblem({
+		accounts: problem.accounts,
+		events: problem.events,
+		policy: problem.policy
+	}) : solveJournal({
+		accounts: problem.accounts,
+		entries: problem.entries,
+		policy: problem.policy
+	});
+	const checks = [];
+	const expected = problem.expect;
+	if (expected.acceptedEntries != null) checks.push(check("accepted entries", solution.acceptedEntries.length, expected.acceptedEntries));
+	if (expected.rejectedEntries != null) checks.push(check("rejected entries", solution.rejectedEntries.length, expected.rejectedEntries));
+	if (expected.trialBalanceTotal != null) checks.push(check("trial balance total", solution.trialBalance.debitTotal, expected.trialBalanceTotal));
+	if (expected.profit != null) checks.push(check("profit", solution.equation.profit, expected.profit));
+	if (expected.assets != null) checks.push(check("assets", solution.equation.assets, expected.assets));
+	if (expected.liabilities != null) checks.push(check("liabilities", solution.equation.liabilities, expected.liabilities));
+	if (expected.equity != null) checks.push(check("equity", solution.equation.equity, expected.equity));
+	if (expected.diagnosticCodes != null) checks.push(check("diagnostic codes", solution.diagnostics.map((item) => item.code).sort(), [...expected.diagnosticCodes].sort()));
+	checks.push(check("trial balance invariant", String(solution.trialBalance.balances), "true"));
+	checks.push(check("accounting equation invariant", String(solution.equation.balances), "true"));
+	return {
+		caseId: problem.id,
+		passed: checks.every((item) => item.passed),
+		checks,
+		solution
+	};
+}
+
+//#endregion
+export { runAccountingCase };

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

@@ -0,0 +1,18 @@
+import { AccountCategory, AccountDefinition, AccountRole, AccountingCase, AccountingCaseResult, AccountingCheck, AccountingDiagnostic, AccountingEquation, AccountingExpectation, AccountingPolicy, AccountingSolution, AdjustmentFact, AdjustmentResult, BankReconciliationItem, BankReconciliationResult, BusinessEvent, ClubMember, ClubMemberState, ClubMemberTiming, ClubStatementFacts, ClubStatementResult, ClubSubscriptionResult, ControlAccountFacts, ControlAccountResult, ExplanationStep, FinancialAnalysisComparison, FinancialAnalysisFacts, FinancialAnalysisResult, FinancialRatioAssessment, FinancialRatioBenchmark, FinancialRatioFamily, FinancialRatioKey, FinancialRatioMetric, FinancialStatements, JournalEntry, JournalLine, LedgerAccount, LedgerPosting, LimitedCompanyStatementFacts, LimitedCompanyStatementResult, ManufacturingAccountFacts, ManufacturingAccountResult, ManufacturingFlowStage, ManufacturingTradingFacts, ManufacturingTradingResult, PartnerAppropriation, PartnerFacts, PartnershipAgreement, PartnershipResult, PostingSide, SoleTraderPeriodCase, SoleTraderPeriodResult, SoleTraderStatementFacts, SoleTraderStatementResult, StatementLine, StatementSection, SuspenseCorrectionFact, SuspenseDiscoveredError, SuspenseMovement, SuspenseReconstructionFacts, SuspenseReconstructionResult, TrialBalance, TrialBalanceErrorDiagnosis, TrialBalanceErrorType, TrialBalanceLine } from "./types.mjs";
+import { DEFAULT_ACCOUNTING_POLICY, amountScale, fromMinor, toMinor } from "./precision.mjs";
+import { changeSide, deriveNaturalEquation, normalBalance, statementOf, totalsBalance } from "./rules.mjs";
+import { validateChart, validateJournalEntry } from "./validate.mjs";
+import { journalizeBusinessEvent, journalizeBusinessEvents } from "./journalize.mjs";
+import { applyAdjustments, produceAdjustment } from "./adjustments.mjs";
+import { createSuspenseCorrection, diagnoseTrialBalanceError, reconcileBank, reconstructSuspenseAccount, solveControlAccount } from "./verification.mjs";
+import { solveCashSettledSoleTraderScenario, solveSoleTraderStatements } from "./statements.mjs";
+import { salaryForEqualPartnershipShares, solvePartnershipAppropriation } from "./partnership.mjs";
+import { solveDividendSettledCompanyScenario, solveLimitedCompanyStatements } from "./company-statements.mjs";
+import { CLUB_MEMBER_STATES, clubMemberCrossesYear, clubMemberTiming, solveClubStatements, solveClubSubscriptions } from "./clubs.mjs";
+import { solveManufacturingAccount, solveManufacturingTradingFlow } from "./manufacturing.mjs";
+import { solveSoleTraderPeriod } from "./period-case.mjs";
+import { analyzeFinancialPerformance, assessFinancialPerformance, compareFinancialPerformance } from "./analysis.mjs";
+import { runAccountingCase } from "./harness.mjs";
+import { deriveEquation, deriveStatements, deriveTrialBalance, postLedger } from "./post.mjs";
+import { SolveJournalOptions, solveBusinessProblem, solveJournal } from "./solve.mjs";
+export { AccountCategory, AccountDefinition, AccountRole, AccountingCase, AccountingCaseResult, AccountingCheck, AccountingDiagnostic, AccountingEquation, AccountingExpectation, AccountingPolicy, AccountingSolution, AdjustmentFact, AdjustmentResult, BankReconciliationItem, BankReconciliationResult, BusinessEvent, CLUB_MEMBER_STATES, ClubMember, ClubMemberState, ClubMemberTiming, ClubStatementFacts, ClubStatementResult, ClubSubscriptionResult, ControlAccountFacts, ControlAccountResult, DEFAULT_ACCOUNTING_POLICY, ExplanationStep, FinancialAnalysisComparison, FinancialAnalysisFacts, FinancialAnalysisResult, FinancialRatioAssessment, FinancialRatioBenchmark, FinancialRatioFamily, FinancialRatioKey, FinancialRatioMetric, FinancialStatements, JournalEntry, JournalLine, LedgerAccount, LedgerPosting, LimitedCompanyStatementFacts, LimitedCompanyStatementResult, ManufacturingAccountFacts, ManufacturingAccountResult, ManufacturingFlowStage, ManufacturingTradingFacts, ManufacturingTradingResult, PartnerAppropriation, PartnerFacts, PartnershipAgreement, PartnershipResult, PostingSide, SoleTraderPeriodCase, SoleTraderPeriodResult, SoleTraderStatementFacts, SoleTraderStatementResult, SolveJournalOptions, StatementLine, StatementSection, SuspenseCorrectionFact, SuspenseDiscoveredError, SuspenseMovement, SuspenseReconstructionFacts, SuspenseReconstructionResult, TrialBalance, TrialBalanceErrorDiagnosis, TrialBalanceErrorType, TrialBalanceLine, amountScale, analyzeFinancialPerformance, applyAdjustments, assessFinancialPerformance, changeSide, clubMemberCrossesYear, clubMemberTiming, compareFinancialPerformance, createSuspenseCorrection, deriveEquation, deriveNaturalEquation, deriveStatements, deriveTrialBalance, diagnoseTrialBalanceError, fromMinor, journalizeBusinessEvent, journalizeBusinessEvents, normalBalance, postLedger, produceAdjustment, reconcileBank, reconstructSuspenseAccount, runAccountingCase, salaryForEqualPartnershipShares, solveBusinessProblem, solveCashSettledSoleTraderScenario, solveClubStatements, solveClubSubscriptions, solveControlAccount, solveDividendSettledCompanyScenario, solveJournal, solveLimitedCompanyStatements, solveManufacturingAccount, solveManufacturingTradingFlow, solvePartnershipAppropriation, solveSoleTraderPeriod, solveSoleTraderStatements, statementOf, toMinor, totalsBalance, validateChart, validateJournalEntry };

package/dist/finance/accounting/index.mjs

@@ -0,0 +1,18 @@
+import { journalizeBusinessEvent, journalizeBusinessEvents } from "./journalize.mjs";
+import { DEFAULT_ACCOUNTING_POLICY, amountScale, fromMinor, toMinor } from "./precision.mjs";
+import { changeSide, deriveNaturalEquation, normalBalance, statementOf, totalsBalance } from "./rules.mjs";
+import { deriveEquation, deriveStatements, deriveTrialBalance, postLedger } from "./post.mjs";
+import { validateChart, validateJournalEntry } from "./validate.mjs";
+import { solveBusinessProblem, solveJournal } from "./solve.mjs";
+import { applyAdjustments, produceAdjustment } from "./adjustments.mjs";
+import { createSuspenseCorrection, diagnoseTrialBalanceError, reconcileBank, reconstructSuspenseAccount, solveControlAccount } from "./verification.mjs";
+import { solveCashSettledSoleTraderScenario, solveSoleTraderStatements } from "./statements.mjs";
+import { salaryForEqualPartnershipShares, solvePartnershipAppropriation } from "./partnership.mjs";
+import { solveDividendSettledCompanyScenario, solveLimitedCompanyStatements } from "./company-statements.mjs";
+import { CLUB_MEMBER_STATES, clubMemberCrossesYear, clubMemberTiming, solveClubStatements, solveClubSubscriptions } from "./clubs.mjs";
+import { solveManufacturingAccount, solveManufacturingTradingFlow } from "./manufacturing.mjs";
+import { solveSoleTraderPeriod } from "./period-case.mjs";
+import { analyzeFinancialPerformance, assessFinancialPerformance, compareFinancialPerformance } from "./analysis.mjs";
+import { runAccountingCase } from "./harness.mjs";
+
+export { CLUB_MEMBER_STATES, DEFAULT_ACCOUNTING_POLICY, amountScale, analyzeFinancialPerformance, applyAdjustments, assessFinancialPerformance, changeSide, clubMemberCrossesYear, clubMemberTiming, compareFinancialPerformance, createSuspenseCorrection, deriveEquation, deriveNaturalEquation, deriveStatements, deriveTrialBalance, diagnoseTrialBalanceError, fromMinor, journalizeBusinessEvent, journalizeBusinessEvents, normalBalance, postLedger, produceAdjustment, reconcileBank, reconstructSuspenseAccount, runAccountingCase, salaryForEqualPartnershipShares, solveBusinessProblem, solveCashSettledSoleTraderScenario, solveClubStatements, solveClubSubscriptions, solveControlAccount, solveDividendSettledCompanyScenario, solveJournal, solveLimitedCompanyStatements, solveManufacturingAccount, solveManufacturingTradingFlow, solvePartnershipAppropriation, solveSoleTraderPeriod, solveSoleTraderStatements, statementOf, toMinor, totalsBalance, validateChart, validateJournalEntry };

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

@@ -0,0 +1,16 @@
+import { AccountDefinition, AccountingDiagnostic, BusinessEvent, ExplanationStep, JournalEntry } from "./types.mjs";
+
+//#region src/finance/accounting/journalize.d.ts
+interface JournalizedEvent {
+  entry?: JournalEntry;
+  diagnostics: AccountingDiagnostic[];
+  trace: ExplanationStep[];
+}
+declare function journalizeBusinessEvent(event: BusinessEvent, accounts: readonly AccountDefinition[]): JournalizedEvent;
+declare function journalizeBusinessEvents(events: readonly BusinessEvent[], accounts: readonly AccountDefinition[]): {
+  entries: JournalEntry[];
+  diagnostics: AccountingDiagnostic[];
+  trace: ExplanationStep[];
+};
+//#endregion
+export { journalizeBusinessEvent, journalizeBusinessEvents };

package/dist/finance/accounting/journalize.mjs

@@ -0,0 +1,128 @@
+//#region src/finance/accounting/journalize.ts
+function accountForRole(accounts, role, eventId) {
+	const matches = accounts.filter((account) => account.role === role);
+	if (matches.length === 0) return { diagnostic: {
+		code: "missing-role",
+		severity: "error",
+		entryId: eventId,
+		message: `No account is assigned the ${role} role.`
+	} };
+	if (matches.length > 1) return { diagnostic: {
+		code: "ambiguous-role",
+		severity: "error",
+		entryId: eventId,
+		message: `More than one account is assigned the ${role} role.`
+	} };
+	return { account: matches[0] };
+}
+function journalizeBusinessEvent(event, accounts) {
+	const diagnostics = [];
+	const trace = [{
+		id: `${event.id}:classify`,
+		kind: "classify",
+		rule: "Classify the business event before choosing accounts.",
+		working: event.type,
+		result: event.type
+	}];
+	const required = [];
+	const specs = [];
+	const add = (role, side, amount = event.amount) => {
+		required.push(role);
+		specs.push({
+			role,
+			side,
+			amount
+		});
+	};
+	switch (event.type) {
+		case "owner-investment":
+			add("cash", "debit");
+			add("capital", "credit");
+			break;
+		case "borrow":
+			add("cash", "debit");
+			add("loan", "credit");
+			break;
+		case "buy-equipment":
+			add("equipment", "debit");
+			add(event.settlement === "cash" ? "cash" : "payable", "credit");
+			break;
+		case "buy-inventory":
+			add("inventory", "debit");
+			add(event.settlement === "cash" ? "cash" : "payable", "credit");
+			break;
+		case "sale":
+			add(event.settlement === "cash" ? "cash" : "receivable", "debit");
+			add("revenue", "credit");
+			if (event.cost != null) {
+				add("cost-of-sales", "debit", event.cost);
+				add("inventory", "credit", event.cost);
+			}
+			break;
+		case "pay-expense":
+			add("expense", "debit");
+			add("cash", "credit");
+			break;
+		case "owner-drawings":
+			add("drawings", "debit");
+			add("cash", "credit");
+			break;
+		case "collect-receivable":
+			add("cash", "debit");
+			add("receivable", "credit");
+			break;
+		case "pay-payable":
+			add("payable", "debit");
+			add("cash", "credit");
+			break;
+	}
+	const resolved = /* @__PURE__ */ new Map();
+	for (const role of new Set(required)) {
+		const result = accountForRole(accounts, role, event.id);
+		if (result.diagnostic) diagnostics.push(result.diagnostic);
+		if (result.account) resolved.set(role, result.account);
+	}
+	if (diagnostics.length > 0) return {
+		diagnostics,
+		trace
+	};
+	const lines = specs.map((spec) => ({
+		accountId: resolved.get(spec.role).id,
+		side: spec.side,
+		amount: spec.amount
+	}));
+	const narration = event.narration ?? event.type.replaceAll("-", " ");
+	trace.push({
+		id: `${event.id}:journalize`,
+		kind: "journalize",
+		rule: "Every event changes at least two accounts with equal debits and credits.",
+		working: lines.map((line) => `${line.side} ${line.accountId} ${line.amount}`).join("; "),
+		result: "journal prepared"
+	});
+	return {
+		entry: {
+			id: event.id,
+			narration,
+			lines
+		},
+		diagnostics,
+		trace
+	};
+}
+function journalizeBusinessEvents(events, accounts) {
+	const entries = [], diagnostics = [], trace = [];
+	for (const event of events) {
+		const result = journalizeBusinessEvent(event, accounts);
+		if (result.entry) entries.push(result.entry);
+		diagnostics.push(...result.diagnostics);
+		trace.push(...result.trace);
+	}
+	return {
+		entries,
+		diagnostics,
+		trace
+	};
+}
+
+//#endregion
+export { journalizeBusinessEvent, journalizeBusinessEvents };

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

@@ -0,0 +1,8 @@
+import { AccountingPolicy, ManufacturingAccountFacts, ManufacturingAccountResult, ManufacturingTradingFacts, ManufacturingTradingResult } from "./types.mjs";
+
+//#region src/finance/accounting/manufacturing.d.ts
+declare function solveManufacturingAccount(facts: ManufacturingAccountFacts, policy?: AccountingPolicy): ManufacturingAccountResult;
+/** Carries factory output through finished-goods inventory into cost of sales and gross profit. */
+declare function solveManufacturingTradingFlow(facts: ManufacturingTradingFacts, policy?: AccountingPolicy): ManufacturingTradingResult;
+//#endregion
+export { solveManufacturingAccount, solveManufacturingTradingFlow };

package/dist/finance/accounting/manufacturing.mjs

@@ -0,0 +1,236 @@
+import { DEFAULT_ACCOUNTING_POLICY, fromMinor, toMinor } from "./precision.mjs";
+
+//#region src/finance/accounting/manufacturing.ts
+function solveManufacturingAccount(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 (facts.closingRawMaterials > facts.openingRawMaterials + facts.purchasesOfRawMaterials) diagnostics.push({
+		code: "invalid-adjustment",
+		severity: "error",
+		message: "Closing raw materials cannot exceed all raw materials available."
+	});
+	const zero = {
+		materialsConsumed: 0,
+		primeCost: 0,
+		totalFactoryCost: 0,
+		costOfProduction: 0,
+		invertedClosingWipResult: 0,
+		inversionDifference: 0,
+		stages: [],
+		statement: [],
+		diagnostics,
+		trace: []
+	};
+	if (diagnostics.length > 0) return zero;
+	const m = (value) => toMinor(value, policy), out = (value) => fromMinor(value, policy);
+	const materialsConsumed = m(facts.openingRawMaterials) + m(facts.purchasesOfRawMaterials) - m(facts.closingRawMaterials);
+	const primeCost = materialsConsumed + m(facts.directLabour) + m(facts.directExpenses);
+	const totalFactoryCost = primeCost + m(facts.factoryOverheads);
+	const costOfProduction = totalFactoryCost + m(facts.openingWorkInProgress) - m(facts.closingWorkInProgress);
+	if (costOfProduction < 0) {
+		diagnostics.push({
+			code: "invalid-adjustment",
+			severity: "error",
+			message: "Closing work in progress cannot exceed factory cost plus opening work in progress."
+		});
+		return {
+			...zero,
+			diagnostics
+		};
+	}
+	const inverted = totalFactoryCost + m(facts.openingWorkInProgress) + m(facts.closingWorkInProgress);
+	const stages = [
+		{
+			key: "materials",
+			label: "Raw materials consumed",
+			amount: out(materialsConsumed),
+			direction: "in"
+		},
+		{
+			key: "labour",
+			label: "Direct labour",
+			amount: facts.directLabour,
+			direction: "in"
+		},
+		{
+			key: "direct-expenses",
+			label: "Direct expenses",
+			amount: facts.directExpenses,
+			direction: "in",
+			reaches: "prime-cost"
+		},
+		{
+			key: "overheads",
+			label: "Factory overheads",
+			amount: facts.factoryOverheads,
+			direction: "in",
+			reaches: "total-factory-cost"
+		},
+		{
+			key: "opening-wip",
+			label: "Opening work in progress",
+			amount: facts.openingWorkInProgress,
+			direction: "in"
+		},
+		{
+			key: "closing-wip",
+			label: "Closing work in progress",
+			amount: facts.closingWorkInProgress,
+			direction: "out",
+			reaches: "cost-of-production"
+		}
+	];
+	const line = (id, label, amount, kind = "detail", treatment) => ({
+		id,
+		label,
+		amount,
+		kind,
+		...treatment ? { treatment } : {}
+	});
+	const statement = [{
+		id: "manufacturing",
+		title: "Manufacturing account",
+		lines: [
+			line("opening-materials", "Opening raw materials", facts.openingRawMaterials, "detail", "add"),
+			line("purchases-materials", "Purchases of raw materials", facts.purchasesOfRawMaterials, "detail", "add"),
+			line("closing-materials", "Closing raw materials", facts.closingRawMaterials, "detail", "subtract"),
+			line("materials-consumed", "Raw materials consumed", out(materialsConsumed), "subtotal", "result"),
+			line("direct-labour", "Direct labour", facts.directLabour, "detail", "add"),
+			line("direct-expenses", "Direct expenses", facts.directExpenses, "detail", "add"),
+			line("prime-cost", "Prime cost", out(primeCost), "subtotal", "result"),
+			line("factory-overheads", "Factory overheads", facts.factoryOverheads, "detail", "add"),
+			line("factory-cost", "Total factory cost", out(totalFactoryCost), "subtotal", "result"),
+			line("opening-wip", "Opening work in progress", facts.openingWorkInProgress, "detail", "add"),
+			line("closing-wip", "Closing work in progress", facts.closingWorkInProgress, "detail", "subtract"),
+			line("cost-of-production", "Cost of production", out(costOfProduction), "total", "result")
+		]
+	}];
+	return {
+		materialsConsumed: out(materialsConsumed),
+		primeCost: out(primeCost),
+		totalFactoryCost: out(totalFactoryCost),
+		costOfProduction: out(costOfProduction),
+		invertedClosingWipResult: out(inverted),
+		inversionDifference: out(inverted - costOfProduction),
+		stages,
+		statement,
+		diagnostics,
+		trace: [
+			{
+				id: "manufacturing:materials",
+				kind: "derive",
+				rule: "Raw materials consumed = opening inventory + purchases − closing inventory.",
+				working: `${facts.openingRawMaterials} + ${facts.purchasesOfRawMaterials} − ${facts.closingRawMaterials}`,
+				result: out(materialsConsumed)
+			},
+			{
+				id: "manufacturing:prime",
+				kind: "derive",
+				rule: "Prime cost contains direct materials, direct labour and direct expenses.",
+				working: `${out(materialsConsumed)} + ${facts.directLabour} + ${facts.directExpenses}`,
+				result: out(primeCost)
+			},
+			{
+				id: "manufacturing:factory",
+				kind: "derive",
+				rule: "Total factory cost = prime cost + factory overheads.",
+				working: `${out(primeCost)} + ${facts.factoryOverheads}`,
+				result: out(totalFactoryCost)
+			},
+			{
+				id: "manufacturing:production",
+				kind: "derive",
+				rule: "Cost of production = factory cost + opening work in progress − closing work in progress.",
+				working: `${out(totalFactoryCost)} + ${facts.openingWorkInProgress} − ${facts.closingWorkInProgress}`,
+				result: out(costOfProduction)
+			},
+			{
+				id: "manufacturing:sign-check",
+				kind: "check",
+				rule: "Adding instead of deducting closing work in progress overstates production by twice that closing amount.",
+				working: `${out(inverted)} − ${out(costOfProduction)}`,
+				result: out(inverted - costOfProduction)
+			}
+		]
+	};
+}
+/** Carries factory output through finished-goods inventory into cost of sales and gross profit. */
+function solveManufacturingTradingFlow(facts, policy = DEFAULT_ACCOUNTING_POLICY) {
+	const manufacturing = solveManufacturingAccount(facts, policy);
+	const diagnostics = [...manufacturing.diagnostics];
+	for (const name of [
+		"openingFinishedGoods",
+		"closingFinishedGoods",
+		"revenue"
+	]) {
+		const value = facts[name];
+		if (!Number.isFinite(value) || value < 0) diagnostics.push({
+			code: "invalid-adjustment",
+			severity: "error",
+			message: `${name} must be a finite non-negative amount.`
+		});
+	}
+	const zero = {
+		manufacturing,
+		goodsAvailableForSale: 0,
+		costOfSales: 0,
+		grossProfit: 0,
+		diagnostics,
+		trace: manufacturing.trace
+	};
+	if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return zero;
+	const m = (value) => toMinor(value, policy);
+	const out = (value) => fromMinor(value, policy);
+	const goodsAvailableForSale = m(facts.openingFinishedGoods) + m(manufacturing.costOfProduction);
+	if (m(facts.closingFinishedGoods) > goodsAvailableForSale) {
+		diagnostics.push({
+			code: "invalid-adjustment",
+			severity: "error",
+			message: "Closing finished goods cannot exceed goods available for sale."
+		});
+		return {
+			...zero,
+			diagnostics
+		};
+	}
+	const costOfSales = goodsAvailableForSale - m(facts.closingFinishedGoods);
+	const grossProfit = m(facts.revenue) - costOfSales;
+	return {
+		manufacturing,
+		goodsAvailableForSale: out(goodsAvailableForSale),
+		costOfSales: out(costOfSales),
+		grossProfit: out(grossProfit),
+		diagnostics,
+		trace: [
+			...manufacturing.trace,
+			{
+				id: "manufacturing:available-for-sale",
+				kind: "derive",
+				rule: "Goods available for sale = opening finished goods + cost of production.",
+				working: `${facts.openingFinishedGoods} + ${manufacturing.costOfProduction}`,
+				result: out(goodsAvailableForSale)
+			},
+			{
+				id: "manufacturing:cost-of-sales",
+				kind: "derive",
+				rule: "Cost of sales = goods available for sale − closing finished goods.",
+				working: `${out(goodsAvailableForSale)} − ${facts.closingFinishedGoods}`,
+				result: out(costOfSales)
+			},
+			{
+				id: "manufacturing:gross-profit",
+				kind: "derive",
+				rule: "Gross profit = revenue − cost of sales.",
+				working: `${facts.revenue} − ${out(costOfSales)}`,
+				result: out(grossProfit)
+			}
+		]
+	};
+}
+
+//#endregion
+export { solveManufacturingAccount, solveManufacturingTradingFlow };

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

@@ -0,0 +1,7 @@
+import { AccountingPolicy, PartnerFacts, PartnershipAgreement, PartnershipResult } from "./types.mjs";
+
+//#region src/finance/accounting/partnership.d.ts
+declare function solvePartnershipAppropriation(agreement: PartnershipAgreement, partners: readonly PartnerFacts[], policy?: AccountingPolicy): PartnershipResult;
+declare function salaryForEqualPartnershipShares(agreement: PartnershipAgreement, partners: readonly PartnerFacts[], policy?: AccountingPolicy): number | null;
+//#endregion
+export { salaryForEqualPartnershipShares, solvePartnershipAppropriation };