@classytic/ledger 0.5.1 → 0.6.0

package/dist/index.mjs

@@ -1,9 +1,9 @@
 import { a as JOURNAL_CODES, c as getCustomJournalTypes, d as isValidJournalType, f as registerJournalType, i as isValidCurrency, l as getJournalType, n as getCurrency, o as JOURNAL_TYPES, r as getMinorUnit, s as _freezeJournalTypes, t as CURRENCIES, u as getJournalTypeCodes } from "./currencies-CsuBGfgs.mjs";
 import { Money, add, allocate, format, formatPlain, fromDecimal, multiply, parseCents, percentage, splitTaxExclusive, splitTaxInclusive, subtract, toDecimal } from "./money.mjs";
-import { n as Errors, t as AccountingError } from "./errors-BmRjW38t.mjs";
-import { C as DEFAULT_BUCKETS, S as isVirtualTaxAccount, T as requireOrgScope, _ as getDateRange, a as defaultLogger, b as calculateTotal, c as buildRevaluationEntry, d as generateGeneralLedger, f as generateDimensionBreakdown, g as buildItemFilters, h as generateBalanceSheet, i as finalizeSession, l as computeRevaluation, m as generateBudgetVsActual, n as reopenFiscalPeriod, o as generateTrialBalance, p as generateCashFlow, r as acquireSession, s as generateRevaluation, t as closeFiscalPeriod, u as generateIncomeStatement, v as getFiscalYearStart, w as generateAgedBalance, x as computeEndingBalance, y as buildAccountTypeMap } from "./fiscal-close-Dk3yRT9i.mjs";
+import { n as Errors, t as AccountingError } from "./errors-CSDQPNyt.mjs";
+import { C as isVirtualTaxAccount, E as requireOrgScope, S as computeEndingBalance, T as generateAgedBalance, _ as buildItemFilters, a as finalizeSession, b as buildAccountTypeMap, c as generateRevaluation, d as generateIncomeStatement, f as generateGeneralLedger, g as generateBalanceSheet, h as generateBudgetVsActual, i as acquireSession, l as buildRevaluationEntry, m as generateCashFlow, n as closeFiscalPeriod, o as defaultLogger, p as generateDimensionBreakdown, r as reopenFiscalPeriod, s as generateTrialBalance, t as generatePartnerLedger, u as computeRevaluation, v as getDateRange, w as DEFAULT_BUCKETS, x as calculateTotal, y as getFiscalYearStart } from "./partner-ledger-D9H5hegI.mjs";
 import { c as getNormalBalance, d as isValidCategory, l as isBalanceSheet, n as CATEGORY_KEYS, t as CATEGORIES, u as isIncomeStatement } from "./categories-BkKdv16V.mjs";
-import { i as doubleEntryPlugin, n as idempotencyPlugin, r as fiscalLockPlugin, t as dateLockPlugin } from "./date-lock.plugin-B6WyvqNG.mjs";
+import { a as taxLockPlugin, c as createLockPlugin, i as fiscalLockPlugin, l as idempotencyPlugin, n as creditLimitPlugin, o as watermarkResolver, r as dailyLockPlugin, s as periodResolver, t as fxRealizationPlugin, u as doubleEntryPlugin } from "./fx-realization.plugin-CgQFDGv2.mjs";
 import { defineCountryPack } from "./country/index.mjs";
 import { a as exportToCsv, i as quickbooksFieldMap, r as universalFieldMap, t as flattenJournalEntries } from "./exports-BP-0Ni5W.mjs";
 import mongoose, { Schema } from "mongoose";
@@ -273,6 +273,121 @@ function createFiscalPeriodSchema(config, options = {}) {
 	return schema;
 }
 //#endregion
+//#region src/schemas/journal.schema.ts
+/**
+* Journal Schema Factory (0.6.0 — first-class Journal resource)
+*
+* A Journal is an organization-owned posting channel with its own
+* reference-number sequence, permitted payment methods, optional default
+* accounts, and source configuration for bank/statement imports.
+*
+* Journals are **optional** — a consumer that never seeds journals keeps
+* the 0.5.x enum-only flow on journal entries. Consumers that do seed
+* journals gain:
+*
+*   - Per-journal reference-number prefix (e.g. `INV/2026/03/0042`)
+*   - Per-journal lock wiring (sale-lock on the sales journal, not globally)
+*   - Payment method restrictions
+*   - Bank-statement source binding for automated imports (0.7+)
+*
+* The schema is additive: existing journal entries without a `journal` ref
+* keep working unchanged, and seed-from-pack is opt-in via
+* `engine.repositories.journals.seedDefaults(orgId)`.
+*/
+function createJournalSchema(config, accountModelName, options = {}) {
+	const { multiTenant } = config;
+	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
+	const fields = {
+		code: {
+			type: String,
+			required: true,
+			trim: true
+		},
+		name: {
+			type: String,
+			required: true,
+			trim: true
+		},
+		journalType: {
+			type: String,
+			required: true
+		},
+		kind: {
+			type: String,
+			enum: [
+				"general",
+				"sale",
+				"purchase",
+				"bank",
+				"cash",
+				"misc"
+			],
+			default: "general",
+			required: true
+		},
+		sequencePrefix: {
+			type: String,
+			default: null
+		},
+		sequenceNextNum: {
+			type: Number,
+			default: 1,
+			min: 1
+		},
+		defaultDebitAccount: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: accountModelName,
+			default: null
+		},
+		defaultCreditAccount: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: accountModelName,
+			default: null
+		},
+		allowedPaymentMethods: {
+			type: [String],
+			default: []
+		},
+		source: {
+			type: String,
+			default: "manual"
+		},
+		active: {
+			type: Boolean,
+			default: true
+		},
+		...extraFields
+	};
+	if (multiTenant) fields[multiTenant.orgField] = {
+		type: mongoose.Schema.Types.ObjectId,
+		ref: multiTenant.orgRef,
+		required: true
+	};
+	const schema = new mongoose.Schema(fields, { timestamps: true });
+	if (indexes) {
+		const org = multiTenant?.orgField;
+		if (org) {
+			schema.index({
+				[org]: 1,
+				code: 1
+			}, { unique: true });
+			schema.index({
+				[org]: 1,
+				kind: 1,
+				active: 1
+			});
+		} else {
+			schema.index({ code: 1 }, { unique: true });
+			schema.index({
+				kind: 1,
+				active: 1
+			});
+		}
+	}
+	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
+	return schema;
+}
+//#endregion
 //#region src/schemas/journal-entry.schema.ts
 /**
 * Journal Entry Schema Factory
@@ -308,17 +423,19 @@ function createJournalEntrySchema(config, accountModelName, options = {}) {
 				message: "exchangeRate must be greater than zero when set, got {VALUE}"
 			}
 		};
+		const originalAmountValidator = {
+			validator: (v) => v === null || v === void 0 || Number.isInteger(v) && v >= 0,
+			message: "{PATH} must be a non-negative integer (cents), got {VALUE}"
+		};
 		currencyItemFields.originalDebit = {
 			type: Number,
 			default: null,
-			min: 0,
-			validate: amountValidator
+			validate: originalAmountValidator
 		};
 		currencyItemFields.originalCredit = {
 			type: Number,
 			default: null,
-			min: 0,
-			validate: amountValidator
+			validate: originalAmountValidator
 		};
 	}
 	const JournalItemSchema = new mongoose.Schema({
@@ -345,6 +462,14 @@ function createJournalEntrySchema(config, accountModelName, options = {}) {
 			type: [TaxDetailSchema],
 			default: []
 		},
+		matchingNumber: {
+			type: String,
+			default: null
+		},
+		maturityDate: {
+			type: Date,
+			default: null
+		},
 		...currencyItemFields,
 		...extraItemFields
 	}, { _id: false });
@@ -356,6 +481,10 @@ function createJournalEntrySchema(config, accountModelName, options = {}) {
 			default: JOURNAL_CODES.MISC,
 			required: true
 		},
+		journal: {
+			type: mongoose.Schema.Types.ObjectId,
+			default: null
+		},
 		referenceNumber: { type: String },
 		label: { type: String },
 		date: {
@@ -572,6 +701,11 @@ function createJournalEntrySchema(config, accountModelName, options = {}) {
 			});
 		}
 		schema.index({ reversed: 1 });
+		if (org) schema.index({
+			[org]: 1,
+			"journalItems.matchingNumber": 1
+		});
+		else schema.index({ "journalItems.matchingNumber": 1 });
 		if (config.idempotency) {
 			const idempotencyIdx = {};
 			if (org) idempotencyIdx[org] = 1;
@@ -601,50 +735,112 @@ function createJournalEntrySchema(config, accountModelName, options = {}) {
 //#endregion
 //#region src/schemas/reconciliation.schema.ts
 /**
-* Reconciliation Schema Factory
+* Reconciliation Schema Factory (0.6.0 — item-level open-item matching)
+*
+* A reconciliation is a **matching group** of journal items that together
+* settle each other in whole or in part. Each group carries a stable
+* `matchingNumber` string that is stamped onto every referenced journal
+* item. A group is `isFullReconcile = true` iff debit/credit totals
+* balance to zero — partial matches (a cheque paying 2 of 3 invoices) are
+* represented by isFullReconcile=false.
 *
-* Creates a Mongoose schema for reconciliation records that link matched
-* debit/credit journal items. Used to track which journal entries have been
-* reconciled against each other for a given account.
+* This replaces 0.5.x entry-level reconciliation, which could not represent
+* the canonical AR/AP flow where one cheque covers multiple invoices or
+* one invoice is paid by multiple cheques.
+*
+* A dedicated collection exists so that match/unmatch can atomically stamp
+* `journalItems[i].matchingNumber`, update totals, and trigger the
+* fxRealizationPlugin via mongokit hooks — without bumping the entries'
+* `updatedAt` timestamps.
 */
 function createReconciliationSchema(config, accountModelName, journalEntryModelName, options = {}) {
 	const { multiTenant } = config;
 	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
+	const MatchedItemRefSchema = new mongoose.Schema({
+		entry: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: journalEntryModelName,
+			required: true
+		},
+		itemIndex: {
+			type: Number,
+			required: true,
+			min: 0,
+			validate: {
+				validator: Number.isInteger,
+				message: "itemIndex must be a non-negative integer"
+			}
+		},
+		debit: {
+			type: Number,
+			default: 0,
+			min: 0
+		},
+		credit: {
+			type: Number,
+			default: 0,
+			min: 0
+		},
+		amountCurrency: {
+			type: Number,
+			default: null
+		},
+		exchangeRate: {
+			type: Number,
+			default: null
+		}
+	}, { _id: false });
 	const fields = {
+		matchingNumber: {
+			type: String,
+			required: true
+		},
 		account: {
 			type: mongoose.Schema.Types.ObjectId,
 			ref: accountModelName,
 			required: true
 		},
-		journalEntryIds: {
-			type: [{
-				type: mongoose.Schema.Types.ObjectId,
-				ref: journalEntryModelName
-			}],
+		items: {
+			type: [MatchedItemRefSchema],
 			required: true,
 			validate: {
-				validator: (v) => Array.isArray(v) && v.length > 0,
-				message: "journalEntryIds must contain at least one entry."
+				validator: (v) => Array.isArray(v) && v.length >= 2,
+				message: "a reconciliation must reference at least two items"
 			}
 		},
 		debitTotal: {
 			type: Number,
-			required: true
+			required: true,
+			min: 0
 		},
 		creditTotal: {
 			type: Number,
-			required: true
+			required: true,
+			min: 0
 		},
 		difference: {
 			type: Number,
 			default: 0
 		},
+		isFullReconcile: {
+			type: Boolean,
+			default: false
+		},
+		currency: {
+			type: String,
+			default: null
+		},
 		note: { type: String },
 		reconciledBy: { type: String },
 		reconciledAt: {
 			type: Date,
 			default: Date.now
 		},
+		fxRealizationEntry: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: journalEntryModelName,
+			default: null
+		},
 		...extraFields
 	};
 	if (multiTenant) fields[multiTenant.orgField] = {
@@ -654,18 +850,31 @@ function createReconciliationSchema(config, accountModelName, journalEntryModelN
 	};
 	const schema = new mongoose.Schema(fields, { timestamps: true });
 	if (indexes) {
-		if (multiTenant) {
-			const org = multiTenant.orgField;
+		const org = multiTenant?.orgField;
+		if (org) {
+			schema.index({
+				[org]: 1,
+				matchingNumber: 1
+			}, { unique: true });
 			schema.index({
 				[org]: 1,
 				account: 1,
+				isFullReconcile: 1,
 				reconciledAt: 1
 			});
-		} else schema.index({
-			account: 1,
-			reconciledAt: 1
-		});
-		schema.index({ journalEntryIds: 1 });
+			schema.index({
+				[org]: 1,
+				"items.entry": 1
+			});
+		} else {
+			schema.index({ matchingNumber: 1 }, { unique: true });
+			schema.index({
+				account: 1,
+				isFullReconcile: 1,
+				reconciledAt: 1
+			});
+			schema.index({ "items.entry": 1 });
+		}
 	}
 	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
 	return schema;
@@ -678,33 +887,29 @@ function resolveModelNames(overrides) {
 		journalEntry: overrides?.journalEntry ?? "JournalEntry",
 		fiscalPeriod: overrides?.fiscalPeriod ?? "FiscalPeriod",
 		budget: overrides?.budget ?? "Budget",
-		reconciliation: overrides?.reconciliation ?? "Reconciliation"
+		reconciliation: overrides?.reconciliation ?? "Reconciliation",
+		journal: overrides?.journal ?? "Journal"
 	};
 }
-/**
-* Create (or reuse) all ledger models on the given connection.
-*
-* If a model with the same name is already registered on the connection,
-* the existing model is reused — this allows multiple engine instances
-* to share models and prevents "OverwriteModelError".
-*/
 function createModels(connection, config) {
 	const names = resolveModelNames(config.modelNames);
 	const so = config.schemaOptions ?? {};
 	const existing = connection.models;
-	if (existing[names.account] && existing[names.journalEntry] && existing[names.fiscalPeriod] && existing[names.budget] && existing[names.reconciliation]) return {
+	if (existing[names.account] && existing[names.journalEntry] && existing[names.fiscalPeriod] && existing[names.budget] && existing[names.reconciliation] && existing[names.journal]) return {
 		Account: existing[names.account],
 		JournalEntry: existing[names.journalEntry],
 		FiscalPeriod: existing[names.fiscalPeriod],
 		Budget: existing[names.budget],
-		Reconciliation: existing[names.reconciliation]
+		Reconciliation: existing[names.reconciliation],
+		Journal: existing[names.journal]
 	};
 	return {
 		Account: existing[names.account] ?? connection.model(names.account, createAccountSchema(config, so.account)),
 		JournalEntry: existing[names.journalEntry] ?? connection.model(names.journalEntry, createJournalEntrySchema(config, names.account, so.journalEntry)),
 		FiscalPeriod: existing[names.fiscalPeriod] ?? connection.model(names.fiscalPeriod, createFiscalPeriodSchema(config, so.fiscalPeriod)),
 		Budget: existing[names.budget] ?? connection.model(names.budget, createBudgetSchema(config, so.budget)),
-		Reconciliation: existing[names.reconciliation] ?? connection.model(names.reconciliation, createReconciliationSchema(config, names.account, names.journalEntry, so.reconciliation))
+		Reconciliation: existing[names.reconciliation] ?? connection.model(names.reconciliation, createReconciliationSchema(config, names.account, names.journalEntry, so.reconciliation)),
+		Journal: existing[names.journal] ?? connection.model(names.journal, createJournalSchema(config, names.account, so.journal))
 	};
 }
 //#endregion
@@ -901,6 +1106,104 @@ function wireAccountMethods(repository, AccountModel, country, orgField) {
 	return repository;
 }
 //#endregion
+//#region src/repositories/journal.repository.ts
+/**
+* Lean default set used when a country pack doesn't provide
+* `journalTemplates`. Covers the Stripe/QuickBooks/Xero baseline.
+*/
+const DEFAULT_TEMPLATES = [
+	{
+		code: "SALES",
+		name: "Sales",
+		journalType: "SALES",
+		kind: "sale",
+		sequencePrefix: "INV"
+	},
+	{
+		code: "PURCHASE",
+		name: "Purchases",
+		journalType: "PURCHASES",
+		kind: "purchase",
+		sequencePrefix: "BILL"
+	},
+	{
+		code: "BANK",
+		name: "Bank",
+		journalType: "CASH_RECEIPTS",
+		kind: "bank",
+		sequencePrefix: "BNK"
+	},
+	{
+		code: "CASH",
+		name: "Cash",
+		journalType: "CASH_PAYMENTS",
+		kind: "cash",
+		sequencePrefix: "CSH"
+	},
+	{
+		code: "MISC",
+		name: "Miscellaneous",
+		journalType: "MISC",
+		kind: "general",
+		sequencePrefix: "JE"
+	}
+];
+function wireJournalMethods(repository, country, orgField) {
+	const create = repository.create.bind(repository);
+	const exists = repository.exists.bind(repository);
+	repository.seedDefaults = async (orgId) => {
+		requireOrgScope(orgField, orgId);
+		const templates = country.journalTemplates ?? DEFAULT_TEMPLATES;
+		let created = 0;
+		let skipped = 0;
+		for (const tpl of templates) {
+			const existingQuery = { code: tpl.code };
+			if (orgField && orgId != null) existingQuery[orgField] = orgId;
+			if (await exists(existingQuery)) {
+				skipped += 1;
+				continue;
+			}
+			const data = {
+				code: tpl.code,
+				name: tpl.name,
+				journalType: tpl.journalType,
+				kind: tpl.kind ?? "general",
+				sequencePrefix: tpl.sequencePrefix ?? tpl.code,
+				sequenceNextNum: tpl.sequenceStartNum ?? 1,
+				active: true
+			};
+			if (orgField && orgId != null) data[orgField] = orgId;
+			await create(data);
+			created += 1;
+		}
+		return {
+			created,
+			skipped
+		};
+	};
+	repository.nextSequenceNumber = async (journalId, orgId) => {
+		requireOrgScope(orgField, orgId);
+		const query = { _id: journalId };
+		if (orgField && orgId != null) query[orgField] = orgId;
+		const updated = await repository._executeQuery(async (Model) => Model.findOneAndUpdate(query, { $inc: { sequenceNextNum: 1 } }, { returnDocument: "after" }).lean());
+		if (!updated) throw Errors.notFound(`Journal ${String(journalId)} not found`);
+		const next = (updated.sequenceNextNum ?? 1) - 1;
+		const prefix = updated.sequencePrefix ?? updated.code ?? "JE";
+		const now = /* @__PURE__ */ new Date();
+		return `${prefix}/${now.getFullYear()}/${String(now.getMonth() + 1).padStart(2, "0")}/${String(next).padStart(4, "0")}`;
+	};
+	if (typeof repository.registerMethod === "function") for (const name of ["seedDefaults", "nextSequenceNumber"]) {
+		const fn = repository[name];
+		try {
+			delete repository[name];
+			repository.registerMethod(name, fn);
+		} catch {
+			repository[name] = fn;
+		}
+	}
+	return repository;
+}
+//#endregion
 //#region src/repositories/journal-entry.repository.ts
 /** Keys that are either handled explicitly or must not be copied */
 const ITEM_CORE_KEYS = new Set([
@@ -1204,91 +1507,186 @@ function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, stric
 //#endregion
 //#region src/repositories/reconciliation.repository.ts
 /**
-* Wire reconciliation methods onto an existing mongokit Repository.
-*
-* - reconcile() uses repository.create() so hooks (multi-tenant, audit) fire
-* - unreconcile() uses repository.delete() so hooks fire
-* - Cross-repo reads (JournalEntryModel) use direct Model access (acceptable)
+* Default matching-number generator — atomic counter stored in the
+* reconciliation collection. Uses a dedicated sentinel document keyed
+* `{ matchingNumber: '__counter__', [org]: orgId }` so each org has its
+* own counter, safe under concurrent match calls.
 */
-function wireReconciliationMethods(repository, _ReconciliationModel, JournalEntryModel, orgField) {
+async function nextMatchingNumber(ReconciliationModel, orgField, orgId, session) {
+	const counterQuery = { matchingNumber: "__counter__" };
+	if (orgField && orgId != null) counterQuery[orgField] = orgId;
+	const seq = (await ReconciliationModel.findOneAndUpdate(counterQuery, {
+		$inc: { seq: 1 },
+		$setOnInsert: {
+			account: null,
+			items: [{
+				entry: null,
+				itemIndex: 0
+			}, {
+				entry: null,
+				itemIndex: 1
+			}],
+			debitTotal: 0,
+			creditTotal: 0
+		}
+	}, {
+		new: true,
+		upsert: true,
+		session,
+		strict: false
+	}).lean())?.seq ?? 1;
+	return `RECN-${String(seq).padStart(6, "0")}`;
+}
+function wireReconciliationMethods(repository, ReconciliationModel, JournalEntryModel, orgField) {
 	const create = repository.create.bind(repository);
 	const deleteById = repository.delete.bind(repository);
-	/**
-	* Create a reconciliation record linking matched journal entries.
-	* Validates that all entries exist, are posted, and belong to the same account/org.
-	*/
-	repository.reconcile = async (input) => {
-		const { account, journalEntryIds, note, reconciledBy, organizationId } = input;
+	const repoInstance = repository;
+	repository.match = async (input) => {
+		const { account, items, note, reconciledBy, organizationId, session = null } = input;
+		let { matchingNumber } = input;
 		requireOrgScope(orgField, organizationId);
-		if (!journalEntryIds || journalEntryIds.length === 0) throw Errors.validation("journalEntryIds must contain at least one entry.");
-		const query = { _id: { $in: journalEntryIds } };
-		if (orgField && organizationId != null) query[orgField] = organizationId;
-		const entries = await JournalEntryModel.find(query).lean();
-		if (entries.length !== journalEntryIds.length) throw Errors.notFound(`Expected ${journalEntryIds.length} entries but found ${entries.length}. Some entries do not exist or belong to a different organization.`);
-		const notPosted = entries.filter((e) => e.state !== "posted");
-		if (notPosted.length > 0) throw Errors.validation(`${notPosted.length} entry(ies) are not posted. Only posted entries can be reconciled.`);
+		if (!Array.isArray(items) || items.length < 2) throw Errors.validation("match() requires at least two items");
+		const entryIds = Array.from(new Set(items.map((i) => String(i.entry))));
+		const entryQuery = { _id: { $in: entryIds } };
+		if (orgField && organizationId != null) entryQuery[orgField] = organizationId;
+		const entries = await JournalEntryModel.find(entryQuery).session(session).lean();
+		if (entries.length !== entryIds.length) throw Errors.notFound(`Expected ${entryIds.length} entries but found ${entries.length}. Some do not exist or belong to a different organization.`);
+		const entryMap = /* @__PURE__ */ new Map();
+		for (const e of entries) entryMap.set(String(e._id), e);
 		const accountStr = String(account);
-		for (const entry of entries) if (!entry.journalItems.some((item) => String(item.account) === accountStr)) throw Errors.validation(`Entry ${entry._id} does not contain any items for account ${account}.`);
 		let debitTotal = 0;
 		let creditTotal = 0;
-		for (const entry of entries) for (const item of entry.journalItems) if (String(item.account) === accountStr) {
-			debitTotal += item.debit ?? 0;
-			creditTotal += item.credit ?? 0;
+		const currencies = /* @__PURE__ */ new Set();
+		const itemSnapshots = [];
+		for (const ref of items) {
+			const entry = entryMap.get(String(ref.entry));
+			if (!entry) throw Errors.notFound(`Entry ${String(ref.entry)} not found in match input`);
+			if (entry.state !== "posted") throw Errors.validation(`Entry ${String(entry._id)} is not posted — only posted entries can be matched`);
+			const item = entry.journalItems[ref.itemIndex];
+			if (!item) throw Errors.validation(`Entry ${String(entry._id)} has no item at index ${ref.itemIndex}`);
+			if (String(item.account) !== accountStr) throw Errors.validation(`Item ${String(entry._id)}[${ref.itemIndex}] is on a different account than the match`);
+			if (item.matchingNumber) throw Errors.conflict(`Item ${String(entry._id)}[${ref.itemIndex}] is already matched (${item.matchingNumber})`);
+			const debit = item.debit ?? 0;
+			const credit = item.credit ?? 0;
+			debitTotal += debit;
+			creditTotal += credit;
+			if (item.currency) currencies.add(item.currency);
+			const amountCurrency = item.originalDebit != null || item.originalCredit != null ? (item.originalDebit ?? 0) - (item.originalCredit ?? 0) : null;
+			itemSnapshots.push({
+				entry: entry._id,
+				itemIndex: ref.itemIndex,
+				debit,
+				credit,
+				amountCurrency,
+				exchangeRate: item.exchangeRate ?? null
+			});
 		}
+		const difference = debitTotal - creditTotal;
+		const isFullReconcile = difference === 0;
+		const sharedCurrency = currencies.size === 1 ? Array.from(currencies)[0] : null;
+		if (!matchingNumber) matchingNumber = await nextMatchingNumber(ReconciliationModel, orgField, organizationId, session);
+		const bulkOps = itemSnapshots.map((snap) => ({ updateOne: {
+			filter: { _id: snap.entry },
+			update: { $set: { [`journalItems.${snap.itemIndex}.matchingNumber`]: matchingNumber } }
+		} }));
+		await JournalEntryModel.bulkWrite(bulkOps, { session: session ?? void 0 });
 		const reconciliationData = {
+			matchingNumber,
 			account,
-			journalEntryIds,
+			items: itemSnapshots.map((s) => ({
+				entry: s.entry,
+				itemIndex: s.itemIndex,
+				debit: s.debit,
+				credit: s.credit,
+				amountCurrency: s.amountCurrency,
+				exchangeRate: s.exchangeRate
+			})),
 			debitTotal,
 			creditTotal,
-			difference: debitTotal - creditTotal,
+			difference,
+			isFullReconcile,
+			currency: sharedCurrency,
 			note,
 			reconciledBy,
 			reconciledAt: /* @__PURE__ */ new Date()
 		};
 		if (orgField && organizationId != null) reconciliationData[orgField] = organizationId;
-		return await create(reconciliationData);
+		const record = await create(reconciliationData);
+		const emit = repoInstance._emitHook;
+		if (emit) await emit.call(repoInstance, "after:match", {
+			reconciliation: record,
+			items: itemSnapshots,
+			sharedCurrency,
+			session
+		});
+		return record;
 	};
-	/**
-	* Remove a reconciliation record via repository.delete().
-	*/
-	repository.unreconcile = async (input) => {
-		const { reconciliationId, organizationId } = input;
+	repository.unmatch = async (input) => {
+		const { matchingNumber, organizationId, session = null } = input;
 		requireOrgScope(orgField, organizationId);
-		if (orgField && organizationId != null) {
-			if (!await repository._executeQuery(async (Model) => Model.findOne({
-				_id: reconciliationId,
-				[orgField]: organizationId
-			}).select("_id").lean())) throw Errors.notFound("Reconciliation record not found.");
-		}
-		const result = await deleteById(String(reconciliationId));
-		if (!result.success) throw Errors.notFound("Reconciliation record not found.");
+		const query = { matchingNumber };
+		if (orgField && organizationId != null) query[orgField] = organizationId;
+		const existing = await ReconciliationModel.findOne(query).session(session).lean();
+		if (!existing) throw Errors.notFound(`Reconciliation ${matchingNumber} not found`);
+		const bulkOps = (existing.items ?? []).map((it) => ({ updateOne: {
+			filter: { _id: it.entry },
+			update: { $set: { [`journalItems.${it.itemIndex}.matchingNumber`]: null } }
+		} }));
+		if (bulkOps.length > 0) await JournalEntryModel.bulkWrite(bulkOps, { session: session ?? void 0 });
+		const result = await deleteById(String(existing._id));
+		if (!result.success) throw Errors.notFound("Failed to delete reconciliation record");
 		return result;
 	};
-	/**
-	* Find journal entries for an account that are NOT in any reconciliation record.
-	* Uses repository.getAll() for reconciliation lookups (hooks fire),
-	* and direct JournalEntryModel for cross-repo reads (acceptable).
-	*/
-	repository.getUnreconciled = async (input) => {
-		const { accountId, organizationId, limit = 100, skip = 0 } = input;
+	repository.getOpenItems = async (params) => {
+		const { accountId, organizationId, filter, asOfDate, limit = 100, skip = 0 } = params;
 		requireOrgScope(orgField, organizationId);
-		const reconFilter = { account: accountId };
-		if (orgField && organizationId != null) reconFilter[orgField] = organizationId;
-		const reconciliations = await repository._executeQuery(async (Model) => Model.find(reconFilter).select("journalEntryIds").lean());
-		const reconciledIds = /* @__PURE__ */ new Set();
-		for (const rec of reconciliations) for (const id of rec.journalEntryIds) reconciledIds.add(String(id));
-		const entryFilter = {
-			state: "posted",
-			"journalItems.account": accountId
-		};
-		if (orgField && organizationId != null) entryFilter[orgField] = organizationId;
-		if (reconciledIds.size > 0) entryFilter._id = { $nin: Array.from(reconciledIds) };
-		return await JournalEntryModel.find(entryFilter).sort({ date: -1 }).skip(skip).limit(limit).lean();
+		const match = { state: "posted" };
+		if (orgField && organizationId != null) match[orgField] = organizationId;
+		if (asOfDate) match.date = { $lte: asOfDate };
+		const pipeline = [
+			{ $match: match },
+			{ $project: {
+				_id: 1,
+				date: 1,
+				referenceNumber: 1,
+				journalItems: 1
+			} },
+			{ $addFields: { journalItems: { $map: {
+				input: { $range: [0, { $size: "$journalItems" }] },
+				as: "idx",
+				in: { $mergeObjects: [{ $arrayElemAt: ["$journalItems", "$$idx"] }, { _itemIndex: "$$idx" }] }
+			} } } },
+			{ $unwind: "$journalItems" },
+			{ $match: {
+				"journalItems.account": accountId,
+				$or: [{ "journalItems.matchingNumber": null }, { "journalItems.matchingNumber": { $exists: false } }],
+				...filter ? Object.fromEntries(Object.entries(filter).map(([k, v]) => [`journalItems.${k}`, v])) : {}
+			} },
+			{ $project: {
+				_id: 0,
+				entry: "$_id",
+				itemIndex: "$journalItems._itemIndex",
+				debit: { $ifNull: ["$journalItems.debit", 0] },
+				credit: { $ifNull: ["$journalItems.credit", 0] },
+				date: { $ifNull: ["$journalItems.date", "$date"] },
+				maturityDate: "$journalItems.maturityDate",
+				account: "$journalItems.account",
+				currency: "$journalItems.currency",
+				exchangeRate: "$journalItems.exchangeRate",
+				label: "$journalItems.label",
+				referenceNumber: 1,
+				item: "$journalItems"
+			} },
+			{ $sort: { date: 1 } },
+			{ $skip: skip },
+			{ $limit: limit }
+		];
+		return await JournalEntryModel.aggregate(pipeline);
 	};
 	if (typeof repository.registerMethod === "function") for (const name of [
-		"reconcile",
-		"unreconcile",
-		"getUnreconciled"
+		"match",
+		"unmatch",
+		"getOpenItems"
 	]) {
 		const fn = repository[name];
 		try {
@@ -1347,12 +1745,18 @@ function createRepositories(models, config, plugins = {}, pagination = {}) {
 		JournalEntryModel: models.JournalEntry,
 		orgField
 	}));
+	const journalEntries = wireJournalEntryMethods(new Repository(models.JournalEntry, jePlugins, jePagination), models.JournalEntry, orgField, strictness);
+	const fiscalPeriods = new Repository(models.FiscalPeriod, plugins.fiscalPeriod ?? [], fpPagination);
+	const budgets = new Repository(models.Budget, plugins.budget ?? [], budgetPagination);
+	const reconciliations = wireReconciliationMethods(new Repository(models.Reconciliation, plugins.reconciliation ?? [], reconPagination), models.Reconciliation, models.JournalEntry, orgField);
+	const journalPagination = pagination.journal ?? {};
 	return {
 		accounts,
-		journalEntries: wireJournalEntryMethods(new Repository(models.JournalEntry, jePlugins, jePagination), models.JournalEntry, orgField, strictness),
-		fiscalPeriods: new Repository(models.FiscalPeriod, plugins.fiscalPeriod ?? [], fpPagination),
-		budgets: new Repository(models.Budget, plugins.budget ?? [], budgetPagination),
-		reconciliations: wireReconciliationMethods(new Repository(models.Reconciliation, plugins.reconciliation ?? [], reconPagination), models.Reconciliation, models.JournalEntry, orgField)
+		journalEntries,
+		fiscalPeriods,
+		budgets,
+		reconciliations,
+		journals: wireJournalMethods(new Repository(models.Journal, plugins.journal ?? [], journalPagination), country, orgField)
 	};
 }
 //#endregion
@@ -2046,6 +2450,68 @@ function createAccountingEngine(config) {
 	return new AccountingEngine(config);
 }
 //#endregion
+//#region src/utils/repartition-tax.ts
+/**
+* Default role resolver used when the country pack doesn't override.
+* Walks `taxCodes` to find a code whose `direction` matches the role.
+*/
+function defaultResolveRoleCode(role, _tax, country) {
+	const direction = role === "collected" ? "collected" : role === "recoverable" ? "recoverable" : null;
+	if (!direction) return void 0;
+	for (const tc of Object.values(country.taxCodes)) if (tc.direction === direction) return tc.code;
+}
+/**
+* Build a `TaxLineGenerator` that expands each hit `taxCode` into one
+* journal item per repartition line. Taxes without `repartition` fall
+* back to a single-line generator using the direction-implied account.
+*/
+function createRepartitionTaxGenerator(options) {
+	const { country, resolveAccount, documentType = "invoice" } = options;
+	return { generateTaxLines(input) {
+		const code = input.taxCode;
+		if (!code) return [];
+		const tax = country.taxCodes[code];
+		if (!tax) return [];
+		const baseTax = Math.round(input.amount * tax.rate / 100);
+		if (baseTax === 0) return [];
+		const lines = tax.repartition && tax.repartition.length > 0 ? tax.repartition.filter((line) => !line.documentTypes || line.documentTypes.includes(documentType)) : [{
+			factor: 1,
+			accountRole: tax.direction === "recoverable" ? "recoverable" : "collected",
+			gridCode: tax.reportLines?.[0]
+		}];
+		const generated = [];
+		for (const rep of lines) {
+			const signed = Math.round(baseTax * rep.factor);
+			if (signed === 0) continue;
+			const account = resolveAccount(rep.accountRole, tax, input);
+			if (!account) throw new Error(`repartitionTax: cannot resolve account for role "${rep.accountRole}" on tax "${tax.code}"`);
+			const absAmount = Math.abs(signed);
+			let onCredit = rep.accountRole === "collected" || rep.accountRole === "transition";
+			if (signed < 0) onCredit = !onCredit;
+			generated.push({
+				account,
+				debit: onCredit ? 0 : absAmount,
+				credit: onCredit ? absAmount : 0,
+				label: rep.label ?? `${tax.name} ${rep.accountRole}`,
+				taxDetails: [{
+					taxCode: tax.code,
+					taxName: tax.name,
+					...rep.gridCode != null ? { gridCode: String(rep.gridCode) } : {}
+				}]
+			});
+		}
+		return generated;
+	} };
+}
+/**
+* Helper for packs that want the standard "role → account-type code"
+* mapping without writing their own resolver. Returns the function you
+* stuff into `CountryPackInput.resolveTaxRepartitionAccountCode`.
+*/
+function defaultResolveTaxRepartitionAccountCode(country) {
+	return (role, tax) => defaultResolveRoleCode(role, tax, country);
+}
+//#endregion
 //#region src/utils/dimensions.ts
 /**
 * Analytic Dimensions — Helpers for defining analytic dimensions
@@ -2105,4 +2571,4 @@ function buildDimensionIndexes(dimensions, orgField) {
 	});
 }
 //#endregion
-export { AccountingEngine, AccountingError, CATEGORIES, CATEGORY_KEYS, CURRENCIES, DEFAULT_BUCKETS, Errors, JOURNAL_CODES, JOURNAL_TYPES, Money, acquireSession, add, allocate, buildAccountTypeMap, buildDimensionFields, buildDimensionIndexes, buildItemFilters, buildRevaluationEntry, calculateTotal, closeFiscalPeriod, computeEndingBalance, computeRevaluation, createAccountingEngine, createModels, createRepositories, dateLockPlugin, defaultLogger, defineCountryPack, doubleEntryPlugin, exportToCsv, finalizeSession, fiscalLockPlugin, flattenJournalEntries, format, formatPlain, fromDecimal, generateAgedBalance, generateBalanceSheet, generateBudgetVsActual, generateCashFlow, generateDimensionBreakdown, generateGeneralLedger, generateIncomeStatement, generateRevaluation, generateTrialBalance, getCurrency, getCustomJournalTypes, getDateRange, getFiscalYearStart, getJournalType, getJournalTypeCodes, getMinorUnit, getNormalBalance, idempotencyPlugin, isBalanceSheet, isIncomeStatement, isValidCategory, isValidCurrency, isValidJournalType, isVirtualTaxAccount, multiply, parseCents, percentage, quickbooksFieldMap, registerJournalType, reopenFiscalPeriod, resolveModelNames, splitTaxExclusive, splitTaxInclusive, subtract, toDecimal, universalFieldMap };
+export { AccountingEngine, AccountingError, CATEGORIES, CATEGORY_KEYS, CURRENCIES, DEFAULT_BUCKETS, Errors, JOURNAL_CODES, JOURNAL_TYPES, Money, acquireSession, add, allocate, buildAccountTypeMap, buildDimensionFields, buildDimensionIndexes, buildItemFilters, buildRevaluationEntry, calculateTotal, closeFiscalPeriod, computeEndingBalance, computeRevaluation, createAccountingEngine, createLockPlugin, createModels, createRepartitionTaxGenerator, createRepositories, creditLimitPlugin, dailyLockPlugin, defaultLogger, defaultResolveTaxRepartitionAccountCode, defineCountryPack, doubleEntryPlugin, exportToCsv, finalizeSession, fiscalLockPlugin, flattenJournalEntries, format, formatPlain, fromDecimal, fxRealizationPlugin, generateAgedBalance, generateBalanceSheet, generateBudgetVsActual, generateCashFlow, generateDimensionBreakdown, generateGeneralLedger, generateIncomeStatement, generatePartnerLedger, generateRevaluation, generateTrialBalance, getCurrency, getCustomJournalTypes, getDateRange, getFiscalYearStart, getJournalType, getJournalTypeCodes, getMinorUnit, getNormalBalance, idempotencyPlugin, isBalanceSheet, isIncomeStatement, isValidCategory, isValidCurrency, isValidJournalType, isVirtualTaxAccount, multiply, parseCents, percentage, periodResolver, quickbooksFieldMap, registerJournalType, reopenFiscalPeriod, resolveModelNames, splitTaxExclusive, splitTaxInclusive, subtract, taxLockPlugin, toDecimal, universalFieldMap, watermarkResolver };