@classytic/stage 0.2.0 → 0.4.0

package/dist/finance/management-accounting/management-case.mjs

@@ -0,0 +1,91 @@
+import { DEFAULT_ACCOUNTING_POLICY } from "../accounting/precision.mjs";
+import { evaluateRelevantCostDecision, optimizeLimitedFactor } from "./decisions.mjs";
+import { appraiseInvestment } from "./investment-appraisal.mjs";
+import { costJobOrBatch, costProcessWithLosses } from "./production-costing.mjs";
+
+//#region src/finance/management-accounting/management-case.ts
+/** Runs independent authored tasks through their authoritative solvers; it contains no accounting formulas. */
+function runManagementAccountingCase(caseDefinition, policy = DEFAULT_ACCOUNTING_POLICY) {
+	const diagnostics = [];
+	const seen = /* @__PURE__ */ new Set();
+	const tasks = caseDefinition.tasks.map((task) => {
+		if (seen.has(task.id)) diagnostics.push({
+			code: "duplicate-task",
+			severity: "error",
+			taskId: task.id,
+			message: `Task ${task.id} is duplicated.`
+		});
+		seen.add(task.id);
+		const result = runTask(task, policy);
+		if (!result.completed) diagnostics.push({
+			code: "task-failed",
+			severity: "error",
+			taskId: task.id,
+			message: `Task ${task.id} contains invalid facts.`
+		});
+		return result;
+	});
+	const trace = tasks.flatMap((task) => task.solution.trace.map((step) => ({
+		...step,
+		id: `${task.id}:${step.id}`
+	})));
+	return {
+		caseId: caseDefinition.id,
+		completed: diagnostics.length === 0,
+		tasks,
+		diagnostics,
+		trace
+	};
+}
+function runTask(task, policy) {
+	switch (task.kind) {
+		case "job-batch": {
+			const solution = costJobOrBatch(task.facts, policy);
+			return {
+				id: task.id,
+				kind: task.kind,
+				completed: solution.completed,
+				solution
+			};
+		}
+		case "process-loss": {
+			const solution = costProcessWithLosses(task.facts, policy);
+			return {
+				id: task.id,
+				kind: task.kind,
+				completed: solution.completed,
+				solution
+			};
+		}
+		case "limited-factor": {
+			const solution = optimizeLimitedFactor(task.products, task.resourceAvailable, policy);
+			return {
+				id: task.id,
+				kind: task.kind,
+				completed: solution.completed,
+				solution
+			};
+		}
+		case "relevant-cost": {
+			const solution = evaluateRelevantCostDecision(task.alternatives, policy);
+			return {
+				id: task.id,
+				kind: task.kind,
+				completed: solution.completed,
+				solution
+			};
+		}
+		case "investment-appraisal": {
+			const solution = appraiseInvestment(task.facts, policy);
+			return {
+				id: task.id,
+				kind: task.kind,
+				completed: solution.completed,
+				solution
+			};
+		}
+	}
+}
+
+//#endregion
+export { runManagementAccountingCase };

package/dist/finance/management-accounting/master-budget.d.mts

@@ -0,0 +1,7 @@
+import { AccountingPolicy } from "../accounting/types.mjs";
+import { MasterBudgetFacts, MasterBudgetResult } from "./types.mjs";
+
+//#region src/finance/management-accounting/master-budget.d.ts
+declare function composeMasterBudget(facts: MasterBudgetFacts, policy?: AccountingPolicy): MasterBudgetResult;
+//#endregion
+export { composeMasterBudget };

package/dist/finance/management-accounting/master-budget.mjs

@@ -0,0 +1,137 @@
+import { fromMinor, toMinor } from "../accounting/precision.mjs";
+
+//#region src/finance/management-accounting/master-budget.ts
+const DEFAULT_POLICY = { decimalPlaces: 2 };
+function composeMasterBudget(facts, policy = DEFAULT_POLICY) {
+	const diagnostics = [];
+	if (!facts.operating.completed) diagnostics.push({
+		code: "incomplete-source",
+		severity: "error",
+		message: "Operating budget must be complete."
+	});
+	if (!facts.cash.completed) diagnostics.push({
+		code: "incomplete-source",
+		severity: "error",
+		message: "Cash budget must be complete."
+	});
+	if (!Number.isFinite(facts.openingFinishedGoodsValue) || facts.openingFinishedGoodsValue < 0) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: "Opening finished-goods value must be finite and non-negative."
+	});
+	const policies = /* @__PURE__ */ new Map();
+	for (const item of facts.periodPolicies) {
+		if (policies.has(item.periodId)) diagnostics.push({
+			code: "period-mismatch",
+			severity: "error",
+			periodId: item.periodId,
+			message: `Policy for ${item.periodId} is duplicated.`
+		});
+		policies.set(item.periodId, item);
+		if (![item.variableSellingAdministrationPerUnit, item.fixedSellingAdministration].every((value) => Number.isFinite(value) && value >= 0)) diagnostics.push({
+			code: "invalid-input",
+			severity: "error",
+			periodId: item.periodId,
+			message: "Selling and administration assumptions must be finite and non-negative."
+		});
+	}
+	if (facts.operating.periods.length !== facts.cash.periods.length) diagnostics.push({
+		code: "period-mismatch",
+		severity: "error",
+		message: "Operating and cash budgets must cover the same periods."
+	});
+	facts.operating.periods.forEach((period, index) => {
+		if (facts.cash.periods[index]?.id !== period.id) diagnostics.push({
+			code: "period-mismatch",
+			severity: "error",
+			periodId: period.id,
+			message: `Cash period does not align with ${period.label}.`
+		});
+		if (!policies.has(period.id)) diagnostics.push({
+			code: "period-mismatch",
+			severity: "error",
+			periodId: period.id,
+			message: `Selling and administration policy is missing for ${period.label}.`
+		});
+	});
+	if (diagnostics.length > 0) return emptyResult(diagnostics);
+	const periods = [];
+	const trace = [];
+	let openingFinishedGoodsValue = money(facts.openingFinishedGoodsValue, policy);
+	for (let index = 0; index < facts.operating.periods.length; index += 1) {
+		const operating = facts.operating.periods[index];
+		const cash = facts.cash.periods[index];
+		const periodPolicy = policies.get(operating.id);
+		const materialUsageCost = money(operating.materialsUsage.materialUnitsRequired * operating.materialsPurchases.costPerUnit, policy);
+		const manufacturingCost = money(materialUsageCost + operating.directLabour.labourCost + operating.productionOverhead.totalOverhead, policy);
+		const goodsAvailableUnits = operating.production.openingFinishedGoodsUnits + operating.production.unitsToProduce;
+		const goodsAvailableValue = money(openingFinishedGoodsValue + manufacturingCost, policy);
+		const averageUnitCost = goodsAvailableUnits === 0 ? 0 : goodsAvailableValue / goodsAvailableUnits;
+		const closingFinishedGoodsValue = money(operating.production.desiredClosingFinishedGoodsUnits * averageUnitCost, policy);
+		const costOfSales = money(goodsAvailableValue - closingFinishedGoodsValue, policy);
+		const grossProfit = money(operating.sales.revenue - costOfSales, policy);
+		const variableSellingAdministration = money(operating.sales.units * periodPolicy.variableSellingAdministrationPerUnit, policy);
+		const operatingProfit = money(grossProfit - variableSellingAdministration - periodPolicy.fixedSellingAdministration, policy);
+		periods.push({
+			id: operating.id,
+			label: operating.label,
+			revenue: operating.sales.revenue,
+			materialUsageCost,
+			labourCost: operating.directLabour.labourCost,
+			productionOverhead: operating.productionOverhead.totalOverhead,
+			manufacturingCost,
+			goodsAvailableValue,
+			closingFinishedGoodsValue,
+			costOfSales,
+			grossProfit,
+			variableSellingAdministration,
+			fixedSellingAdministration: periodPolicy.fixedSellingAdministration,
+			operatingProfit,
+			closingCashBalance: cash.closingCashBalance,
+			financingRequired: cash.financingRequired
+		});
+		trace.push({
+			id: `${operating.id}:master-profit`,
+			kind: "derive",
+			rule: "Operating profit = revenue − cost of sales − variable selling/administration − fixed selling/administration.",
+			working: `${operating.sales.revenue} − ${costOfSales} − ${variableSellingAdministration} − ${periodPolicy.fixedSellingAdministration}`,
+			result: operatingProfit
+		});
+		openingFinishedGoodsValue = closingFinishedGoodsValue;
+	}
+	const total = (select) => money(periods.reduce((sum, period) => sum + select(period), 0), policy);
+	return {
+		completed: true,
+		periods,
+		totals: {
+			revenue: total((period) => period.revenue),
+			manufacturingCost: total((period) => period.manufacturingCost),
+			costOfSales: total((period) => period.costOfSales),
+			grossProfit: total((period) => period.grossProfit),
+			sellingAdministration: total((period) => period.variableSellingAdministration + period.fixedSellingAdministration),
+			operatingProfit: total((period) => period.operatingProfit),
+			financingRequired: total((period) => period.financingRequired)
+		},
+		diagnostics,
+		trace
+	};
+}
+const money = (value, policy) => fromMinor(toMinor(value, policy), policy);
+const emptyResult = (diagnostics) => ({
+	completed: false,
+	periods: [],
+	totals: {
+		revenue: 0,
+		manufacturingCost: 0,
+		costOfSales: 0,
+		grossProfit: 0,
+		sellingAdministration: 0,
+		operatingProfit: 0,
+		financingRequired: 0
+	},
+	diagnostics,
+	trace: []
+});
+
+//#endregion
+export { composeMasterBudget };

package/dist/finance/management-accounting/production-costing.d.mts

@@ -0,0 +1,8 @@
+import { AccountingPolicy } from "../accounting/types.mjs";
+import { JobBatchCostFacts, JobBatchCostResult, ProcessCostFacts, ProcessCostResult } from "./types.mjs";
+
+//#region src/finance/management-accounting/production-costing.d.ts
+declare function costJobOrBatch(facts: JobBatchCostFacts, policy?: AccountingPolicy): JobBatchCostResult;
+declare function costProcessWithLosses(facts: ProcessCostFacts, policy?: AccountingPolicy): ProcessCostResult;
+//#endregion
+export { costJobOrBatch, costProcessWithLosses };

package/dist/finance/management-accounting/production-costing.mjs

@@ -0,0 +1,214 @@
+import { fromMinor, toMinor } from "../accounting/precision.mjs";
+
+//#region src/finance/management-accounting/production-costing.ts
+const DEFAULT_POLICY = { decimalPlaces: 2 };
+function costJobOrBatch(facts, policy = DEFAULT_POLICY) {
+	const diagnostics = [];
+	const positive = [[facts.outputUnits, "Output units"]];
+	const nonNegative = [
+		[facts.directMaterials, "Direct materials"],
+		[facts.directLabourHours, "Direct labour hours"],
+		[facts.directLabourRatePerHour, "Direct labour rate"],
+		[facts.directExpenses ?? 0, "Direct expenses"],
+		[facts.productionOverhead.basisQuantity, "Overhead basis quantity"],
+		[facts.productionOverhead.ratePerBasisUnit, "Overhead rate"],
+		[facts.nonProductionOverhead ?? 0, "Non-production overhead"]
+	];
+	for (const [value, label] of positive) if (!Number.isFinite(value) || value <= 0) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: `${label} must be finite and positive.`
+	});
+	for (const [value, label] of nonNegative) if (!Number.isFinite(value) || value < 0) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: `${label} must be finite and non-negative.`
+	});
+	if (diagnostics.length > 0) return {
+		completed: false,
+		kind: facts.kind,
+		directLabour: 0,
+		primeCost: 0,
+		productionOverhead: 0,
+		productionCost: 0,
+		totalCost: 0,
+		costPerUnit: 0,
+		diagnostics,
+		trace: []
+	};
+	const directLabour = money(facts.directLabourHours * facts.directLabourRatePerHour, policy);
+	const primeCost = money(facts.directMaterials + directLabour + (facts.directExpenses ?? 0), policy);
+	const productionOverhead = money(facts.productionOverhead.basisQuantity * facts.productionOverhead.ratePerBasisUnit, policy);
+	const productionCost = money(primeCost + productionOverhead, policy);
+	const totalCost = money(productionCost + (facts.nonProductionOverhead ?? 0), policy);
+	const costPerUnit = money(totalCost / facts.outputUnits, policy);
+	const trace = [
+		{
+			id: `${facts.kind}:prime`,
+			kind: "derive",
+			rule: "Prime cost = direct materials + direct labour + direct expenses.",
+			working: `${facts.directMaterials} + ${directLabour} + ${facts.directExpenses ?? 0}`,
+			result: primeCost
+		},
+		{
+			id: `${facts.kind}:overhead`,
+			kind: "derive",
+			rule: `Production overhead = ${facts.productionOverhead.basisLabel} × overhead rate.`,
+			working: `${facts.productionOverhead.basisQuantity} × ${facts.productionOverhead.ratePerBasisUnit}`,
+			result: productionOverhead
+		},
+		{
+			id: `${facts.kind}:unit`,
+			kind: "derive",
+			rule: `Cost per ${facts.kind === "job" ? "output unit" : "batch unit"} = total assigned cost ÷ output units.`,
+			working: `${totalCost} ÷ ${facts.outputUnits}`,
+			result: costPerUnit
+		}
+	];
+	return {
+		completed: true,
+		kind: facts.kind,
+		directLabour,
+		primeCost,
+		productionOverhead,
+		productionCost,
+		totalCost,
+		costPerUnit,
+		diagnostics,
+		trace
+	};
+}
+function costProcessWithLosses(facts, policy = DEFAULT_POLICY) {
+	const diagnostics = [];
+	const positive = [[facts.inputUnits, "Input units"]];
+	const nonNegative = [
+		[facts.directMaterials, "Direct materials"],
+		[facts.conversionCost, "Conversion cost"],
+		[facts.normalLossUnits, "Normal loss units"],
+		[facts.normalLossScrapValuePerUnit, "Normal-loss scrap value"],
+		[facts.actualOutputUnits, "Actual output units"]
+	];
+	for (const [value, label] of positive) if (!Number.isFinite(value) || value <= 0) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: `${label} must be finite and positive.`
+	});
+	for (const [value, label] of nonNegative) if (!Number.isFinite(value) || value < 0) diagnostics.push({
+		code: "invalid-input",
+		severity: "error",
+		message: `${label} must be finite and non-negative.`
+	});
+	if (facts.normalLossUnits >= facts.inputUnits) diagnostics.push({
+		code: "impossible-flow",
+		severity: "error",
+		message: "Normal loss must be lower than input units."
+	});
+	if (facts.actualOutputUnits > facts.inputUnits) diagnostics.push({
+		code: "impossible-flow",
+		severity: "error",
+		message: "Actual output cannot exceed input units."
+	});
+	if (diagnostics.length > 0) return emptyProcess(diagnostics);
+	const actualLossUnits = facts.inputUnits - facts.actualOutputUnits;
+	const expectedOutputUnits = facts.inputUnits - facts.normalLossUnits;
+	const totalProcessCost = money(facts.directMaterials + facts.conversionCost, policy);
+	const normalLossScrapValue = money(facts.normalLossUnits * facts.normalLossScrapValuePerUnit, policy);
+	const netProcessCost = money(totalProcessCost - normalLossScrapValue, policy);
+	if (netProcessCost < 0) return emptyProcess([{
+		code: "impossible-flow",
+		severity: "error",
+		message: "Normal-loss scrap value cannot exceed total process cost."
+	}]);
+	const exactCostPerExpectedUnit = netProcessCost / expectedOutputUnits;
+	const costPerExpectedUnit = money(exactCostPerExpectedUnit, policy);
+	const outputValue = money(facts.actualOutputUnits * exactCostPerExpectedUnit, policy);
+	const difference = actualLossUnits - facts.normalLossUnits;
+	const abnormalKind = difference > 0 ? "loss" : difference < 0 ? "gain" : "none";
+	const abnormalUnits = Math.abs(difference);
+	const grossValue = abnormalKind === "loss" ? money(totalProcessCost - normalLossScrapValue - outputValue, policy) : abnormalKind === "gain" ? money(outputValue + normalLossScrapValue - totalProcessCost, policy) : 0;
+	const scrapAdjustment = money(abnormalUnits * facts.normalLossScrapValuePerUnit, policy);
+	const netCostImpact = money(grossValue - scrapAdjustment, policy);
+	const processDebit = money(totalProcessCost + (abnormalKind === "gain" ? grossValue : 0), policy);
+	const processCredit = money(outputValue + normalLossScrapValue + (abnormalKind === "loss" ? grossValue : 0), policy);
+	const balances = processDebit === processCredit;
+	const trace = [
+		{
+			id: "process:expected-output",
+			kind: "derive",
+			rule: "Expected good output = input units − normal loss units.",
+			working: `${facts.inputUnits} − ${facts.normalLossUnits}`,
+			result: expectedOutputUnits
+		},
+		{
+			id: "process:unit-cost",
+			kind: "derive",
+			rule: "Cost per expected good unit = (process cost − normal-loss scrap value) ÷ expected output.",
+			working: `(${totalProcessCost} − ${normalLossScrapValue}) ÷ ${expectedOutputUnits}`,
+			result: costPerExpectedUnit
+		},
+		{
+			id: "process:abnormal",
+			kind: "derive",
+			rule: "Actual loss compared with normal loss identifies abnormal loss or gain; it is valued at the expected good-unit cost.",
+			working: `${actualLossUnits} actual loss − ${facts.normalLossUnits} normal loss`,
+			result: `${abnormalKind}:${abnormalUnits}`
+		},
+		{
+			id: "process:balance",
+			kind: "check",
+			rule: "The process account balances after output, normal scrap, and abnormal loss/gain are recognized.",
+			working: `${processDebit} debit = ${processCredit} credit`,
+			result: balances
+		}
+	];
+	return {
+		completed: true,
+		actualLossUnits,
+		expectedOutputUnits,
+		netProcessCost,
+		costPerExpectedUnit,
+		outputValue,
+		normalLossScrapValue,
+		abnormal: {
+			kind: abnormalKind,
+			units: abnormalUnits,
+			grossValue,
+			scrapAdjustment,
+			netCostImpact
+		},
+		processAccount: {
+			debit: processDebit,
+			credit: processCredit,
+			balances
+		},
+		diagnostics,
+		trace
+	};
+}
+const money = (value, policy) => fromMinor(toMinor(value, policy), policy);
+const emptyProcess = (diagnostics) => ({
+	completed: false,
+	actualLossUnits: 0,
+	expectedOutputUnits: 0,
+	netProcessCost: 0,
+	costPerExpectedUnit: 0,
+	outputValue: 0,
+	normalLossScrapValue: 0,
+	abnormal: {
+		kind: "none",
+		units: 0,
+		grossValue: 0,
+		scrapAdjustment: 0,
+		netCostImpact: 0
+	},
+	processAccount: {
+		debit: 0,
+		credit: 0,
+		balances: false
+	},
+	diagnostics,
+	trace: []
+});
+
+//#endregion
+export { costJobOrBatch, costProcessWithLosses };