@classytic/ledger 0.1.3

package/dist/fiscal-close-CNOwv_ud.mjs

@@ -0,0 +1,934 @@
+import { n as Errors } from "./errors-CeqRahE-.mjs";
+import { i as requireOrgScope, n as finalizeSession, r as defaultLogger, t as acquireSession } from "./session-Dh0s6zG4.mjs";
+import { i as extractMainType } from "./categories-BNJBd4ze.mjs";
+
+//#region src/utils/date-range.ts
+/**
+* Compute start/end dates from a date option + value.
+*
+* Examples:
+*   getDateRange('month', '2025-03')            → Mar 1 – Mar 31
+*   getDateRange('quarter', { quarter: 2, year: 2025 }) → Apr 1 – Jun 30
+*   getDateRange('year', 2025)                  → Jan 1 – Dec 31
+*   getDateRange('custom', { startDate, endDate })
+*/
+function getDateRange(option, value) {
+	switch (option) {
+		case "month": {
+			let year;
+			let month;
+			const match = String(value).match(/^(\d{4})-(\d{1,2})$/);
+			if (match) {
+				year = parseInt(match[1], 10);
+				month = parseInt(match[2], 10) - 1;
+			} else {
+				const date = new Date(value);
+				year = date.getFullYear();
+				month = date.getMonth();
+			}
+			return {
+				startDate: new Date(year, month, 1),
+				endDate: new Date(year, month + 1, 0, 23, 59, 59, 999)
+			};
+		}
+		case "quarter": {
+			const { quarter, year } = value;
+			const startMonth = (quarter - 1) * 3;
+			return {
+				startDate: new Date(year, startMonth, 1),
+				endDate: new Date(year, startMonth + 3, 0, 23, 59, 59, 999)
+			};
+		}
+		case "year": {
+			const year = typeof value === "number" ? value : parseInt(String(value), 10);
+			return {
+				startDate: new Date(year, 0, 1),
+				endDate: new Date(year, 11, 31, 23, 59, 59, 999)
+			};
+		}
+		case "custom": {
+			const { startDate, endDate } = value;
+			const end = new Date(endDate);
+			if (end.getHours() === 0 && end.getMinutes() === 0 && end.getSeconds() === 0 && end.getMilliseconds() === 0) end.setHours(23, 59, 59, 999);
+			return {
+				startDate: new Date(startDate),
+				endDate: end
+			};
+		}
+		default: {
+			const now = /* @__PURE__ */ new Date();
+			return {
+				startDate: new Date(now.getFullYear(), now.getMonth(), 1),
+				endDate: new Date(now.getFullYear(), now.getMonth() + 1, 0, 23, 59, 59, 999)
+			};
+		}
+	}
+}
+/** Get fiscal year start date for a given date and fiscal start month */
+function getFiscalYearStart(date, fiscalStartMonth = 1) {
+	const month = fiscalStartMonth - 1;
+	const year = date.getMonth() < month ? date.getFullYear() - 1 : date.getFullYear();
+	return new Date(year, month, 1);
+}
+
+//#endregion
+//#region src/utils/filter-builder.ts
+/**
+* Filter Builder — Sanitizes user-supplied dimension filters for aggregation pipelines.
+*
+* Prevents injection of dangerous MongoDB operators while allowing
+* standard equality and comparison filters on custom dimension fields.
+*/
+const BLOCKED_OPERATORS = new Set([
+	"$where",
+	"$expr",
+	"$function",
+	"$accumulator",
+	"$merge",
+	"$out",
+	"$unionWith"
+]);
+/**
+* Build a sanitized filter object from user-supplied dimension filters.
+* Blocks dangerous operators ($where, $expr, $function, etc.).
+*
+* @param filters - Key-value filters (e.g. { 'journalItems.departmentId': 'dept-1' })
+* @returns Sanitized filter object safe for $match stages
+* @throws Error if a blocked operator is used
+*/
+function buildItemFilters(filters) {
+	if (!filters || Object.keys(filters).length === 0) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(filters)) {
+		if (key.startsWith("$")) throw new Error(`Filter key "${key}" is not allowed. Use field names, not operators.`);
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			for (const opKey of Object.keys(value)) if (BLOCKED_OPERATORS.has(opKey)) throw new Error(`Filter operator "${opKey}" is not allowed.`);
+		}
+		result[key] = value;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/reports/trial-balance.ts
+async function generateTrialBalance(opts, params) {
+	const { AccountModel, JournalEntryModel, country, orgField, fiscalYearStartMonth = 1 } = opts;
+	requireOrgScope(orgField, params.organizationId);
+	const { startDate, endDate } = getDateRange(params.dateOption, params.dateValue);
+	const fiscalYearStart = getFiscalYearStart(startDate, fiscalYearStartMonth);
+	const itemFilters = buildItemFilters(params.filters);
+	const accountQuery = { active: true };
+	if (orgField && params.organizationId) accountQuery[orgField] = params.organizationId;
+	const allAccounts = await AccountModel.find(accountQuery).lean();
+	const bsIds = [];
+	const isIds = [];
+	for (const acc of allAccounts) {
+		const at = country.getAccountType(acc.accountTypeCode);
+		if (!at || at.isGroup) continue;
+		if (at.category.startsWith("Balance Sheet")) bsIds.push(acc._id);
+		else if (at.category.startsWith("Income Statement")) isIds.push(acc._id);
+	}
+	const baseMatch = { state: "posted" };
+	if (orgField && params.organizationId) baseMatch[orgField] = params.organizationId;
+	const accountFilter = params.accountId ? { "journalItems.account": params.accountId } : {};
+	const buildPipeline = (ids, dateFrom, dateTo) => [
+		{ $match: {
+			...baseMatch,
+			date: {
+				$gte: dateFrom,
+				$lt: dateTo
+			}
+		} },
+		{ $unwind: "$journalItems" },
+		{ $match: {
+			"journalItems.account": { $in: ids },
+			...accountFilter,
+			...itemFilters
+		} },
+		{ $group: {
+			_id: "$journalItems.account",
+			d: { $sum: "$journalItems.debit" },
+			c: { $sum: "$journalItems.credit" }
+		} }
+	];
+	const [bsInitial, isInitial, current] = await Promise.all([
+		bsIds.length ? JournalEntryModel.aggregate(buildPipeline(bsIds, /* @__PURE__ */ new Date(0), startDate)) : [],
+		isIds.length ? JournalEntryModel.aggregate(buildPipeline(isIds, fiscalYearStart, startDate)) : [],
+		JournalEntryModel.aggregate(buildPipeline([...bsIds, ...isIds], startDate, new Date(endDate.getTime() + 1)))
+	]);
+	const map = /* @__PURE__ */ new Map();
+	for (const r of [...bsInitial, ...isInitial]) {
+		const key = String(r._id);
+		map.set(key, {
+			iD: r.d,
+			iC: r.c,
+			cD: 0,
+			cC: 0
+		});
+	}
+	for (const r of current) {
+		const key = String(r._id);
+		const existing = map.get(key) ?? {
+			iD: 0,
+			iC: 0,
+			cD: 0,
+			cC: 0
+		};
+		existing.cD = r.d;
+		existing.cC = r.c;
+		map.set(key, existing);
+	}
+	const accountLookup = new Map(allAccounts.map((a) => [String(a._id), a]));
+	const rows = [];
+	for (const [id, bal] of map) {
+		const acc = accountLookup.get(id);
+		const net = bal.iD + bal.cD - (bal.iC + bal.cC);
+		rows.push({
+			account: acc ?? id,
+			initial: {
+				debit: bal.iD,
+				credit: bal.iC
+			},
+			current: {
+				debit: bal.cD,
+				credit: bal.cC
+			},
+			ending: net >= 0 ? {
+				debit: net,
+				credit: 0
+			} : {
+				debit: 0,
+				credit: Math.abs(net)
+			}
+		});
+	}
+	return {
+		rows,
+		period: {
+			startDate,
+			endDate
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/account-helpers.ts
+/**
+* Check if an account type is a virtual tax sub-account.
+* Returns true if the account's parent has `isVirtualTotal: true`.
+* Works for any country pack — no code format assumptions.
+*/
+function isVirtualTaxAccount(accountType, accountMap) {
+	if (!accountType.parentCode) return false;
+	return accountMap.get(accountType.parentCode)?.isVirtualTotal === true;
+}
+/**
+* Calculate a total from sub-accounts using the totalAccountTypes formula.
+* @param formula - Array of { account, operation } instructions
+* @param balanceMap - Map of account code → balance
+*/
+function calculateTotal(formula, balanceMap) {
+	let total = 0;
+	for (const item of formula) {
+		const balance = balanceMap.get(item.account) ?? 0;
+		total += item.operation === "+" ? balance : -balance;
+	}
+	return total;
+}
+/**
+* Compute the ending balance for an account given its debits and credits.
+* Uses the account's main type to determine normal balance direction.
+*
+* Assets & Expenses: debit - credit
+* Liabilities, Equity & Income: credit - debit
+*/
+function computeEndingBalance(category, totalDebit, totalCredit) {
+	const mainType = extractMainType(category);
+	if (mainType === "Asset" || mainType === "Expense") return totalDebit - totalCredit;
+	return totalCredit - totalDebit;
+}
+/**
+* Build a lookup map from an array of account types.
+*/
+function buildAccountTypeMap(accountTypes) {
+	const map = /* @__PURE__ */ new Map();
+	for (const at of accountTypes) map.set(at.code, at);
+	return map;
+}
+
+//#endregion
+//#region src/reports/balance-sheet.ts
+async function generateBalanceSheet(opts, params) {
+	const { AccountModel, JournalEntryModel, country, orgField, fiscalYearStartMonth = 1, retainedEarningsCode = country.retainedEarningsCode ?? "3660", currentYearEarningsCode = country.currentYearEarningsCode ?? "3680" } = opts;
+	requireOrgScope(orgField, params.organizationId);
+	const { endDate } = getDateRange(params.dateOption, params.dateValue);
+	const fiscalYearStart = getFiscalYearStart(endDate, fiscalYearStartMonth);
+	const itemFilters = buildItemFilters(params.filters);
+	const q = { active: true };
+	if (orgField && params.organizationId) q[orgField] = params.organizationId;
+	const allAccounts = await AccountModel.find(q).lean();
+	const bsIds = allAccounts.filter((a) => {
+		const at = country.getAccountType(a.accountTypeCode);
+		return at && !at.isGroup && at.category.startsWith("Balance Sheet");
+	}).map((a) => a._id);
+	const isIds = allAccounts.filter((a) => {
+		const at = country.getAccountType(a.accountTypeCode);
+		return at && !at.isGroup && !at.isTotal && at.category.startsWith("Income Statement");
+	}).map((a) => a._id);
+	const baseMatch = { state: "posted" };
+	if (orgField && params.organizationId) baseMatch[orgField] = params.organizationId;
+	const [bsResults, netIncomeResults, priorRetainedResults] = await Promise.all([
+		JournalEntryModel.aggregate([
+			{ $match: {
+				...baseMatch,
+				date: { $lte: endDate }
+			} },
+			{ $unwind: "$journalItems" },
+			{ $match: {
+				"journalItems.account": { $in: bsIds },
+				...itemFilters
+			} },
+			{ $group: {
+				_id: "$journalItems.account",
+				d: { $sum: "$journalItems.debit" },
+				c: { $sum: "$journalItems.credit" }
+			} }
+		]),
+		JournalEntryModel.aggregate([
+			{ $match: {
+				...baseMatch,
+				date: {
+					$gte: fiscalYearStart,
+					$lte: endDate
+				}
+			} },
+			{ $unwind: "$journalItems" },
+			{ $match: {
+				"journalItems.account": { $in: isIds },
+				...itemFilters
+			} },
+			{ $group: {
+				_id: null,
+				d: { $sum: "$journalItems.debit" },
+				c: { $sum: "$journalItems.credit" }
+			} }
+		]),
+		JournalEntryModel.aggregate([
+			{ $match: {
+				...baseMatch,
+				date: { $lt: fiscalYearStart }
+			} },
+			{ $unwind: "$journalItems" },
+			{ $match: {
+				"journalItems.account": { $in: isIds },
+				...itemFilters
+			} },
+			{ $group: {
+				_id: null,
+				d: { $sum: "$journalItems.debit" },
+				c: { $sum: "$journalItems.credit" }
+			} }
+		])
+	]);
+	const netIncome = netIncomeResults.length > 0 ? netIncomeResults[0].c - netIncomeResults[0].d : 0;
+	const priorRetained = priorRetainedResults.length > 0 ? priorRetainedResults[0].c - priorRetainedResults[0].d : 0;
+	const accountMap = new Map(allAccounts.map((a) => [String(a._id), a]));
+	const accountTypeMap = buildAccountTypeMap(country.accountTypes);
+	const balanceMap = /* @__PURE__ */ new Map();
+	const labels = country.reportLabels ?? {};
+	const assets = {
+		name: labels.assets ?? "Assets",
+		total: 0,
+		groups: []
+	};
+	const liabilities = {
+		name: labels.liabilities ?? "Liabilities",
+		total: 0,
+		groups: []
+	};
+	const equity = {
+		name: labels.equity ?? "Equity",
+		total: 0,
+		groups: []
+	};
+	const groupsMap = {
+		Asset: {},
+		Liability: {},
+		Equity: {}
+	};
+	for (const r of bsResults) {
+		const acc = accountMap.get(String(r._id));
+		if (!acc) continue;
+		const at = country.getAccountType(acc.accountTypeCode);
+		if (!at) continue;
+		const mainType = extractMainType(at.category) ?? "Asset";
+		const balance = computeEndingBalance(at.category, r.d, r.c);
+		balanceMap.set(at.code, balance);
+		const groupName = (at.parentCode ? country.getAccountType(at.parentCode) : void 0)?.name ?? at.name;
+		if (!(groupName in groupsMap[mainType])) groupsMap[mainType][groupName] = {
+			name: groupName,
+			total: 0,
+			accounts: []
+		};
+		const group = groupsMap[mainType][groupName];
+		if (!isVirtualTaxAccount(at, accountTypeMap)) group.accounts.push({
+			id: acc._id,
+			name: acc.name ?? at.name,
+			code: acc.accountNumber ?? at.code,
+			balance,
+			isTotal: at.isTotal,
+			isVirtualTotal: at.isVirtualTotal
+		});
+		if (!at.isTotal) group.total += balance;
+	}
+	const reGroup = {
+		name: "Retained Earnings",
+		total: priorRetained + netIncome,
+		accounts: [{
+			id: "prior-retained",
+			name: "Previous Years Retained Earnings",
+			code: retainedEarningsCode,
+			balance: priorRetained
+		}, {
+			id: "current-year",
+			name: `Current Year Net Income (${endDate.getFullYear()})`,
+			code: currentYearEarningsCode,
+			balance: netIncome,
+			isCalculated: true
+		}]
+	};
+	if (!(reGroup.name in groupsMap.Equity)) groupsMap.Equity[reGroup.name] = reGroup;
+	else {
+		groupsMap.Equity[reGroup.name].accounts.push(...reGroup.accounts);
+		groupsMap.Equity[reGroup.name].total += reGroup.total;
+	}
+	assets.groups = Object.values(groupsMap.Asset);
+	liabilities.groups = Object.values(groupsMap.Liability);
+	equity.groups = Object.values(groupsMap.Equity);
+	assets.total = assets.groups.reduce((s, g) => s + g.total, 0);
+	liabilities.total = liabilities.groups.reduce((s, g) => s + g.total, 0);
+	equity.total = equity.groups.reduce((s, g) => s + g.total, 0);
+	const liabilitiesAndEquity = liabilities.total + equity.total;
+	return {
+		metadata: {
+			businessName: params.businessName,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			asOfDate: endDate.toISOString().split("T")[0],
+			displayDate: `As of ${endDate.toLocaleDateString("en-US", {
+				year: "numeric",
+				month: "long",
+				day: "numeric"
+			})}`
+		},
+		assets,
+		liabilities,
+		equity,
+		summary: {
+			totalAssets: assets.total,
+			totalLiabilities: liabilities.total,
+			totalEquity: equity.total,
+			liabilitiesAndEquity,
+			difference: assets.total - liabilitiesAndEquity,
+			isBalanced: assets.total === liabilitiesAndEquity
+		}
+	};
+}
+
+//#endregion
+//#region src/reports/income-statement.ts
+async function generateIncomeStatement(opts, params) {
+	const { AccountModel, JournalEntryModel, country, orgField } = opts;
+	requireOrgScope(orgField, params.organizationId);
+	const { startDate, endDate } = getDateRange(params.dateOption, params.dateValue);
+	const itemFilters = buildItemFilters(params.filters);
+	const q = { active: true };
+	if (orgField && params.organizationId) q[orgField] = params.organizationId;
+	const allAccounts = await AccountModel.find(q).lean();
+	const isIds = allAccounts.filter((a) => {
+		const at = country.getAccountType(a.accountTypeCode);
+		return at && !at.isGroup && !at.isTotal && at.category.startsWith("Income Statement");
+	}).map((a) => a._id);
+	const baseMatch = {
+		state: "posted",
+		date: {
+			$gte: startDate,
+			$lte: endDate
+		}
+	};
+	if (orgField && params.organizationId) baseMatch[orgField] = params.organizationId;
+	const results = await JournalEntryModel.aggregate([
+		{ $match: baseMatch },
+		{ $unwind: "$journalItems" },
+		{ $match: {
+			"journalItems.account": { $in: isIds },
+			...itemFilters
+		} },
+		{ $group: {
+			_id: "$journalItems.account",
+			d: { $sum: "$journalItems.debit" },
+			c: { $sum: "$journalItems.credit" }
+		} }
+	]);
+	const accountMap = new Map(allAccounts.map((a) => [String(a._id), a]));
+	const revenueGroups = {};
+	const expenseGroups = {};
+	for (const r of results) {
+		const acc = accountMap.get(String(r._id));
+		if (!acc) continue;
+		const at = country.getAccountType(acc.accountTypeCode);
+		if (!at) continue;
+		const mainType = extractMainType(at.category);
+		const netAmount = mainType === "Income" ? r.c - r.d : r.d - r.c;
+		if (netAmount === 0) continue;
+		const groupName = (at.parentCode ? country.getAccountType(at.parentCode) : void 0)?.name ?? at.name;
+		const groups = mainType === "Income" ? revenueGroups : expenseGroups;
+		if (!(groupName in groups)) groups[groupName] = {
+			name: groupName,
+			total: 0,
+			accounts: []
+		};
+		groups[groupName].accounts.push({
+			id: acc._id,
+			name: acc.name ?? at.name,
+			code: acc.accountNumber ?? at.code,
+			balance: netAmount
+		});
+		groups[groupName].total += netAmount;
+	}
+	const labels = country.reportLabels ?? {};
+	const revenue = {
+		name: labels.revenue ?? "Revenue",
+		total: Object.values(revenueGroups).reduce((s, g) => s + g.total, 0),
+		groups: Object.values(revenueGroups)
+	};
+	const expenses = {
+		name: labels.expenses ?? "Expenses",
+		total: Object.values(expenseGroups).reduce((s, g) => s + g.total, 0),
+		groups: Object.values(expenseGroups)
+	};
+	const cogsCode = country.cogsGroupCode;
+	const isCogs = (name) => cogsCode ? name === cogsCode : name === "Cost of Sales" || name === "Cost of Goods Sold";
+	const costOfSales = expenses.groups.find((g) => isCogs(g.name))?.total ?? 0;
+	const grossProfit = revenue.total - costOfSales;
+	const operatingIncome = grossProfit - expenses.groups.filter((g) => !isCogs(g.name)).reduce((s, g) => s + g.total, 0);
+	const netIncome = revenue.total - expenses.total;
+	const periodDisplay = params.dateOption === "year" ? `For the year ended ${endDate.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "long",
+		day: "numeric"
+	})}` : `${startDate.toLocaleDateString("en-US", {
+		month: "short",
+		day: "numeric"
+	})} – ${endDate.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric"
+	})}`;
+	return {
+		metadata: {
+			businessName: params.businessName,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			periodStart: startDate.toISOString().split("T")[0],
+			periodEnd: endDate.toISOString().split("T")[0],
+			displayPeriod: periodDisplay
+		},
+		revenue,
+		costOfSales,
+		grossProfit,
+		expenses,
+		operatingIncome,
+		netIncome
+	};
+}
+
+//#endregion
+//#region src/reports/general-ledger.ts
+async function generateGeneralLedger(opts, params) {
+	const { AccountModel, JournalEntryModel, country, orgField, fiscalYearStartMonth = 1 } = opts;
+	requireOrgScope(orgField, params.organizationId);
+	const { startDate, endDate } = getDateRange(params.dateOption, params.dateValue);
+	const fiscalYearStart = getFiscalYearStart(startDate, fiscalYearStartMonth);
+	const itemFilters = buildItemFilters(params.filters);
+	const acctQuery = { active: true };
+	if (orgField && params.organizationId) acctQuery[orgField] = params.organizationId;
+	if (params.accountId) acctQuery._id = params.accountId;
+	const allAccounts = await AccountModel.find(acctQuery).lean();
+	const filtered = [];
+	for (const acc of allAccounts) {
+		const at = country.getAccountType(acc.accountTypeCode);
+		if (!at || at.isGroup || at.isTotal) continue;
+		filtered.push({
+			acc,
+			at
+		});
+	}
+	if (filtered.length === 0) return {
+		accounts: [],
+		period: {
+			startDate,
+			endDate
+		}
+	};
+	const bsAccountIds = [];
+	const isAccountIds = [];
+	const allAccountIds = [];
+	for (const { acc, at } of filtered) {
+		allAccountIds.push(acc._id);
+		if (at.category.startsWith("Balance Sheet")) bsAccountIds.push(acc._id);
+		else isAccountIds.push(acc._id);
+	}
+	const orgScope = {};
+	if (orgField && params.organizationId) orgScope[orgField] = params.organizationId;
+	const openingBalancePipeline = (accountIds, dateFilter) => accountIds.length > 0 ? JournalEntryModel.aggregate([
+		{ $match: {
+			state: "posted",
+			date: dateFilter,
+			...orgScope
+		} },
+		{ $unwind: "$journalItems" },
+		{ $match: {
+			"journalItems.account": { $in: accountIds },
+			...itemFilters
+		} },
+		{ $group: {
+			_id: "$journalItems.account",
+			d: { $sum: "$journalItems.debit" },
+			c: { $sum: "$journalItems.credit" }
+		} }
+	]) : Promise.resolve([]);
+	const [bsOpenResults, isOpenResults, periodEntries] = await Promise.all([
+		openingBalancePipeline(bsAccountIds, { $lt: startDate }),
+		openingBalancePipeline(isAccountIds, {
+			$gte: fiscalYearStart,
+			$lt: startDate
+		}),
+		JournalEntryModel.find({
+			state: "posted",
+			date: {
+				$gte: startDate,
+				$lte: endDate
+			},
+			"journalItems.account": { $in: allAccountIds },
+			...orgScope,
+			...itemFilters
+		}).select("date referenceNumber label journalItems").sort({ date: 1 }).lean()
+	]);
+	const openBalMap = /* @__PURE__ */ new Map();
+	for (const r of [...bsOpenResults, ...isOpenResults]) openBalMap.set(String(r._id), {
+		d: r.d,
+		c: r.c
+	});
+	const entryItemsByAccount = /* @__PURE__ */ new Map();
+	for (const entry of periodEntries) {
+		const items = entry.journalItems ?? [];
+		for (const item of items) {
+			const accId = String(item.account);
+			const debit = item.debit ?? 0;
+			const credit = item.credit ?? 0;
+			let list = entryItemsByAccount.get(accId);
+			if (!list) {
+				list = [];
+				entryItemsByAccount.set(accId, list);
+			}
+			list.push({
+				date: entry.date,
+				referenceNumber: entry.referenceNumber ?? "",
+				label: entry.label ?? "",
+				debit,
+				credit
+			});
+		}
+	}
+	const glAccounts = [];
+	for (const { acc, at } of filtered) {
+		const accIdStr = String(acc._id);
+		const openData = openBalMap.get(accIdStr);
+		const openingBalance = openData ? computeEndingBalance(at.category, openData.d, openData.c) : 0;
+		let runningBalance = openingBalance;
+		const entries = [];
+		const mainType = extractMainType(at.category);
+		const accountItems = entryItemsByAccount.get(accIdStr) ?? [];
+		for (const item of accountItems) {
+			const delta = mainType === "Asset" || mainType === "Expense" ? item.debit - item.credit : item.credit - item.debit;
+			runningBalance += delta;
+			entries.push({
+				date: item.date,
+				referenceNumber: item.referenceNumber,
+				label: item.label,
+				debit: item.debit,
+				credit: item.credit,
+				runningBalance
+			});
+		}
+		glAccounts.push({
+			account: acc,
+			openingBalance,
+			entries,
+			closingBalance: runningBalance
+		});
+	}
+	return {
+		accounts: glAccounts,
+		period: {
+			startDate,
+			endDate
+		}
+	};
+}
+
+//#endregion
+//#region src/reports/cash-flow.ts
+async function generateCashFlow(opts, params) {
+	const { AccountModel, JournalEntryModel, country, orgField } = opts;
+	requireOrgScope(orgField, params.organizationId);
+	const { startDate, endDate } = getDateRange(params.dateOption, params.dateValue);
+	const itemFilters = buildItemFilters(params.filters);
+	const q = { active: true };
+	if (orgField && params.organizationId) q[orgField] = params.organizationId;
+	const allAccounts = await AccountModel.find(q).lean();
+	const accountCfMap = /* @__PURE__ */ new Map();
+	const accountMap = new Map(allAccounts.map((a) => [String(a._id), a]));
+	const cfAccountIds = [];
+	for (const acc of allAccounts) {
+		const at = country.getAccountType(acc.accountTypeCode);
+		if (!at || at.isGroup || at.isTotal) continue;
+		const cf = at.cashFlowCategory;
+		if (!cf) continue;
+		const normalized = cf.charAt(0).toUpperCase() + cf.slice(1);
+		accountCfMap.set(String(acc._id), {
+			category: at.category,
+			cfCategory: normalized
+		});
+		cfAccountIds.push(acc._id);
+	}
+	const baseMatch = {
+		state: "posted",
+		date: {
+			$gte: startDate,
+			$lte: endDate
+		}
+	};
+	if (orgField && params.organizationId) baseMatch[orgField] = params.organizationId;
+	const results = cfAccountIds.length > 0 ? await JournalEntryModel.aggregate([
+		{ $match: baseMatch },
+		{ $unwind: "$journalItems" },
+		{ $match: {
+			"journalItems.account": { $in: cfAccountIds },
+			...itemFilters
+		} },
+		{ $group: {
+			_id: "$journalItems.account",
+			d: { $sum: "$journalItems.debit" },
+			c: { $sum: "$journalItems.credit" }
+		} }
+	]) : [];
+	const flows = {
+		Operating: {
+			total: 0,
+			accounts: []
+		},
+		Investing: {
+			total: 0,
+			accounts: []
+		},
+		Financing: {
+			total: 0,
+			accounts: []
+		}
+	};
+	for (const r of results) {
+		const accIdStr = String(r._id);
+		const meta = accountCfMap.get(accIdStr);
+		if (!meta) continue;
+		const amount = computeEndingBalance(meta.category, r.d, r.c);
+		const acc = accountMap.get(accIdStr);
+		const at = country.getAccountType(acc?.accountTypeCode);
+		flows[meta.cfCategory].accounts.push({
+			name: acc?.name ?? at?.name ?? "",
+			code: acc?.accountNumber ?? at?.code ?? "",
+			amount
+		});
+		flows[meta.cfCategory].total += amount;
+	}
+	const netCashFlow = flows.Operating.total + flows.Investing.total + flows.Financing.total;
+	const periodDisplay = `${startDate.toLocaleDateString("en-US", {
+		month: "short",
+		day: "numeric"
+	})} – ${endDate.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric"
+	})}`;
+	return {
+		metadata: {
+			businessName: params.businessName,
+			generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			periodStart: startDate.toISOString().split("T")[0],
+			periodEnd: endDate.toISOString().split("T")[0],
+			displayPeriod: periodDisplay
+		},
+		operating: flows.Operating,
+		investing: flows.Investing,
+		financing: flows.Financing,
+		netCashFlow
+	};
+}
+
+//#endregion
+//#region src/reports/fiscal-close.ts
+async function closeFiscalPeriod(opts, params) {
+	const { AccountModel, JournalEntryModel, FiscalPeriodModel, country, orgField, retainedEarningsCode = country.retainedEarningsCode ?? "3660", logger = defaultLogger } = opts;
+	const { periodId, organizationId, closedBy } = params;
+	requireOrgScope(orgField, organizationId);
+	const { session, ownSession } = await acquireSession(AccountModel.db, params.session, logger);
+	let success = false;
+	try {
+		const queryOpts = session ? { session } : {};
+		const periodQuery = { _id: periodId };
+		if (orgField && organizationId) periodQuery[orgField] = organizationId;
+		const period = await FiscalPeriodModel.findOne(periodQuery, null, queryOpts).lean();
+		if (!period) throw Errors.notFound("Fiscal period not found");
+		if (period.closed) throw Errors.fiscal("Fiscal period is already closed");
+		const startDate = period.startDate;
+		const endDate = period.endDate;
+		const accountQuery = { active: true };
+		if (orgField && organizationId) accountQuery[orgField] = organizationId;
+		const allAccounts = await AccountModel.find(accountQuery, null, queryOpts).lean();
+		const isAccounts = [];
+		let retainedEarningsId = null;
+		for (const acc of allAccounts) {
+			const at = country.getAccountType(acc.accountTypeCode);
+			if (!at) continue;
+			if (acc.accountTypeCode === retainedEarningsCode) retainedEarningsId = acc._id;
+			if (at.isGroup || at.isTotal) continue;
+			if (at.category.startsWith("Income Statement")) isAccounts.push({
+				id: acc._id,
+				code: at.code,
+				isIncome: at.category === "Income Statement-Income"
+			});
+		}
+		if (!retainedEarningsId) throw Errors.fiscal(`Retained earnings account (code: ${retainedEarningsCode}) not found. Create this account before closing the fiscal period.`);
+		const baseMatch = {
+			state: "posted",
+			date: {
+				$gte: startDate,
+				$lte: endDate
+			}
+		};
+		if (orgField && organizationId) baseMatch[orgField] = organizationId;
+		const isIds = isAccounts.map((a) => a.id);
+		const balances = isIds.length > 0 ? await JournalEntryModel.aggregate([
+			{ $match: baseMatch },
+			{ $unwind: "$journalItems" },
+			{ $match: { "journalItems.account": { $in: isIds } } },
+			{ $group: {
+				_id: "$journalItems.account",
+				d: { $sum: "$journalItems.debit" },
+				c: { $sum: "$journalItems.credit" }
+			} }
+		], queryOpts) : [];
+		const closingItems = [];
+		let netIncome = 0;
+		const balMap = new Map(balances.map((b) => [String(b._id), b]));
+		for (const acc of isAccounts) {
+			const bal = balMap.get(String(acc.id));
+			if (!bal) continue;
+			const net = bal.c - bal.d;
+			if (net === 0) continue;
+			closingItems.push({
+				account: acc.id,
+				debit: net > 0 ? net : 0,
+				credit: net < 0 ? Math.abs(net) : 0,
+				label: `Close ${acc.code}`
+			});
+			netIncome += net;
+		}
+		let closingEntryId = null;
+		if (closingItems.length > 0) {
+			closingItems.push({
+				account: retainedEarningsId,
+				debit: netIncome < 0 ? Math.abs(netIncome) : 0,
+				credit: netIncome > 0 ? netIncome : 0,
+				label: "Transfer net income to retained earnings"
+			});
+			const totalDebit = closingItems.reduce((s, i) => s + i.debit, 0);
+			const totalCredit = closingItems.reduce((s, i) => s + i.credit, 0);
+			const closingEntryData = {
+				journalType: "YEAR_END",
+				state: "posted",
+				date: endDate,
+				label: `Fiscal year closing – ${period.name ?? "Period"}`,
+				journalItems: closingItems,
+				totalDebit,
+				totalCredit
+			};
+			if (orgField && organizationId) closingEntryData[orgField] = organizationId;
+			const [closingEntry] = await JournalEntryModel.create([closingEntryData], queryOpts);
+			closingEntryId = closingEntry._id;
+		}
+		const closedAt = /* @__PURE__ */ new Date();
+		await FiscalPeriodModel.findOneAndUpdate(periodQuery, {
+			closed: true,
+			closedAt,
+			closedBy: closedBy ?? null,
+			closingEntryId
+		}, queryOpts);
+		const result = {
+			periodId,
+			netIncome,
+			closingEntryId,
+			accountsClosed: closingItems.length - (closingItems.length > 0 ? 1 : 0),
+			closedAt
+		};
+		success = true;
+		return result;
+	} finally {
+		await finalizeSession(session, ownSession, success);
+	}
+}
+async function reopenFiscalPeriod(opts, params) {
+	const { JournalEntryModel, FiscalPeriodModel, orgField, logger = defaultLogger } = opts;
+	const { periodId, organizationId, reopenedBy } = params;
+	requireOrgScope(orgField, organizationId);
+	const db = (opts.AccountModel ?? FiscalPeriodModel).db;
+	const { session, ownSession } = await acquireSession(db, params.session, logger);
+	let success = false;
+	try {
+		const queryOpts = session ? { session } : {};
+		const periodQuery = { _id: periodId };
+		if (orgField && organizationId) periodQuery[orgField] = organizationId;
+		const period = await FiscalPeriodModel.findOne(periodQuery, null, queryOpts).lean();
+		if (!period) throw Errors.notFound("Fiscal period not found");
+		if (!period.closed) throw Errors.fiscal("Fiscal period is not closed");
+		const laterQuery = {
+			closed: true,
+			startDate: { $gt: period.endDate }
+		};
+		if (orgField && organizationId) laterQuery[orgField] = organizationId;
+		if (await FiscalPeriodModel.findOne(laterQuery, null, queryOpts).lean()) throw Errors.fiscal("Cannot reopen: a later fiscal period is already closed. Reopen later periods first.");
+		const closingEntryId = period.closingEntryId ?? null;
+		if (closingEntryId) await JournalEntryModel.findByIdAndDelete(closingEntryId, queryOpts);
+		const reopenedAt = /* @__PURE__ */ new Date();
+		await FiscalPeriodModel.findOneAndUpdate(periodQuery, {
+			closed: false,
+			closedAt: null,
+			closedBy: null,
+			closingEntryId: null,
+			reopenedAt,
+			reopenedBy: reopenedBy ?? null
+		}, queryOpts);
+		const result = {
+			periodId,
+			deletedEntryId: closingEntryId,
+			reopenedAt
+		};
+		success = true;
+		return result;
+	} finally {
+		await finalizeSession(session, ownSession, success);
+	}
+}
+
+//#endregion
+export { generateIncomeStatement as a, calculateTotal as c, generateTrialBalance as d, buildItemFilters as f, generateGeneralLedger as i, computeEndingBalance as l, getFiscalYearStart as m, reopenFiscalPeriod as n, generateBalanceSheet as o, getDateRange as p, generateCashFlow as r, buildAccountTypeMap as s, closeFiscalPeriod as t, isVirtualTaxAccount as u };
+//# sourceMappingURL=fiscal-close-CNOwv_ud.mjs.map