@classytic/stage 0.2.0 → 0.4.0

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

@@ -0,0 +1,189 @@
+import { fromMinor, toMinor } from "../accounting/precision.mjs";
+
+//#region src/finance/management-accounting/budgeting.ts
+const DEFAULT_POLICY = { decimalPlaces: 2 };
+function buildOperatingBudget(facts, policy = DEFAULT_POLICY) {
+	const diagnostics = [];
+	const seen = /* @__PURE__ */ new Set();
+	const check = (value, label, periodId) => {
+		if (!Number.isFinite(value) || value < 0) diagnostics.push({
+			code: "invalid-input",
+			severity: "error",
+			periodId,
+			message: `${label} must be finite and non-negative.`
+		});
+	};
+	check(facts.openingFinishedGoodsUnits, "Opening finished-goods units");
+	check(facts.openingMaterialUnits, "Opening material units");
+	for (const period of facts.periods) {
+		if (seen.has(period.id)) diagnostics.push({
+			code: "duplicate-period",
+			severity: "error",
+			periodId: period.id,
+			message: `Period ${period.id} is duplicated.`
+		});
+		seen.add(period.id);
+		check(period.salesUnits, "Sales units", period.id);
+		check(period.sellingPricePerUnit, "Selling price per unit", period.id);
+		check(period.desiredClosingFinishedGoodsUnits, "Desired closing finished-goods units", period.id);
+		check(period.materialUnitsPerFinishedUnit, "Material units per finished unit", period.id);
+		check(period.desiredClosingMaterialUnits, "Desired closing material units", period.id);
+		check(period.materialCostPerUnit, "Material cost per unit", period.id);
+		check(period.directLabourHoursPerUnit ?? 0, "Direct labour hours per finished unit", period.id);
+		check(period.directLabourRatePerHour ?? 0, "Direct labour rate per hour", period.id);
+		check(period.variableProductionOverheadRatePerLabourHour ?? 0, "Variable production overhead rate per labour hour", period.id);
+		check(period.fixedProductionOverhead ?? 0, "Fixed production overhead", period.id);
+	}
+	if (diagnostics.length > 0) return emptyResult(diagnostics);
+	const periods = [];
+	const trace = [];
+	let openingFinishedGoodsUnits = facts.openingFinishedGoodsUnits;
+	let openingMaterialUnits = facts.openingMaterialUnits;
+	for (const period of facts.periods) {
+		const unitsToProduce = period.salesUnits + period.desiredClosingFinishedGoodsUnits - openingFinishedGoodsUnits;
+		const materialUnitsRequired = unitsToProduce * period.materialUnitsPerFinishedUnit;
+		const unitsToPurchase = materialUnitsRequired + period.desiredClosingMaterialUnits - openingMaterialUnits;
+		if (unitsToProduce < 0) diagnostics.push({
+			code: "impossible-schedule",
+			severity: "error",
+			periodId: period.id,
+			message: `${period.label} requires negative production; opening finished goods exceed sales plus desired closing inventory.`
+		});
+		if (unitsToPurchase < 0) diagnostics.push({
+			code: "impossible-schedule",
+			severity: "error",
+			periodId: period.id,
+			message: `${period.label} requires negative material purchases; opening materials exceed usage plus desired closing inventory.`
+		});
+		if (diagnostics.length > 0) break;
+		const revenue = money(period.salesUnits * period.sellingPricePerUnit, policy);
+		const purchaseCost = money(unitsToPurchase * period.materialCostPerUnit, policy);
+		const hoursPerUnit = period.directLabourHoursPerUnit ?? 0;
+		const ratePerHour = period.directLabourRatePerHour ?? 0;
+		const labourHours = unitsToProduce * hoursPerUnit;
+		const labourCost = money(labourHours * ratePerHour, policy);
+		const variableRatePerLabourHour = period.variableProductionOverheadRatePerLabourHour ?? 0;
+		const variableOverhead = money(labourHours * variableRatePerLabourHour, policy);
+		const fixedOverhead = money(period.fixedProductionOverhead ?? 0, policy);
+		const totalOverhead = money(variableOverhead + fixedOverhead, policy);
+		periods.push({
+			id: period.id,
+			label: period.label,
+			sales: {
+				units: period.salesUnits,
+				pricePerUnit: period.sellingPricePerUnit,
+				revenue
+			},
+			production: {
+				openingFinishedGoodsUnits,
+				salesUnits: period.salesUnits,
+				desiredClosingFinishedGoodsUnits: period.desiredClosingFinishedGoodsUnits,
+				unitsToProduce
+			},
+			materialsUsage: {
+				unitsPerFinishedUnit: period.materialUnitsPerFinishedUnit,
+				productionUnits: unitsToProduce,
+				materialUnitsRequired
+			},
+			materialsPurchases: {
+				openingMaterialUnits,
+				materialUnitsRequired,
+				desiredClosingMaterialUnits: period.desiredClosingMaterialUnits,
+				unitsToPurchase,
+				costPerUnit: period.materialCostPerUnit,
+				purchaseCost
+			},
+			directLabour: {
+				hoursPerUnit,
+				productionUnits: unitsToProduce,
+				labourHours,
+				ratePerHour,
+				labourCost
+			},
+			productionOverhead: {
+				labourHours,
+				variableRatePerLabourHour,
+				variableOverhead,
+				fixedOverhead,
+				totalOverhead
+			}
+		});
+		trace.push({
+			id: `${period.id}:production`,
+			kind: "derive",
+			rule: "Production = sales + desired closing finished goods − opening finished goods.",
+			working: `${period.salesUnits} + ${period.desiredClosingFinishedGoodsUnits} − ${openingFinishedGoodsUnits}`,
+			result: unitsToProduce
+		}, {
+			id: `${period.id}:usage`,
+			kind: "derive",
+			rule: "Material usage = production × material required per finished unit.",
+			working: `${unitsToProduce} × ${period.materialUnitsPerFinishedUnit}`,
+			result: materialUnitsRequired
+		}, {
+			id: `${period.id}:purchases`,
+			kind: "derive",
+			rule: "Material purchases = usage + desired closing materials − opening materials.",
+			working: `${materialUnitsRequired} + ${period.desiredClosingMaterialUnits} − ${openingMaterialUnits}`,
+			result: unitsToPurchase
+		}, {
+			id: `${period.id}:labour`,
+			kind: "derive",
+			rule: "Direct labour hours = production × labour hours required per finished unit.",
+			working: `${unitsToProduce} × ${hoursPerUnit}`,
+			result: labourHours
+		}, {
+			id: `${period.id}:overhead`,
+			kind: "derive",
+			rule: "Production overhead = variable overhead per labour hour × labour hours + fixed production overhead.",
+			working: `${variableRatePerLabourHour} × ${labourHours} + ${fixedOverhead}`,
+			result: totalOverhead
+		});
+		openingFinishedGoodsUnits = period.desiredClosingFinishedGoodsUnits;
+		openingMaterialUnits = period.desiredClosingMaterialUnits;
+	}
+	if (diagnostics.length > 0) return emptyResult(diagnostics);
+	return {
+		completed: true,
+		periods,
+		totals: {
+			salesUnits: sum(periods, (period) => period.sales.units),
+			revenue: money(sum(periods, (period) => period.sales.revenue), policy),
+			productionUnits: sum(periods, (period) => period.production.unitsToProduce),
+			materialUsageUnits: sum(periods, (period) => period.materialsUsage.materialUnitsRequired),
+			materialPurchaseUnits: sum(periods, (period) => period.materialsPurchases.unitsToPurchase),
+			materialPurchaseCost: money(sum(periods, (period) => period.materialsPurchases.purchaseCost), policy),
+			labourHours: sum(periods, (period) => period.directLabour.labourHours),
+			labourCost: money(sum(periods, (period) => period.directLabour.labourCost), policy),
+			variableProductionOverhead: money(sum(periods, (period) => period.productionOverhead.variableOverhead), policy),
+			fixedProductionOverhead: money(sum(periods, (period) => period.productionOverhead.fixedOverhead), policy),
+			totalProductionOverhead: money(sum(periods, (period) => period.productionOverhead.totalOverhead), policy)
+		},
+		diagnostics,
+		trace
+	};
+}
+const money = (value, policy) => fromMinor(toMinor(value, policy), policy);
+const sum = (periods, select) => periods.reduce((total, period) => total + select(period), 0);
+const emptyResult = (diagnostics) => ({
+	completed: false,
+	periods: [],
+	totals: {
+		salesUnits: 0,
+		revenue: 0,
+		productionUnits: 0,
+		materialUsageUnits: 0,
+		materialPurchaseUnits: 0,
+		materialPurchaseCost: 0,
+		labourHours: 0,
+		labourCost: 0,
+		variableProductionOverhead: 0,
+		fixedProductionOverhead: 0,
+		totalProductionOverhead: 0
+	},
+	diagnostics,
+	trace: []
+});
+
+//#endregion
+export { buildOperatingBudget };

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

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

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

@@ -0,0 +1,154 @@
+import { fromMinor, toMinor } from "../accounting/precision.mjs";
+
+//#region src/finance/management-accounting/cash-budget.ts
+const DEFAULT_POLICY = { decimalPlaces: 2 };
+function buildCashBudget(facts, policy = DEFAULT_POLICY) {
+	const diagnostics = [];
+	const check = (value, label, periodId) => {
+		if (!Number.isFinite(value) || value < 0) diagnostics.push({
+			code: "invalid-input",
+			severity: "error",
+			periodId,
+			message: `${label} must be finite and non-negative.`
+		});
+	};
+	check(facts.openingCashBalance, "Opening cash balance");
+	check(facts.minimumCashBalance ?? 0, "Minimum cash balance");
+	validateProfile(facts.collectionProfile, "Collection profile", diagnostics);
+	validateProfile(facts.materialPaymentProfile, "Material payment profile", diagnostics);
+	const seen = /* @__PURE__ */ new Set();
+	for (const period of facts.periods) {
+		if (seen.has(period.id)) diagnostics.push({
+			code: "duplicate-period",
+			severity: "error",
+			periodId: period.id,
+			message: `Period ${period.id} is duplicated.`
+		});
+		seen.add(period.id);
+		check(period.salesRevenue, "Sales revenue", period.id);
+		check(period.materialPurchases, "Material purchases", period.id);
+		check(period.labourCost, "Labour cost", period.id);
+		check(period.productionOverhead, "Production overhead", period.id);
+		check(period.nonCashProductionOverhead ?? 0, "Non-cash production overhead", period.id);
+		check(period.broughtForwardReceipts ?? 0, "Brought-forward receipts", period.id);
+		check(period.broughtForwardPayments ?? 0, "Brought-forward payments", period.id);
+		check(period.otherReceipts ?? 0, "Other receipts", period.id);
+		check(period.otherPayments ?? 0, "Other payments", period.id);
+		if ((period.nonCashProductionOverhead ?? 0) > period.productionOverhead) diagnostics.push({
+			code: "invalid-input",
+			severity: "error",
+			periodId: period.id,
+			message: "Non-cash production overhead cannot exceed total production overhead."
+		});
+	}
+	if (diagnostics.length > 0) return emptyResult(diagnostics);
+	const receipts = Array(facts.periods.length).fill(0);
+	const materialPayments = Array(facts.periods.length).fill(0);
+	let closingReceivablesMinor = 0;
+	let closingMaterialPayablesMinor = 0;
+	facts.periods.forEach((period, sourceIndex) => {
+		allocate(toMinor(period.salesRevenue, policy), facts.collectionProfile).forEach(({ offset, amountMinor }) => {
+			const target = sourceIndex + offset;
+			if (target < receipts.length) receipts[target] = (receipts[target] ?? 0) + amountMinor;
+			else closingReceivablesMinor += amountMinor;
+		});
+		allocate(toMinor(period.materialPurchases, policy), facts.materialPaymentProfile).forEach(({ offset, amountMinor }) => {
+			const target = sourceIndex + offset;
+			if (target < materialPayments.length) materialPayments[target] = (materialPayments[target] ?? 0) + amountMinor;
+			else closingMaterialPayablesMinor += amountMinor;
+		});
+	});
+	const periods = [];
+	const trace = [];
+	const minimumCashMinor = toMinor(facts.minimumCashBalance ?? 0, policy);
+	let openingCashMinor = toMinor(facts.openingCashBalance, policy);
+	let totalFinancingMinor = 0;
+	facts.periods.forEach((period, index) => {
+		const customerReceiptsMinor = receipts[index] ?? 0;
+		const totalReceiptsMinor = customerReceiptsMinor + toMinor((period.broughtForwardReceipts ?? 0) + (period.otherReceipts ?? 0), policy);
+		const materialPaymentsMinor = materialPayments[index] ?? 0;
+		const labourPaymentsMinor = toMinor(period.labourCost, policy);
+		const overheadPaymentsMinor = toMinor(period.productionOverhead - (period.nonCashProductionOverhead ?? 0), policy);
+		const totalPaymentsMinor = materialPaymentsMinor + labourPaymentsMinor + overheadPaymentsMinor + toMinor((period.broughtForwardPayments ?? 0) + (period.otherPayments ?? 0), policy);
+		const preFinancingClosingMinor = openingCashMinor + totalReceiptsMinor - totalPaymentsMinor;
+		const financingMinor = Math.max(0, minimumCashMinor - preFinancingClosingMinor);
+		const closingCashMinor = preFinancingClosingMinor + financingMinor;
+		totalFinancingMinor += financingMinor;
+		periods.push({
+			id: period.id,
+			label: period.label,
+			openingCashBalance: fromMinor(openingCashMinor, policy),
+			customerReceipts: fromMinor(customerReceiptsMinor, policy),
+			totalReceipts: fromMinor(totalReceiptsMinor, policy),
+			materialPayments: fromMinor(materialPaymentsMinor, policy),
+			labourPayments: fromMinor(labourPaymentsMinor, policy),
+			overheadPayments: fromMinor(overheadPaymentsMinor, policy),
+			totalPayments: fromMinor(totalPaymentsMinor, policy),
+			preFinancingClosingCash: fromMinor(preFinancingClosingMinor, policy),
+			financingRequired: fromMinor(financingMinor, policy),
+			closingCashBalance: fromMinor(closingCashMinor, policy)
+		});
+		trace.push({
+			id: `${period.id}:cash`,
+			kind: "derive",
+			rule: "Closing cash before financing = opening cash + receipts − payments.",
+			working: `${fromMinor(openingCashMinor, policy)} + ${fromMinor(totalReceiptsMinor, policy)} − ${fromMinor(totalPaymentsMinor, policy)}`,
+			result: fromMinor(preFinancingClosingMinor, policy)
+		});
+		openingCashMinor = closingCashMinor;
+	});
+	return {
+		completed: true,
+		periods,
+		closingReceivables: fromMinor(closingReceivablesMinor, policy),
+		closingMaterialPayables: fromMinor(closingMaterialPayablesMinor, policy),
+		totalFinancingRequired: fromMinor(totalFinancingMinor, policy),
+		diagnostics,
+		trace
+	};
+}
+function validateProfile(profile, label, diagnostics) {
+	if (profile.length === 0) diagnostics.push({
+		code: "invalid-profile",
+		severity: "error",
+		message: `${label} must contain at least one allocation.`
+	});
+	const offsets = /* @__PURE__ */ new Set();
+	for (const allocation of profile) {
+		if (!Number.isInteger(allocation.offset) || allocation.offset < 0 || !Number.isFinite(allocation.proportion) || allocation.proportion < 0 || allocation.proportion > 1 || offsets.has(allocation.offset)) diagnostics.push({
+			code: "invalid-profile",
+			severity: "error",
+			message: `${label} offsets must be unique non-negative integers and proportions must be between zero and one.`
+		});
+		offsets.add(allocation.offset);
+	}
+	const total = profile.reduce((sum, allocation) => sum + allocation.proportion, 0);
+	if (Math.abs(total - 1) > 1e-9) diagnostics.push({
+		code: "invalid-profile",
+		severity: "error",
+		message: `${label} proportions must total exactly 1.`
+	});
+}
+function allocate(totalMinor, profile) {
+	let remaining = totalMinor;
+	return profile.map((allocation, index) => {
+		const amountMinor = index === profile.length - 1 ? remaining : Math.round(totalMinor * allocation.proportion);
+		remaining -= amountMinor;
+		return {
+			offset: allocation.offset,
+			amountMinor
+		};
+	});
+}
+const emptyResult = (diagnostics) => ({
+	completed: false,
+	periods: [],
+	closingReceivables: 0,
+	closingMaterialPayables: 0,
+	totalFinancingRequired: 0,
+	diagnostics,
+	trace: []
+});
+
+//#endregion
+export { buildCashBudget };

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

@@ -0,0 +1,8 @@
+import { AccountingPolicy } from "../accounting/types.mjs";
+import { ClassifiedCost, CostClassificationSummary, MarginalAbsorptionFacts, MarginalAbsorptionResult } from "./types.mjs";
+
+//#region src/finance/management-accounting/costing.d.ts
+declare function summarizeClassifiedCosts(costs: readonly ClassifiedCost[]): CostClassificationSummary;
+declare function compareMarginalAndAbsorptionCosting(facts: MarginalAbsorptionFacts, policy?: AccountingPolicy): MarginalAbsorptionResult;
+//#endregion
+export { compareMarginalAndAbsorptionCosting, summarizeClassifiedCosts };

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

@@ -0,0 +1,175 @@
+import { fromMinor, toMinor } from "../accounting/precision.mjs";
+
+//#region src/finance/management-accounting/costing.ts
+const DEFAULT_POLICY = { decimalPlaces: 2 };
+function summarizeClassifiedCosts(costs) {
+	const sum = (predicate) => costs.filter(predicate).reduce((total, cost) => total + cost.amount, 0);
+	return {
+		variableProductionPerUnit: sum((cost) => cost.behavior === "variable" && cost.function === "production" && cost.basis === "per-unit"),
+		variableNonProductionPerUnit: sum((cost) => cost.behavior === "variable" && cost.function !== "production" && cost.basis === "per-unit"),
+		fixedProduction: sum((cost) => cost.behavior === "fixed" && cost.function === "production" && cost.basis === "period"),
+		fixedNonProduction: sum((cost) => cost.behavior === "fixed" && cost.function !== "production" && cost.basis === "period"),
+		directCostPerUnit: sum((cost) => cost.traceability === "direct" && cost.basis === "per-unit"),
+		indirectPeriodCost: sum((cost) => cost.traceability === "indirect" && cost.basis === "period")
+	};
+}
+function compareMarginalAndAbsorptionCosting(facts, policy = DEFAULT_POLICY) {
+	const diagnostics = [];
+	for (const cost of facts.costs) {
+		if (!Number.isFinite(cost.amount) || cost.amount < 0) diagnostics.push({
+			code: "invalid-cost",
+			severity: "error",
+			costId: cost.id,
+			message: `${cost.label} must be a finite non-negative amount.`
+		});
+		if (cost.behavior === "variable" !== (cost.basis === "per-unit")) diagnostics.push({
+			code: "invalid-cost",
+			severity: "error",
+			costId: cost.id,
+			message: `${cost.label} must use a per-unit basis when variable and a period basis when fixed.`
+		});
+	}
+	const openingUnits = facts.openingInventoryUnits ?? 0;
+	for (const [label, value] of [
+		["unitsProduced", facts.unitsProduced],
+		["unitsSold", facts.unitsSold],
+		["openingInventoryUnits", openingUnits],
+		["sellingPricePerUnit", facts.sellingPricePerUnit]
+	]) if (!Number.isFinite(value) || value < 0) diagnostics.push({
+		code: "invalid-volume",
+		severity: "error",
+		message: `${label} must be finite and non-negative.`
+	});
+	if (!Number.isFinite(facts.normalCapacityUnits) || facts.normalCapacityUnits <= 0) diagnostics.push({
+		code: "invalid-capacity",
+		severity: "error",
+		message: "Normal capacity must be finite and positive."
+	});
+	const closingUnits = openingUnits + facts.unitsProduced - facts.unitsSold;
+	if (closingUnits < 0) diagnostics.push({
+		code: "invalid-volume",
+		severity: "error",
+		message: "Units sold cannot exceed opening inventory plus production."
+	});
+	const emptyStatement = {
+		revenue: 0,
+		variableProductionCostOfSales: 0,
+		fixedProductionCostOfSales: 0,
+		variableNonProductionCost: 0,
+		fixedNonProductionCost: 0,
+		underAbsorption: 0,
+		overAbsorption: 0,
+		profit: 0
+	};
+	const emptyValues = {
+		closingInventoryUnits: 0,
+		fixedOverheadRate: 0,
+		absorbedFixedOverhead: 0,
+		actualFixedOverhead: 0,
+		marginalClosingInventory: 0,
+		absorptionClosingInventory: 0,
+		inventoryFixedOverheadMovement: 0,
+		profitDifference: 0
+	};
+	const classification = summarizeClassifiedCosts(facts.costs);
+	if (diagnostics.length > 0) return {
+		classification,
+		values: emptyValues,
+		marginal: emptyStatement,
+		absorption: emptyStatement,
+		reconciles: false,
+		diagnostics,
+		trace: []
+	};
+	const money = (value) => fromMinor(toMinor(value, policy), policy);
+	const revenue = money(facts.unitsSold * facts.sellingPricePerUnit);
+	const variableProductionCostOfSales = money(facts.unitsSold * classification.variableProductionPerUnit);
+	const variableNonProductionCost = money(facts.unitsSold * classification.variableNonProductionPerUnit);
+	const fixedOverheadRate = money(classification.fixedProduction / facts.normalCapacityUnits);
+	const actualFixedOverhead = money(facts.actualFixedProductionOverhead ?? classification.fixedProduction);
+	const absorbedFixedOverhead = money(facts.unitsProduced * fixedOverheadRate);
+	const absorptionDifference = money(absorbedFixedOverhead - actualFixedOverhead);
+	const underAbsorption = Math.max(0, -absorptionDifference);
+	const overAbsorption = Math.max(0, absorptionDifference);
+	const fixedProductionCostOfSales = money(facts.unitsSold * fixedOverheadRate);
+	const contribution = money(revenue - variableProductionCostOfSales - variableNonProductionCost);
+	const marginalProfit = money(contribution - actualFixedOverhead - classification.fixedNonProduction);
+	const grossProfit = money(revenue - variableProductionCostOfSales - fixedProductionCostOfSales);
+	const absorptionProfit = money(grossProfit - variableNonProductionCost - classification.fixedNonProduction - underAbsorption + overAbsorption);
+	const marginalClosingInventory = money(closingUnits * classification.variableProductionPerUnit);
+	const absorptionClosingInventory = money(closingUnits * (classification.variableProductionPerUnit + fixedOverheadRate));
+	const inventoryFixedOverheadMovement = money((closingUnits - openingUnits) * fixedOverheadRate);
+	const profitDifference = money(absorptionProfit - marginalProfit);
+	const reconciles = profitDifference === inventoryFixedOverheadMovement;
+	const trace = [
+		{
+			id: "costing:fixed-rate",
+			kind: "derive",
+			rule: "Fixed production overhead absorption rate = budgeted fixed production overhead ÷ normal capacity.",
+			working: `${classification.fixedProduction} ÷ ${facts.normalCapacityUnits}`,
+			result: fixedOverheadRate
+		},
+		{
+			id: "costing:contribution",
+			kind: "derive",
+			rule: "Contribution = revenue − all variable costs of sales.",
+			working: `${revenue} − ${variableProductionCostOfSales} − ${variableNonProductionCost}`,
+			result: contribution
+		},
+		{
+			id: "costing:absorption",
+			kind: "derive",
+			rule: "Absorption profit charges fixed production overhead through units sold and corrects under/over-absorption.",
+			working: `${grossProfit} − ${variableNonProductionCost} − ${classification.fixedNonProduction} − ${underAbsorption} + ${overAbsorption}`,
+			result: absorptionProfit
+		},
+		{
+			id: "costing:reconcile",
+			kind: "check",
+			rule: "Profit difference = change in inventory units × fixed production overhead rate.",
+			working: `${closingUnits - openingUnits} × ${fixedOverheadRate}`,
+			result: reconciles
+		}
+	];
+	return {
+		classification,
+		values: {
+			closingInventoryUnits: closingUnits,
+			fixedOverheadRate,
+			absorbedFixedOverhead,
+			actualFixedOverhead,
+			marginalClosingInventory,
+			absorptionClosingInventory,
+			inventoryFixedOverheadMovement,
+			profitDifference
+		},
+		marginal: {
+			revenue,
+			variableProductionCostOfSales,
+			fixedProductionCostOfSales: 0,
+			variableNonProductionCost,
+			fixedNonProductionCost: classification.fixedNonProduction,
+			contribution,
+			underAbsorption: 0,
+			overAbsorption: 0,
+			profit: marginalProfit
+		},
+		absorption: {
+			revenue,
+			variableProductionCostOfSales,
+			fixedProductionCostOfSales,
+			variableNonProductionCost,
+			fixedNonProductionCost: classification.fixedNonProduction,
+			grossProfit,
+			underAbsorption,
+			overAbsorption,
+			profit: absorptionProfit
+		},
+		reconciles,
+		diagnostics,
+		trace
+	};
+}
+
+//#endregion
+export { compareMarginalAndAbsorptionCosting, summarizeClassifiedCosts };

package/dist/finance/management-accounting/decisions.d.mts

@@ -0,0 +1,8 @@
+import { AccountingPolicy } from "../accounting/types.mjs";
+import { LimitedFactorProduct, LimitedFactorResult, RelevantCostAlternative, RelevantCostDecisionResult } from "./types.mjs";
+
+//#region src/finance/management-accounting/decisions.d.ts
+declare function optimizeLimitedFactor(products: readonly LimitedFactorProduct[], resourceAvailable: number, policy?: AccountingPolicy): LimitedFactorResult;
+declare function evaluateRelevantCostDecision(alternatives: readonly RelevantCostAlternative[], policy?: AccountingPolicy): RelevantCostDecisionResult;
+//#endregion
+export { evaluateRelevantCostDecision, optimizeLimitedFactor };