@classytic/ledger 0.4.2 → 0.5.0

package/dist/index.mjs

@@ -1,16 +1,676 @@
-import { a as createAccountSchema, i as createBudgetSchema, n as createJournalEntrySchema, r as createFiscalPeriodSchema, t as createReconciliationSchema } from "./reconciliation.schema-BA1lPv4t.mjs";
-import { a as getJournalType, c as registerJournalType, i as getCustomJournalTypes, n as JOURNAL_TYPES, o as getJournalTypeCodes, s as isValidJournalType, t as JOURNAL_CODES } from "./journals-BfwnCFam.mjs";
+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-B_dyYZc_.mjs";
-import { i as doubleEntryPlugin, n as idempotencyPlugin, r as fiscalLockPlugin, t as dateLockPlugin } from "./date-lock.plugin-DL6pe24p.mjs";
-import { C as DEFAULT_BUCKETS, S as isVirtualTaxAccount, _ 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-B2_7WMTe.mjs";
-import { c as getNormalBalance, d as isValidCategory, l as isBalanceSheet, n as CATEGORY_KEYS, t as CATEGORIES, u as isIncomeStatement } from "./categories-DWogBUgQ.mjs";
-import { n as wireJournalEntryMethods, r as wireAccountMethods, t as wireReconciliationMethods } from "./reconciliation.repository-fPwFKvrk.mjs";
-import { i as isValidCurrency, n as getCurrency, r as getMinorUnit, t as CURRENCIES } from "./currencies-W8kQAkm0.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 { 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-B2Jy0ukX.mjs";
 import { defineCountryPack } from "./country/index.mjs";
-import { a as exportToCsv, i as quickbooksFieldMap, r as universalFieldMap, t as flattenJournalEntries } from "./exports-DoGQQtMQ.mjs";
-import { Schema } from "mongoose";
+import { a as exportToCsv, i as quickbooksFieldMap, r as universalFieldMap, t as flattenJournalEntries } from "./exports-BP-0Ni5W.mjs";
+import mongoose, { Schema } from "mongoose";
 import { Repository } from "@classytic/mongokit";
+//#region src/schemas/currency-field.ts
+/**
+* Build the Mongoose currency field definition.
+* Returns `null` if multi-currency is not enabled.
+*/
+function buildCurrencyField(config) {
+	if (!config.multiCurrency?.enabled) return null;
+	const allowed = config.multiCurrency.currencies;
+	return {
+		type: String,
+		default: null,
+		...allowed?.length ? { enum: [
+			null,
+			config.currency,
+			...allowed
+		] } : {}
+	};
+}
+//#endregion
+//#region src/schemas/account.schema.ts
+/**
+* Account Schema Factory
+*
+* Creates a Mongoose schema for Chart of Accounts that is:
+* - Multi-tenant aware (adds org field + compound indexes when configured)
+* - Validates accountTypeCode against the country pack
+* - Supports accountNumber (unique per org) and name (user-facing display)
+* - Lean: no cached balances — always computed from journal entries
+*/
+function createAccountSchema(config, options = {}) {
+	const { multiTenant, country } = config;
+	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
+	const fields = {
+		accountTypeCode: {
+			type: String,
+			required: true,
+			validate: {
+				validator: (code) => country.isValidAccountType(code),
+				message: (props) => `"${props.value}" is not a valid account type code for ${country.name}.`
+			}
+		},
+		accountNumber: {
+			type: String,
+			required: true,
+			trim: true
+		},
+		name: {
+			type: String,
+			required: true,
+			trim: true
+		},
+		active: {
+			type: Boolean,
+			default: true
+		},
+		isCashAccount: {
+			type: Boolean,
+			default: false
+		}
+	};
+	const currencyField = buildCurrencyField(config);
+	if (currencyField) fields.currency = currencyField;
+	Object.assign(fields, extraFields);
+	if (multiTenant) fields[multiTenant.orgField] = {
+		type: mongoose.Schema.Types.ObjectId,
+		ref: multiTenant.orgRef,
+		required: true
+	};
+	const schema = new mongoose.Schema(fields, { timestamps: true });
+	schema.pre("validate", function() {
+		if (!this.accountNumber && this.accountTypeCode) this.accountNumber = this.accountTypeCode;
+		if (!this.name && this.accountTypeCode) this.name = country.getAccountType(this.accountTypeCode)?.name ?? this.accountTypeCode;
+	});
+	if (indexes) if (multiTenant) {
+		const org = multiTenant.orgField;
+		schema.index({
+			[org]: 1,
+			active: 1
+		});
+		schema.index({
+			[org]: 1,
+			accountNumber: 1
+		}, { unique: true });
+		schema.index({
+			[org]: 1,
+			accountTypeCode: 1
+		});
+	} else {
+		schema.index({ active: 1 });
+		schema.index({ accountNumber: 1 }, { unique: true });
+		schema.index({ accountTypeCode: 1 });
+	}
+	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
+	return schema;
+}
+//#endregion
+//#region src/schemas/budget.schema.ts
+/**
+* Budget Schema Factory
+*
+* Creates a Mongoose schema for budget records.
+* Each record represents a budgeted amount for an account over a specific period.
+* All monetary amounts are in integer cents.
+*/
+function createBudgetSchema(config, options = {}) {
+	const { multiTenant } = config;
+	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
+	const fields = {
+		account: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Account",
+			required: true
+		},
+		periodStart: {
+			type: Date,
+			required: true
+		},
+		periodEnd: {
+			type: Date,
+			required: true
+		},
+		amount: {
+			type: Number,
+			required: true,
+			validate: {
+				validator: (v) => Number.isInteger(v),
+				message: "amount must be an integer (cents)."
+			}
+		},
+		label: {
+			type: String,
+			default: null
+		},
+		...extraFields
+	};
+	if (multiTenant) fields[multiTenant.orgField] = {
+		type: mongoose.Schema.Types.ObjectId,
+		ref: multiTenant.orgRef,
+		required: true
+	};
+	const schema = new mongoose.Schema(fields, { timestamps: true });
+	schema.pre("validate", function() {
+		const doc = this;
+		if (doc.periodStart && doc.periodEnd && doc.periodEnd <= doc.periodStart) doc.invalidate("periodEnd", "periodEnd must be after periodStart.", doc.periodEnd, "periodEnd");
+	});
+	if (indexes) if (multiTenant) {
+		const org = multiTenant.orgField;
+		schema.index({
+			[org]: 1,
+			account: 1,
+			periodStart: 1,
+			periodEnd: 1
+		}, { unique: true });
+		schema.index({
+			[org]: 1,
+			periodStart: 1,
+			periodEnd: 1
+		});
+	} else {
+		schema.index({
+			account: 1,
+			periodStart: 1,
+			periodEnd: 1
+		}, { unique: true });
+		schema.index({
+			periodStart: 1,
+			periodEnd: 1
+		});
+	}
+	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
+	return schema;
+}
+//#endregion
+//#region src/schemas/fiscal-period.schema.ts
+/**
+* Fiscal Period Schema Factory
+*
+* Creates a Mongoose schema for tracking fiscal periods (months, quarters, years).
+* Supports closing periods to lock entries.
+*/
+function createFiscalPeriodSchema(config, options = {}) {
+	const { multiTenant } = config;
+	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
+	const fields = {
+		name: {
+			type: String,
+			required: true
+		},
+		startDate: {
+			type: Date,
+			required: true
+		},
+		endDate: {
+			type: Date,
+			required: true
+		},
+		closed: {
+			type: Boolean,
+			default: false
+		},
+		closedAt: {
+			type: Date,
+			default: null
+		},
+		closedBy: {
+			type: String,
+			default: null
+		},
+		closingEntryId: {
+			type: mongoose.Schema.Types.ObjectId,
+			default: null
+		},
+		reopenedAt: {
+			type: Date,
+			default: null
+		},
+		reopenedBy: {
+			type: String,
+			default: null
+		},
+		...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) if (multiTenant) {
+		const org = multiTenant.orgField;
+		schema.index({
+			[org]: 1,
+			startDate: 1,
+			endDate: 1
+		}, { unique: true });
+		schema.index({
+			[org]: 1,
+			closed: 1
+		});
+	} else {
+		schema.index({
+			startDate: 1,
+			endDate: 1
+		}, { unique: true });
+		schema.index({ closed: 1 });
+	}
+	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
+	schema.pre("validate", async function() {
+		const doc = this;
+		if (!doc.startDate || !doc.endDate) return;
+		const overlapQuery = {
+			_id: { $ne: doc._id },
+			startDate: { $lt: doc.endDate },
+			endDate: { $gt: doc.startDate }
+		};
+		if (multiTenant) overlapQuery[multiTenant.orgField] = doc[multiTenant.orgField];
+		const overlap = await doc.collection.findOne(overlapQuery);
+		if (overlap) {
+			const msg = `Fiscal period overlaps with existing period "${overlap.name}" (${new Date(overlap.startDate).toISOString().split("T")[0]} – ${new Date(overlap.endDate).toISOString().split("T")[0]}).`;
+			doc.invalidate("startDate", msg, doc.startDate, "overlap");
+		}
+	});
+	return schema;
+}
+//#endregion
+//#region src/schemas/journal-entry.schema.ts
+/**
+* Journal Entry Schema Factory
+*
+* Creates a Mongoose schema for double-entry journal entries.
+* - Multi-tenant aware
+* - Embedded journal items with account refs
+* - State machine: draft → posted, draft → archived
+* - Auto-generated reference numbers
+* - Double-entry validation on post
+* - Optimized indexes for high-load reporting
+*/
+function createJournalEntrySchema(config, accountModelName, options = {}) {
+	const { multiTenant } = config;
+	const { indexes = true, autoReference = true, textSearch = true, extraFields = {}, extraIndexes = [], extraItemFields = {} } = options;
+	const TaxDetailSchema = new mongoose.Schema({
+		taxCode: { type: String },
+		taxName: { type: String }
+	}, { _id: false });
+	const amountValidator = {
+		validator: (v) => Number.isInteger(v) && v >= 0,
+		message: "{PATH} must be a non-negative integer (cents), got {VALUE}"
+	};
+	const currencyItemFields = {};
+	const currencyField = buildCurrencyField(config);
+	if (currencyField) {
+		currencyItemFields.currency = currencyField;
+		currencyItemFields.exchangeRate = {
+			type: Number,
+			default: null,
+			validate: {
+				validator: (v) => v === null || v > 0,
+				message: "exchangeRate must be greater than zero when set, got {VALUE}"
+			}
+		};
+		currencyItemFields.originalDebit = {
+			type: Number,
+			default: null,
+			min: 0,
+			validate: amountValidator
+		};
+		currencyItemFields.originalCredit = {
+			type: Number,
+			default: null,
+			min: 0,
+			validate: amountValidator
+		};
+	}
+	const JournalItemSchema = new mongoose.Schema({
+		account: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: accountModelName,
+			required: true
+		},
+		label: { type: String },
+		date: { type: Date },
+		debit: {
+			type: Number,
+			default: 0,
+			min: 0,
+			validate: amountValidator
+		},
+		credit: {
+			type: Number,
+			default: 0,
+			min: 0,
+			validate: amountValidator
+		},
+		taxDetails: {
+			type: [TaxDetailSchema],
+			default: []
+		},
+		...currencyItemFields,
+		...extraItemFields
+	}, { _id: false });
+	_freezeJournalTypes();
+	const fields = {
+		journalType: {
+			type: String,
+			enum: getJournalTypeCodes(),
+			default: JOURNAL_CODES.MISC,
+			required: true
+		},
+		referenceNumber: { type: String },
+		label: { type: String },
+		date: {
+			type: Date,
+			default: Date.now,
+			required: function() {
+				return this.state !== "draft";
+			}
+		},
+		journalItems: {
+			type: [JournalItemSchema],
+			default: []
+		},
+		totalDebit: {
+			type: Number,
+			required: true,
+			min: 0,
+			validate: {
+				validator: Number.isInteger,
+				message: "totalDebit must be an integer (cents)"
+			}
+		},
+		totalCredit: {
+			type: Number,
+			required: true,
+			min: 0,
+			validate: {
+				validator: Number.isInteger,
+				message: "totalCredit must be an integer (cents)"
+			}
+		},
+		state: {
+			type: String,
+			enum: [
+				"draft",
+				"posted",
+				"archived"
+			],
+			default: "draft",
+			required: true
+		},
+		stateChangedAt: {
+			type: Date,
+			default: Date.now
+		},
+		reversed: {
+			type: Boolean,
+			default: false
+		},
+		reversedBy: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "JournalEntry",
+			default: null
+		},
+		reversalOf: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "JournalEntry",
+			default: null
+		},
+		...extraFields
+	};
+	if (config.audit?.trackActor) {
+		fields.createdBy = {
+			type: mongoose.Schema.Types.ObjectId,
+			default: null
+		};
+		fields.postedBy = {
+			type: mongoose.Schema.Types.ObjectId,
+			default: null
+		};
+		fields.reversedByUser = {
+			type: mongoose.Schema.Types.ObjectId,
+			default: null
+		};
+	}
+	if (config.strictness?.requireApproval || config.audit?.trackActor) {
+		fields.approvedBy = {
+			type: mongoose.Schema.Types.ObjectId,
+			default: null
+		};
+		fields.approvedAt = {
+			type: Date,
+			default: null
+		};
+	}
+	if (config.idempotency) fields.idempotencyKey = {
+		type: String,
+		default: null
+	};
+	if (multiTenant) fields[multiTenant.orgField] = {
+		type: mongoose.Schema.Types.ObjectId,
+		ref: multiTenant.orgRef,
+		required: true
+	};
+	const schema = new mongoose.Schema(fields, { timestamps: true });
+	schema.pre("validate", function() {
+		for (const item of this.journalItems) if (!item.date) item.date = this.date;
+		for (let i = 0; i < this.journalItems.length; i++) {
+			const d = this.journalItems[i].debit ?? 0;
+			const c = this.journalItems[i].credit ?? 0;
+			if (d > 0 && c > 0) throw new Error(`Journal item at index ${i}: cannot have both debit (${d}) and credit (${c}) greater than zero`);
+			if (this.state === "posted" && d === 0 && c === 0) throw new Error(`Journal item at index ${i}: posted entries cannot have zero-value lines (both debit and credit are 0)`);
+		}
+		const totalDebit = this.journalItems.reduce((s, item) => s + (item.debit ?? 0), 0);
+		const totalCredit = this.journalItems.reduce((s, item) => s + (item.credit ?? 0), 0);
+		if (this.state === "posted") {
+			if (this.journalItems.length < 2) throw new Error("Posted entries must have at least 2 journal items");
+			if (totalDebit !== totalCredit) throw new Error("Total debit must equal total credit for posted entries");
+		}
+		this.totalDebit = totalDebit;
+		this.totalCredit = totalCredit;
+	});
+	if (autoReference) {
+		const generateReferenceNumber = async (doc, Model, session) => {
+			const jt = doc.journalType || "MISC";
+			const d = new Date(doc.date);
+			const prefix = `${jt}/${d.getFullYear()}/${String(d.getMonth() + 1).padStart(2, "0")}/`;
+			const matchFilter = { referenceNumber: { $regex: `^${prefix.replace(/\//g, "\\/")}` } };
+			if (multiTenant) matchFilter[multiTenant.orgField] = doc[multiTenant.orgField];
+			const pipeline = [
+				{ $match: matchFilter },
+				{ $addFields: { _refSeq: { $toInt: { $arrayElemAt: [{ $split: ["$referenceNumber", "/"] }, -1] } } } },
+				{ $sort: { _refSeq: -1 } },
+				{ $limit: 1 },
+				{ $project: { _refSeq: 1 } }
+			];
+			const results = await Model.aggregate(pipeline).session(session);
+			let seq = 1;
+			if (results.length > 0 && typeof results[0]._refSeq === "number") seq = results[0]._refSeq + 1;
+			return `${prefix}${String(seq).padStart(4, "0")}`;
+		};
+		schema.pre("save", async function() {
+			if (this.isModified("journalType")) this.referenceNumber = void 0;
+			if (!this.referenceNumber) {
+				const session = this.$session?.() ?? null;
+				const Model = this.constructor;
+				this.referenceNumber = await generateReferenceNumber(this, Model, session);
+			}
+		});
+		const MAX_REF_RETRIES = 3;
+		schema.post("save", async (error, doc, next) => {
+			const mongoError = error;
+			if (mongoError.code === 11e3 && mongoError.keyPattern?.referenceNumber) {
+				const entry = doc;
+				const retryCount = entry.__refRetries ?? 0;
+				if (retryCount >= MAX_REF_RETRIES) {
+					next(/* @__PURE__ */ new Error(`Failed to generate unique reference number after ${MAX_REF_RETRIES} retries. Too many concurrent inserts for this period.`));
+					return;
+				}
+				entry.__refRetries = retryCount + 1;
+				const session = entry.$session?.() ?? null;
+				const Model = entry.constructor;
+				entry.referenceNumber = await generateReferenceNumber(entry, Model, session);
+				try {
+					await entry.save({ session });
+					next();
+				} catch (retryError) {
+					next(retryError);
+				}
+			} else next(error);
+		});
+	}
+	if (indexes) {
+		const org = multiTenant?.orgField;
+		const refPartial = { partialFilterExpression: { referenceNumber: {
+			$exists: true,
+			$type: "string"
+		} } };
+		if (org) {
+			schema.index({
+				[org]: 1,
+				referenceNumber: 1
+			}, {
+				unique: true,
+				...refPartial
+			});
+			schema.index({
+				[org]: 1,
+				state: 1,
+				date: 1
+			});
+			schema.index({
+				[org]: 1,
+				date: -1
+			});
+			schema.index({
+				[org]: 1,
+				journalType: 1
+			});
+			schema.index({
+				"journalItems.account": 1,
+				state: 1
+			});
+			schema.index({
+				[org]: 1,
+				"journalItems.account": 1,
+				date: 1,
+				state: 1
+			});
+		} else {
+			schema.index({ referenceNumber: 1 }, {
+				unique: true,
+				...refPartial
+			});
+			schema.index({
+				state: 1,
+				date: 1
+			});
+			schema.index({ date: -1 });
+			schema.index({ journalType: 1 });
+			schema.index({
+				"journalItems.account": 1,
+				state: 1
+			});
+		}
+		schema.index({ reversed: 1 });
+		if (config.idempotency) {
+			const idempotencyIdx = {};
+			if (org) idempotencyIdx[org] = 1;
+			idempotencyIdx.idempotencyKey = 1;
+			schema.index(idempotencyIdx, {
+				unique: true,
+				partialFilterExpression: { idempotencyKey: {
+					$exists: true,
+					$ne: null
+				} }
+			});
+		}
+	}
+	if (textSearch) schema.index({
+		referenceNumber: "text",
+		label: "text"
+	}, {
+		weights: {
+			referenceNumber: 10,
+			label: 5
+		},
+		name: "journal_text_idx"
+	});
+	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
+	return schema;
+}
+//#endregion
+//#region src/schemas/reconciliation.schema.ts
+/**
+* Reconciliation Schema Factory
+*
+* 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.
+*/
+function createReconciliationSchema(config, accountModelName, journalEntryModelName, options = {}) {
+	const { multiTenant } = config;
+	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
+	const fields = {
+		account: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: accountModelName,
+			required: true
+		},
+		journalEntryIds: {
+			type: [{
+				type: mongoose.Schema.Types.ObjectId,
+				ref: journalEntryModelName
+			}],
+			required: true,
+			validate: {
+				validator: (v) => Array.isArray(v) && v.length > 0,
+				message: "journalEntryIds must contain at least one entry."
+			}
+		},
+		debitTotal: {
+			type: Number,
+			required: true
+		},
+		creditTotal: {
+			type: Number,
+			required: true
+		},
+		difference: {
+			type: Number,
+			default: 0
+		},
+		note: { type: String },
+		reconciledBy: { type: String },
+		reconciledAt: {
+			type: Date,
+			default: Date.now
+		},
+		...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) {
+		if (multiTenant) {
+			const org = multiTenant.orgField;
+			schema.index({
+				[org]: 1,
+				account: 1,
+				reconciledAt: 1
+			});
+		} else schema.index({
+			account: 1,
+			reconciledAt: 1
+		});
+		schema.index({ journalEntryIds: 1 });
+	}
+	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
+	return schema;
+}
+//#endregion
 //#region src/models/factory.ts
 function resolveModelNames(overrides) {
 	return {
@@ -48,6 +708,545 @@ function createModels(connection, config) {
 	};
 }
 //#endregion
+//#region src/repositories/account.repository.ts
+/**
+* Wire seedAccounts, bulkCreate and posting-account validation
+* onto an existing mongokit Repository.
+*
+* @param repository - A mongokit Repository instance (already created)
+* @param AccountModel - The Mongoose model for accounts
+* @param country - The CountryPack for account type lookups
+* @param orgField - The multi-tenant field name (e.g. 'business')
+*/
+function wireAccountMethods(repository, AccountModel, country, orgField) {
+	repository.on("before:create", (ctx) => {
+		const code = ctx.data?.accountTypeCode;
+		if (code && !country.isPostingAccount(code)) throw Errors.validation(`Cannot create account with type "${code}" — it is a structural group or calculated total, not a posting account.`);
+	});
+	/**
+	* Seed standard posting accounts for an organization.
+	*/
+	repository.seedAccounts = async (orgId, options = {}) => {
+		requireOrgScope(orgField, orgId);
+		const postingTypes = country.getPostingAccountTypes();
+		const filter = {};
+		if (orgField && orgId != null) filter[orgField] = orgId;
+		const existing = await AccountModel.find(filter).select("accountNumber").lean();
+		const existingNumbers = new Set(existing.map((a) => a.accountNumber));
+		const toCreate = postingTypes.filter((at) => !existingNumbers.has(at.code)).map((at) => {
+			const doc = {
+				accountTypeCode: at.code,
+				accountNumber: at.code,
+				name: at.name
+			};
+			if (orgField && orgId != null) doc[orgField] = orgId;
+			return doc;
+		});
+		if (toCreate.length === 0) return {
+			created: 0,
+			skipped: existingNumbers.size
+		};
+		try {
+			return {
+				created: (await AccountModel.insertMany(toCreate, {
+					session: options.session ?? void 0,
+					ordered: false
+				})).length,
+				skipped: existingNumbers.size
+			};
+		} catch (err) {
+			const bulkError = err;
+			if (bulkError.code === 11e3 || bulkError.writeErrors) {
+				const insertedDocs = bulkError.insertedDocs ?? [];
+				return {
+					created: insertedDocs.length,
+					skipped: existingNumbers.size + (toCreate.length - insertedDocs.length)
+				};
+			}
+			throw err;
+		}
+	};
+	/**
+	* Bulk create accounts with validation and skip-if-exists logic.
+	*
+	* Uses a single batch query to check existing accounts (instead of N+1),
+	* and ordered: false on insertMany to handle concurrent race conditions
+	* gracefully (duplicate key errors on individual docs don't abort the batch).
+	*/
+	repository.bulkCreate = async (accounts, orgId) => {
+		requireOrgScope(orgField, orgId);
+		const results = {
+			created: [],
+			skipped: [],
+			errors: []
+		};
+		const validAccounts = [];
+		for (let i = 0; i < accounts.length; i++) {
+			const { accountTypeCode, accountNumber, name, active = true, isCashAccount = false } = accounts[i];
+			if (!accountTypeCode) {
+				results.errors.push({
+					index: i,
+					reason: "accountTypeCode is required"
+				});
+				continue;
+			}
+			const at = country.getAccountType(accountTypeCode);
+			if (!at) {
+				results.errors.push({
+					index: i,
+					accountTypeCode,
+					reason: "Invalid account type code"
+				});
+				continue;
+			}
+			if (!country.isPostingAccount(accountTypeCode)) {
+				results.errors.push({
+					index: i,
+					accountTypeCode,
+					reason: `Not a posting account (${at.isGroup ? "group" : "total"})`
+				});
+				continue;
+			}
+			const resolvedNumber = accountNumber ?? accountTypeCode;
+			const resolvedName = name ?? at.name ?? accountTypeCode;
+			validAccounts.push({
+				index: i,
+				accountTypeCode,
+				accountNumber: resolvedNumber,
+				name: resolvedName,
+				active: Boolean(active),
+				isCashAccount: Boolean(isCashAccount)
+			});
+		}
+		if (validAccounts.length === 0) return {
+			summary: {
+				total: accounts.length,
+				created: 0,
+				skipped: results.skipped.length,
+				errors: results.errors.length
+			},
+			...results
+		};
+		const existsFilter = { accountNumber: { $in: validAccounts.map((a) => a.accountNumber) } };
+		if (orgField && orgId != null) existsFilter[orgField] = orgId;
+		const existingDocs = await AccountModel.find(existsFilter).select("accountNumber").lean();
+		const existingNumbers = new Set(existingDocs.map((d) => d.accountNumber));
+		const toCreate = [];
+		for (const item of validAccounts) if (existingNumbers.has(item.accountNumber)) results.skipped.push({
+			index: item.index,
+			accountTypeCode: item.accountTypeCode,
+			reason: "Already exists"
+		});
+		else toCreate.push(item);
+		if (toCreate.length > 0) {
+			const docs = toCreate.map((item) => {
+				const doc = {
+					accountTypeCode: item.accountTypeCode,
+					accountNumber: item.accountNumber,
+					name: item.name,
+					active: item.active,
+					isCashAccount: item.isCashAccount
+				};
+				if (orgField && orgId != null) doc[orgField] = orgId;
+				return doc;
+			});
+			try {
+				const inserted = await AccountModel.insertMany(docs, { ordered: false });
+				results.created = toCreate.map((item, idx) => ({
+					accountTypeCode: item.accountTypeCode,
+					active: item.active,
+					isCashAccount: item.isCashAccount,
+					_id: inserted[idx]._id
+				}));
+			} catch (err) {
+				const bulkError = err;
+				if (bulkError.code === 11e3 || bulkError.writeErrors) {
+					const insertedDocs = bulkError.insertedDocs ?? [];
+					const insertedNumbers = new Set(insertedDocs.map((d) => d.accountNumber));
+					for (const item of toCreate) if (insertedNumbers.has(item.accountNumber)) {
+						const iDoc = insertedDocs.find((d) => d.accountNumber === item.accountNumber);
+						results.created.push({
+							accountTypeCode: item.accountTypeCode,
+							active: item.active,
+							isCashAccount: item.isCashAccount,
+							_id: iDoc?._id
+						});
+					} else results.skipped.push({
+						index: item.index,
+						accountTypeCode: item.accountTypeCode,
+						reason: "Already exists (concurrent insert)"
+					});
+				} else throw err;
+			}
+		}
+		return {
+			summary: {
+				total: accounts.length,
+				created: results.created.length,
+				skipped: results.skipped.length,
+				errors: results.errors.length
+			},
+			...results
+		};
+	};
+	if (typeof repository.registerMethod === "function") for (const name of ["seedAccounts", "bulkCreate"]) {
+		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([
+	"account",
+	"debit",
+	"credit",
+	"label",
+	"date",
+	"taxDetails",
+	"_id",
+	"id"
+]);
+/**
+* Wire post/reverse onto an existing mongokit Repository.
+*
+* All reads use `repository.getByQuery()` so registered plugins
+* (multi-tenant, audit, cache) fire on every operation.
+*
+* @param repository - A mongokit Repository instance (already created)
+* @param _JournalEntryModel - (Deprecated) The Mongoose model — no longer used internally; kept for API compat
+* @param orgField - The multi-tenant field name (e.g. 'business')
+* @param strictness - Strictness rules (immutable, requireActor, requireApproval)
+*/
+function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, strictness) {
+	const getByQuery = repository.getByQuery.bind(repository);
+	const create = repository.create.bind(repository);
+	const withTransaction = repository.withTransaction.bind(repository);
+	/** Build a tenant-scoped query for a single entry by ID (injection-safe) */
+	function buildQuery(id, orgId) {
+		validateScalarId(id, "entry ID");
+		if (orgId != null) validateScalarId(orgId, "organization ID");
+		const query = { _id: id };
+		if (orgField && orgId != null) query[orgField] = orgId;
+		return query;
+	}
+	/** Reject operator-injected objects like { $ne: null } but allow ObjectIds */
+	function validateScalarId(value, label) {
+		if (value == null || typeof value !== "object") return;
+		const obj = value;
+		if (typeof obj.toHexString === "function" || obj._bsontype === "ObjectId") return;
+		if (Object.keys(obj).some((k) => k.startsWith("$"))) throw Errors.validation(`Invalid ${label} — MongoDB operators are not allowed.`);
+	}
+	/** Fetch an entry via the repository (fires all hooks) */
+	async function findEntry(query, options) {
+		const opts = { lean: false };
+		if (options.populate) opts.populate = options.populate;
+		if (options.session) opts.session = options.session;
+		return await getByQuery(query, opts);
+	}
+	/**
+	* Post an entry (draft → posted).
+	* Validates items, balance, and accounts before changing state.
+	*/
+	repository.post = async (id, orgId, options = {}) => {
+		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for post operations.");
+		requireOrgScope(orgField, orgId);
+		const entry = await findEntry(buildQuery(id, orgId), {
+			session: options.session,
+			populate: "journalItems.account"
+		});
+		if (!entry) throw Errors.notFound("Entry not found");
+		if (entry.idempotencyKey && entry.state === "posted") return entry;
+		if (entry.state !== "draft") throw Errors.validation("Only draft entries can be posted");
+		if (strictness?.requireApproval) {
+			if (!entry.approvedBy || !entry.approvedAt) throw Errors.validation("Entry must be approved before posting. Both approvedBy and approvedAt are required.");
+		}
+		if (!entry.journalItems || entry.journalItems.length < 2) throw Errors.validation("Journal entry must have at least 2 items to post");
+		const missing = entry.journalItems.filter((i) => !i.account || i.account === "");
+		if (missing.length > 0) throw Errors.validation(`${missing.length} item(s) missing an account`);
+		const nullAccounts = entry.journalItems.filter((i) => {
+			const acct = i.account;
+			if (!acct) return true;
+			if (typeof acct === "string") return true;
+			if (typeof acct === "object" && !acct._id) return true;
+			return false;
+		});
+		if (nullAccounts.length > 0) throw Errors.validation(`${nullAccounts.length} item(s) reference accounts that do not exist. Ensure all accounts are created before posting.`);
+		if (orgField && orgId != null) {
+			const crossTenant = entry.journalItems.filter((i) => {
+				const acct = i.account;
+				if (!acct || typeof acct !== "object") return false;
+				return String(acct[orgField]) !== String(orgId);
+			});
+			if (crossTenant.length > 0) throw Errors.validation(`${crossTenant.length} item(s) reference accounts from another organization`);
+		}
+		const zeroed = entry.journalItems.filter((i) => (i.debit || 0) === 0 && (i.credit || 0) === 0);
+		if (zeroed.length > 0) throw Errors.validation(`${zeroed.length} item(s) have both debit and credit as zero`);
+		const bothSet = entry.journalItems.filter((i) => (i.debit || 0) > 0 && (i.credit || 0) > 0);
+		if (bothSet.length > 0) throw Errors.validation(`${bothSet.length} item(s) have both debit and credit set — each line must be debit OR credit, not both`);
+		const totalDebit = entry.journalItems.reduce((s, i) => s + (i.debit || 0), 0);
+		const totalCredit = entry.journalItems.reduce((s, i) => s + (i.credit || 0), 0);
+		if (totalDebit !== totalCredit) throw Errors.validation(`Entry is not balanced. Debit: ${totalDebit}, Credit: ${totalCredit}`);
+		entry.state = "posted";
+		entry.stateChangedAt = /* @__PURE__ */ new Date();
+		if (options.actorId) entry.postedBy = options.actorId;
+		await entry.save({ session: options.session });
+		return entry;
+	};
+	/**
+	* Unpost an entry (posted → draft).
+	* Resets state to draft so the entry can be edited and re-posted.
+	* Also clears the reversed flag if set, allowing full re-editing.
+	*/
+	repository.unpost = async (id, orgId, options = {}) => {
+		if (strictness?.immutable) throw Errors.immutable("Unpost is disabled in strict mode. Use reverse() to correct posted entries.");
+		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for unpost operations.");
+		requireOrgScope(orgField, orgId);
+		const entry = await findEntry(buildQuery(id, orgId), { session: options.session });
+		if (!entry) throw Errors.notFound("Entry not found");
+		if (entry.state !== "posted") throw Errors.validation("Only posted entries can be unposted");
+		if (entry.reversed) throw Errors.validation("Cannot unpost a reversed entry. The reversal entry is still posted and linked to this entry. Reverse the reversal entry first, or create a new correcting entry instead.");
+		entry.state = "draft";
+		entry.stateChangedAt = /* @__PURE__ */ new Date();
+		await entry.save({ session: options.session });
+		return entry;
+	};
+	/**
+	* Archive a draft entry (draft → archived).
+	* Used to discard unneeded drafts without deleting them, preserving audit trail.
+	* Only draft entries can be archived. Posted entries must be reversed instead.
+	*/
+	repository.archive = async (id, orgId, options = {}) => {
+		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for archive operations.");
+		requireOrgScope(orgField, orgId);
+		const entry = await findEntry(buildQuery(id, orgId), { session: options.session });
+		if (!entry) throw Errors.notFound("Entry not found");
+		if (entry.state !== "draft") throw Errors.validation("Only draft entries can be archived");
+		entry.state = "archived";
+		entry.stateChangedAt = /* @__PURE__ */ new Date();
+		await entry.save({ session: options.session });
+		return entry;
+	};
+	/**
+	* Duplicate an entry as a new draft.
+	* Copies journal items, journal type, and label. Assigns today's date.
+	*/
+	repository.duplicate = async (id, orgId, options = {}) => {
+		requireOrgScope(orgField, orgId);
+		const entry = await findEntry(buildQuery(id, orgId), { session: options.session });
+		if (!entry) throw Errors.notFound("Entry not found");
+		const duplicateData = {
+			journalType: entry.journalType,
+			state: "draft",
+			date: /* @__PURE__ */ new Date(),
+			label: entry.label ? `Copy of ${entry.label}` : "Duplicated entry",
+			journalItems: entry.journalItems.map((item) => {
+				const accountId = typeof item.account === "object" && item.account !== null ? item.account._id : item.account;
+				const extra = {};
+				for (const key of Object.keys(item)) if (!ITEM_CORE_KEYS.has(key)) extra[key] = item[key];
+				return {
+					...extra,
+					account: accountId,
+					debit: item.debit ?? 0,
+					credit: item.credit ?? 0,
+					label: item.label,
+					date: /* @__PURE__ */ new Date(),
+					taxDetails: item.taxDetails ?? []
+				};
+			})
+		};
+		if (orgField && entry[orgField] != null) duplicateData[orgField] = entry[orgField];
+		return await create(duplicateData, options.session ? { session: options.session } : {});
+	};
+	/**
+	* Reverse a posted entry by creating a mirror entry with flipped debits/credits.
+	* Marks the original as reversed and links both entries bidirectionally.
+	*
+	* Uses repository.withTransaction() for automatic retry on transient failures.
+	* Pass an external session to join a caller-managed transaction instead.
+	*
+	* Routes the reversal through repository.create() so all plugins (fiscal-lock,
+	* double-entry) enforce policy on the reversal entry.
+	*/
+	repository.reverse = async (id, orgId, options = {}) => {
+		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for reverse operations.");
+		requireOrgScope(orgField, orgId);
+		const query = buildQuery(id, orgId);
+		const doReverse = async (session) => {
+			const entry = await findEntry(query, {
+				session,
+				populate: "journalItems.account"
+			});
+			if (!entry) throw Errors.notFound("Entry not found");
+			if (entry.state !== "posted") throw Errors.validation("Only posted entries can be reversed");
+			if (entry.reversed) throw Errors.validation("Entry has already been reversed");
+			const reversalItems = entry.journalItems.map((item) => {
+				const accountId = typeof item.account === "object" && item.account !== null ? item.account._id : item.account;
+				const extra = {};
+				for (const key of Object.keys(item)) if (!ITEM_CORE_KEYS.has(key)) extra[key] = item[key];
+				return {
+					...extra,
+					account: accountId,
+					debit: item.credit ?? 0,
+					credit: item.debit ?? 0,
+					label: item.label ? `Reversal: ${item.label}` : void 0,
+					date: item.date,
+					taxDetails: item.taxDetails ?? []
+				};
+			});
+			const totalDebit = reversalItems.reduce((s, i) => s + i.debit, 0);
+			const totalCredit = reversalItems.reduce((s, i) => s + i.credit, 0);
+			const reversalData = {
+				journalType: entry.journalType ?? "MISC",
+				state: "posted",
+				date: options.reversalDate ?? /* @__PURE__ */ new Date(),
+				label: `Reversal of ${entry.referenceNumber ?? entry._id}`,
+				journalItems: reversalItems,
+				totalDebit,
+				totalCredit,
+				reversalOf: entry._id,
+				stateChangedAt: /* @__PURE__ */ new Date()
+			};
+			if (orgField && entry[orgField] != null) reversalData[orgField] = entry[orgField];
+			if (options.actorId) reversalData.postedBy = options.actorId;
+			const reversalEntry = await create(reversalData, session ? { session } : {});
+			entry.reversed = true;
+			entry.reversedBy = reversalEntry._id;
+			if (options.actorId) entry.reversedByUser = options.actorId;
+			await entry.save({ session });
+			return {
+				original: entry,
+				reversal: reversalEntry
+			};
+		};
+		if (options.session) return await doReverse(options.session);
+		if (withTransaction) return await withTransaction((session) => doReverse(session), { allowFallback: true });
+		return await doReverse();
+	};
+	const methodNames = [
+		"post",
+		"unpost",
+		"archive",
+		"duplicate",
+		"reverse"
+	];
+	if (typeof repository.registerMethod === "function") for (const name of methodNames) {
+		const fn = repository[name];
+		try {
+			delete repository[name];
+			repository.registerMethod(name, fn);
+		} catch {
+			repository[name] = fn;
+		}
+	}
+	return repository;
+}
+//#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)
+*/
+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;
+		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.`);
+		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 reconciliationData = {
+			account,
+			journalEntryIds,
+			debitTotal,
+			creditTotal,
+			difference: debitTotal - creditTotal,
+			note,
+			reconciledBy,
+			reconciledAt: /* @__PURE__ */ new Date()
+		};
+		if (orgField && organizationId != null) reconciliationData[orgField] = organizationId;
+		return await create(reconciliationData);
+	};
+	/**
+	* Remove a reconciliation record via repository.delete().
+	*/
+	repository.unreconcile = async (input) => {
+		const { reconciliationId, organizationId } = 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.");
+		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;
+		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();
+	};
+	if (typeof repository.registerMethod === "function") for (const name of [
+		"reconcile",
+		"unreconcile",
+		"getUnreconciled"
+	]) {
+		const fn = repository[name];
+		try {
+			delete repository[name];
+			repository.registerMethod(name, fn);
+		} catch {
+			repository[name] = fn;
+		}
+	}
+	return repository;
+}
+//#endregion
 //#region src/repositories/factory.ts
 /**
 * Repositories Factory — wires fully-configured repositories.
@@ -71,7 +1270,7 @@ function createRepositories(models, config, plugins = {}, pagination = {}) {
 	const orgField = config.multiTenant?.orgField;
 	const strictness = config.strictness;
 	const country = config.country;
-	const accountPagination = pagination.account ?? { maxLimit: 1e3 };
+	const accountPagination = pagination.account ?? {};
 	const jePagination = pagination.journalEntry ?? {};
 	const fpPagination = pagination.fiscalPeriod ?? {};
 	const budgetPagination = pagination.budget ?? {};
@@ -103,83 +1302,620 @@ function createRepositories(models, config, plugins = {}, pagination = {}) {
 	};
 }
 //#endregion
+//#region src/semantic/introspect.ts
+const REPORT_CATALOG = Object.freeze([
+	{
+		name: "trialBalance",
+		title: "Trial Balance",
+		description: "Debits and credits per account for a period, with opening, current, and ending balances.",
+		params: [
+			{
+				name: "dateOption",
+				required: true,
+				description: "'month' | 'quarter' | 'year' | 'custom'"
+			},
+			{
+				name: "dateValue",
+				required: true,
+				description: "Period value (format depends on dateOption)"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			},
+			{
+				name: "accountId",
+				required: false,
+				description: "Filter to a single account"
+			},
+			{
+				name: "filters",
+				required: false,
+				description: "Additional dimension filters"
+			}
+		]
+	},
+	{
+		name: "balanceSheet",
+		title: "Balance Sheet",
+		description: "Assets, liabilities, and equity at a point in time. Includes computed retained earnings.",
+		params: [
+			{
+				name: "dateOption",
+				required: true,
+				description: "'month' | 'quarter' | 'year' | 'custom'"
+			},
+			{
+				name: "dateValue",
+				required: true,
+				description: "Period value"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			},
+			{
+				name: "businessName",
+				required: false,
+				description: "Header label"
+			},
+			{
+				name: "filters",
+				required: false,
+				description: "Additional dimension filters"
+			}
+		]
+	},
+	{
+		name: "incomeStatement",
+		title: "Income Statement",
+		description: "Revenue, COGS, gross profit, operating expenses, and net income for a period.",
+		params: [
+			{
+				name: "dateOption",
+				required: true,
+				description: "'month' | 'quarter' | 'year' | 'custom'"
+			},
+			{
+				name: "dateValue",
+				required: true,
+				description: "Period value"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			},
+			{
+				name: "businessName",
+				required: false,
+				description: "Header label"
+			},
+			{
+				name: "filters",
+				required: false,
+				description: "Additional dimension filters"
+			}
+		]
+	},
+	{
+		name: "generalLedger",
+		title: "General Ledger",
+		description: "Per-account transaction detail with running balances. Use accountId to scope.",
+		params: [
+			{
+				name: "dateOption",
+				required: true,
+				description: "'month' | 'quarter' | 'year' | 'custom'"
+			},
+			{
+				name: "dateValue",
+				required: true,
+				description: "Period value"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			},
+			{
+				name: "accountId",
+				required: false,
+				description: "Scope to a single account"
+			}
+		]
+	},
+	{
+		name: "cashFlow",
+		title: "Cash Flow Statement",
+		description: "Cash movement by Operating / Investing / Financing sections.",
+		params: [
+			{
+				name: "dateOption",
+				required: true,
+				description: "'month' | 'quarter' | 'year' | 'custom'"
+			},
+			{
+				name: "dateValue",
+				required: true,
+				description: "Period value"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			}
+		]
+	},
+	{
+		name: "agedBalance",
+		title: "Aged Receivables / Payables",
+		description: "Outstanding AR or AP bucketed by age (current, 30, 60, 90+).",
+		params: [
+			{
+				name: "type",
+				required: true,
+				description: "'receivable' | 'payable'"
+			},
+			{
+				name: "asOfDate",
+				required: false,
+				description: "Defaults to now"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			},
+			{
+				name: "buckets",
+				required: false,
+				description: "Custom bucket definitions"
+			}
+		]
+	},
+	{
+		name: "dimensionBreakdown",
+		title: "Dimension Breakdown",
+		description: "Expense/revenue by a custom dimension (department, project, cost center).",
+		params: [
+			{
+				name: "dimension",
+				required: true,
+				description: "Field name to group by (e.g. departmentId)"
+			},
+			{
+				name: "dateOption",
+				required: true,
+				description: "'month' | 'quarter' | 'year' | 'custom'"
+			},
+			{
+				name: "dateValue",
+				required: true,
+				description: "Period value"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			},
+			{
+				name: "accountCategory",
+				required: false,
+				description: "Filter by statement category"
+			}
+		]
+	},
+	{
+		name: "budgetVsActual",
+		title: "Budget vs Actual",
+		description: "Compare budgeted amounts to actual posted entries for a period.",
+		params: [
+			{
+				name: "dateOption",
+				required: true,
+				description: "'month' | 'quarter' | 'year' | 'custom'"
+			},
+			{
+				name: "dateValue",
+				required: true,
+				description: "Period value"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			}
+		]
+	},
+	{
+		name: "revaluation",
+		title: "Foreign Exchange Revaluation",
+		description: "Unrealized FX gain/loss on foreign-currency accounts at a date.",
+		params: [
+			{
+				name: "asOfDate",
+				required: true,
+				description: "Revaluation date"
+			},
+			{
+				name: "rates",
+				required: true,
+				description: "Array of { currency, rate } at asOfDate"
+			},
+			{
+				name: "unrealizedGainLossAccountId",
+				required: true,
+				description: "Account for FX P&L"
+			},
+			{
+				name: "generateEntry",
+				required: false,
+				description: "Auto-create adjustment entry"
+			},
+			{
+				name: "organizationId",
+				required: false,
+				description: "Multi-tenant scoping"
+			}
+		]
+	}
+]);
+function buildIntrospectAPI({ models, country, config }) {
+	const AccountModel = models.Account;
+	const FiscalPeriodModel = models.FiscalPeriod;
+	const orgField = config.multiTenant?.orgField;
+	const normalBalanceFor = (category) => {
+		if (category.endsWith("Asset") || category.endsWith("Expense")) return "debit";
+		return "credit";
+	};
+	const accounts = async (organizationId, session = null) => {
+		const filter = {};
+		if (orgField && organizationId != null) filter[orgField] = organizationId;
+		return (await AccountModel.find(filter).session(session).lean()).map((doc) => {
+			const code = String(doc.accountTypeCode ?? "");
+			const at = country.getAccountType(code);
+			const category = at?.category ?? "Unknown";
+			return {
+				id: String(doc._id),
+				code,
+				name: at?.name ?? code,
+				category,
+				normalBalance: normalBalanceFor(category),
+				parentCode: at?.parentCode ?? null,
+				isPosting: country.isPostingAccount(code),
+				active: doc.active !== false,
+				...orgField && doc[orgField] != null ? { organizationId: String(doc[orgField]) } : {}
+			};
+		});
+	};
+	const journalTypes = () => {
+		const builtIn = Object.values(JOURNAL_TYPES);
+		const custom = getCustomJournalTypes();
+		return Object.freeze([...builtIn, ...custom]);
+	};
+	const reports = () => REPORT_CATALOG;
+	const taxCodes = (region) => {
+		if (region) return Object.freeze(country.getTaxCodesForRegion(region));
+		return Object.freeze(Object.values(country.taxCodes));
+	};
+	const fiscalPeriods = async (organizationId, session = null) => {
+		const filter = {};
+		if (orgField && organizationId != null) filter[orgField] = organizationId;
+		return (await FiscalPeriodModel.find(filter).sort({ startDate: 1 }).session(session).lean()).map((doc) => ({
+			id: String(doc._id),
+			name: String(doc.name ?? ""),
+			startDate: doc.startDate,
+			endDate: doc.endDate,
+			closed: Boolean(doc.closed),
+			...doc.closedAt ? { closedAt: doc.closedAt } : {},
+			...orgField && doc[orgField] != null ? { organizationId: String(doc[orgField]) } : {}
+		}));
+	};
+	const catalog = async (organizationId) => ({
+		accounts: await accounts(organizationId),
+		journalTypes: journalTypes(),
+		reports: reports(),
+		taxCodes: taxCodes(),
+		fiscalPeriods: await fiscalPeriods(organizationId)
+	});
+	return {
+		accounts,
+		journalTypes,
+		reports,
+		taxCodes,
+		fiscalPeriods,
+		catalog
+	};
+}
+//#endregion
+//#region src/semantic/record.ts
+function buildRecordAPI({ models, repositories, country, config }) {
+	const AccountModel = models.Account;
+	const orgField = config.multiTenant?.orgField;
+	const lookupTaxRate = (taxCode) => {
+		const tc = country.taxCodes[taxCode];
+		if (!tc) throw Errors.notFound(`Tax code '${taxCode}' not found in country pack.`, [{
+			path: "tax.code",
+			issue: "unknown tax code",
+			value: taxCode
+		}]);
+		return tc.rate;
+	};
+	const resolveAccounts = async (organizationId, codes, path, session) => {
+		const unique = Array.from(new Set(codes));
+		const filter = { accountTypeCode: { $in: unique } };
+		if (orgField && organizationId != null) filter[orgField] = organizationId;
+		const docs = await AccountModel.find(filter).select(`_id accountTypeCode`).session(session ?? null).lean();
+		const map = /* @__PURE__ */ new Map();
+		for (const d of docs) if (!map.has(d.accountTypeCode)) map.set(d.accountTypeCode, d._id);
+		const missing = unique.filter((c) => !map.has(c));
+		if (missing.length > 0) throw Errors.notFound(`Account(s) not found in ${orgField && organizationId ? "org" : "default"} chart of accounts: ${missing.join(", ")}. Seed them first via engine.repositories.accounts.seedAccounts().`, missing.map((code) => ({
+			path,
+			issue: "account type code not found in chart of accounts",
+			value: code
+		})));
+		return map;
+	};
+	const validateAmount = (amount, path = "amount") => {
+		if (!Number.isInteger(amount)) throw Errors.validation(`Amount must be an integer (cents), got ${amount}.`, [{
+			path,
+			issue: "must be an integer",
+			value: amount
+		}]);
+		if (amount <= 0) throw Errors.validation(`Amount must be positive, got ${amount}.`, [{
+			path,
+			issue: "must be positive",
+			value: amount
+		}]);
+	};
+	const postEntry = async (organizationId, payload, options) => {
+		if (orgField && organizationId != null) payload[orgField] = organizationId;
+		const actorId = options?.actorId ?? (options?.user ? options.user._id?.toString() ?? options.user.id?.toString() : void 0);
+		if (actorId) {
+			payload.createdBy = actorId;
+			payload.postedBy = actorId;
+		}
+		if (options?.idempotencyKey) payload.idempotencyKey = options.idempotencyKey;
+		payload.state = "posted";
+		const ctx = { session: options?.session ?? void 0 };
+		if (options?.user) ctx.user = options.user;
+		if (orgField && organizationId != null) ctx.organizationId = organizationId;
+		if (options) {
+			for (const key of Object.keys(options)) if (key !== "session" && key !== "user" && key !== "actorId" && key !== "idempotencyKey") ctx[key] = options[key];
+		}
+		return repositories.journalEntries.create(payload, ctx);
+	};
+	const buildItem = (account, debit, credit, label, dimensions) => ({
+		account,
+		debit,
+		credit,
+		...label ? { label } : {},
+		...dimensions ?? {}
+	});
+	const sale = async (organizationId, input, options) => {
+		validateAmount(input.amount, "amount");
+		let baseAmount = input.amount;
+		let taxAmount = 0;
+		if (input.tax) {
+			const rate = lookupTaxRate(input.tax.code);
+			if (input.tax.inclusive) {
+				const split = splitTaxInclusive(input.amount, rate);
+				baseAmount = split.base;
+				taxAmount = split.tax;
+			} else {
+				const split = splitTaxExclusive(input.amount, rate);
+				baseAmount = split.base;
+				taxAmount = split.tax;
+			}
+		}
+		const totalCharge = baseAmount + taxAmount;
+		const codes = [input.receivableAccount, input.revenueAccount];
+		if (input.tax) codes.push(input.tax.account);
+		const acctMap = await resolveAccounts(organizationId, codes, "receivableAccount", options?.session ?? null);
+		const items = [buildItem(acctMap.get(input.receivableAccount), totalCharge, 0, input.label, input.dimensions), buildItem(acctMap.get(input.revenueAccount), 0, baseAmount, input.label, input.dimensions)];
+		if (input.tax) items.push(buildItem(acctMap.get(input.tax.account), 0, taxAmount, `${input.label ?? "Sale"} — ${input.tax.code}`, input.dimensions));
+		return postEntry(organizationId, {
+			journalType: input.journalType ?? "SALES",
+			date: input.date,
+			label: input.label,
+			referenceNumber: input.reference,
+			journalItems: items
+		}, options);
+	};
+	const expense = async (organizationId, input, options) => {
+		validateAmount(input.amount, "amount");
+		let baseAmount = input.amount;
+		let taxAmount = 0;
+		if (input.tax) {
+			const rate = lookupTaxRate(input.tax.code);
+			if (input.tax.inclusive) {
+				const split = splitTaxInclusive(input.amount, rate);
+				baseAmount = split.base;
+				taxAmount = split.tax;
+			} else {
+				const split = splitTaxExclusive(input.amount, rate);
+				baseAmount = split.base;
+				taxAmount = split.tax;
+			}
+		}
+		const totalPaid = baseAmount + taxAmount;
+		const codes = [input.expenseAccount, input.paidFromAccount];
+		if (input.tax) codes.push(input.tax.account);
+		const acctMap = await resolveAccounts(organizationId, codes, "expenseAccount", options?.session ?? null);
+		const items = [buildItem(acctMap.get(input.expenseAccount), baseAmount, 0, input.label, input.dimensions)];
+		if (input.tax) items.push(buildItem(acctMap.get(input.tax.account), taxAmount, 0, `${input.label ?? "Expense"} — ${input.tax.code} ITC`, input.dimensions));
+		items.push(buildItem(acctMap.get(input.paidFromAccount), 0, totalPaid, input.label, input.dimensions));
+		return postEntry(organizationId, {
+			journalType: input.journalType ?? "PURCHASES",
+			date: input.date,
+			label: input.label,
+			referenceNumber: input.reference,
+			journalItems: items
+		}, options);
+	};
+	const transfer = async (organizationId, input, options) => {
+		validateAmount(input.amount, "amount");
+		if (input.fromAccount === input.toAccount) throw Errors.validation("Transfer source and destination accounts must be different.", [{
+			path: "fromAccount",
+			issue: "must differ from toAccount",
+			value: {
+				from: input.fromAccount,
+				to: input.toAccount
+			}
+		}]);
+		const acctMap = await resolveAccounts(organizationId, [input.fromAccount, input.toAccount], "fromAccount", options?.session ?? null);
+		const items = [buildItem(acctMap.get(input.toAccount), input.amount, 0, input.label, input.dimensions), buildItem(acctMap.get(input.fromAccount), 0, input.amount, input.label, input.dimensions)];
+		return postEntry(organizationId, {
+			journalType: input.journalType ?? "GENERAL",
+			date: input.date,
+			label: input.label,
+			referenceNumber: input.reference,
+			journalItems: items
+		}, options);
+	};
+	const payment = async (organizationId, input, options) => {
+		validateAmount(input.amount, "amount");
+		const acctMap = await resolveAccounts(organizationId, [input.fromReceivableAccount, input.toCashAccount], "fromReceivableAccount", options?.session ?? null);
+		const items = [buildItem(acctMap.get(input.toCashAccount), input.amount, 0, input.label, input.dimensions), buildItem(acctMap.get(input.fromReceivableAccount), 0, input.amount, input.label, input.dimensions)];
+		return postEntry(organizationId, {
+			journalType: input.journalType ?? "CASH_RECEIPTS",
+			date: input.date,
+			label: input.label,
+			referenceNumber: input.reference,
+			journalItems: items
+		}, options);
+	};
+	const adjustment = async (organizationId, input, options) => {
+		if (!input.lines || input.lines.length < 2) throw Errors.validation("Adjustment requires at least 2 lines.", [{
+			path: "lines",
+			issue: "must contain at least 2 entries",
+			value: input.lines?.length
+		}]);
+		const lineErrors = [];
+		let totalDebit = 0;
+		let totalCredit = 0;
+		input.lines.forEach((line, idx) => {
+			const d = line.debit ?? 0;
+			const c = line.credit ?? 0;
+			if (!Number.isInteger(d) || d < 0) lineErrors.push({
+				path: `lines.${idx}.debit`,
+				issue: "must be a non-negative integer",
+				value: d
+			});
+			if (!Number.isInteger(c) || c < 0) lineErrors.push({
+				path: `lines.${idx}.credit`,
+				issue: "must be a non-negative integer",
+				value: c
+			});
+			if (d > 0 && c > 0) lineErrors.push({
+				path: `lines.${idx}`,
+				issue: "line cannot have both debit and credit",
+				value: {
+					debit: d,
+					credit: c
+				}
+			});
+			if (d === 0 && c === 0) lineErrors.push({
+				path: `lines.${idx}`,
+				issue: "line must have a non-zero debit or credit",
+				value: {
+					debit: 0,
+					credit: 0
+				}
+			});
+			totalDebit += d;
+			totalCredit += c;
+		});
+		if (lineErrors.length > 0) throw Errors.validation(`Invalid adjustment lines: ${lineErrors.length} issue(s).`, lineErrors);
+		if (totalDebit !== totalCredit) throw Errors.validation(`Adjustment not balanced: debits (${totalDebit}) ≠ credits (${totalCredit}).`, [{
+			path: "lines",
+			issue: "debits must equal credits",
+			value: {
+				totalDebit,
+				totalCredit,
+				difference: totalDebit - totalCredit
+			}
+		}]);
+		const acctMap = await resolveAccounts(organizationId, input.lines.map((l) => l.account), "lines", options?.session ?? null);
+		const items = input.lines.map((line) => buildItem(acctMap.get(line.account), line.debit ?? 0, line.credit ?? 0, line.label ?? input.label, input.dimensions));
+		return postEntry(organizationId, {
+			journalType: input.journalType ?? "GENERAL",
+			date: input.date,
+			label: input.label,
+			referenceNumber: input.reference,
+			journalItems: items
+		}, options);
+	};
+	return {
+		sale,
+		expense,
+		transfer,
+		payment,
+		adjustment
+	};
+}
+//#endregion
 //#region src/engine.ts
 var AccountingEngine = class {
 	config;
 	country;
 	currency;
 	money = Money;
-	_models;
-	_repositories;
+	models;
+	repositories;
+	record;
+	introspect;
 	_reports;
-	constructor(config, plugins = {}, pagination = {}) {
+	constructor(config) {
+		if (!config.mongoose) throw new Error("createAccountingEngine: `mongoose` connection is required. Pass `mongoose: mongoose.connection` in config.");
 		this.config = config;
 		this.country = config.country;
 		this.currency = config.currency;
-		if (config.mongoose) {
-			this._models = createModels(config.mongoose, config);
-			this._repositories = createRepositories(this._models, config, plugins, pagination);
-		}
-	}
-	/**
-	* Auto-created Mongoose models. Requires `mongoose` in config.
-	*
-	* @throws if `mongoose` was not provided in config
-	*/
-	get models() {
-		if (!this._models) throw new Error("engine.models requires a Mongoose connection. Pass `mongoose: connection` in createAccountingEngine config.");
-		return this._models;
-	}
-	/**
-	* Auto-wired repositories with plugins + domain methods (post, reverse, etc.).
-	* Requires `mongoose` in config.
-	*
-	* @throws if `mongoose` was not provided in config
-	*/
-	get repositories() {
-		if (!this._repositories) throw new Error("engine.repositories requires a Mongoose connection. Pass `mongoose: connection` in createAccountingEngine config.");
-		return this._repositories;
+		this.models = createModels(config.mongoose, config);
+		this.repositories = createRepositories(this.models, config, config.plugins ?? {}, config.pagination ?? {});
+		this.record = buildRecordAPI({
+			models: this.models,
+			repositories: this.repositories,
+			country: this.country,
+			config: this.config
+		});
+		this.introspect = buildIntrospectAPI({
+			models: this.models,
+			country: this.country,
+			config: this.config
+		});
 	}
 	/**
-	* Pre-built reports bound to auto-created models. Requires `mongoose` in config.
-	* For custom models, use `engine.createReports({ Account, JournalEntry, Budget })`.
+	* Pre-built reports bound to the engine's owned models.
+	* Lazy-initialized on first access.
 	*/
 	get reports() {
-		if (!this._reports) {
-			if (!this._models) throw new Error("engine.reports requires a Mongoose connection. Pass `mongoose: connection` in createAccountingEngine config, or use engine.createReports({ Account, JournalEntry }) for manual models.");
-			this._reports = this._buildReports({
-				Account: this._models.Account,
-				JournalEntry: this._models.JournalEntry,
-				Budget: this._models.Budget
-			});
-		}
+		if (!this._reports) this._reports = this._buildReports();
 		return this._reports;
 	}
-	createAccountSchema(options) {
-		return createAccountSchema(this.config, options);
-	}
-	createJournalEntrySchema(accountModelName, options) {
-		return createJournalEntrySchema(this.config, accountModelName, options);
-	}
-	createFiscalPeriodSchema(options) {
-		return createFiscalPeriodSchema(this.config, options);
+	/** Get all posting account types (accounts you can post transactions to) */
+	getPostingAccountTypes() {
+		return this.country.getPostingAccountTypes();
 	}
-	createBudgetSchema(options) {
-		return createBudgetSchema(this.config, options);
+	/** Validate an account type code */
+	isValidAccountType(code) {
+		return this.country.isValidAccountType(code);
 	}
-	createReconciliationSchema(accountModelName, journalEntryModelName, options) {
-		return createReconciliationSchema(this.config, accountModelName, journalEntryModelName, options);
+	/** Get account type definition by code */
+	getAccountType(code) {
+		return this.country.getAccountType(code);
 	}
-	/**
-	* Build a reports object bound to the given models. Use this when you
-	* need custom/external models. Prefer `engine.reports` when the engine
-	* owns the models (via `mongoose` in config).
-	*/
-	createReports(models) {
-		return this._buildReports(models);
+	/** Get tax codes for a region */
+	getTaxCodesForRegion(region) {
+		return this.country.getTaxCodesForRegion(region);
 	}
-	_buildReports(models) {
-		const { Account: AccountModel, JournalEntry: JournalEntryModel, Budget: BudgetModel } = models;
+	_buildReports() {
+		const AccountModel = this.models.Account;
+		const JournalEntryModel = this.models.JournalEntry;
+		const BudgetModel = this.models.Budget;
 		const { country, config } = this;
 		const orgField = config.multiTenant?.orgField;
 		const fiscalYearStartMonth = config.fiscalYearStartMonth ?? 1;
@@ -235,16 +1971,13 @@ var AccountingEngine = class {
 				country,
 				orgField
 			}, params),
-			budgetVsActual: (params) => {
-				if (!BudgetModel) throw new Error("Budget model required — pass Budget to createReports()");
-				return generateBudgetVsActual({
-					AccountModel,
-					JournalEntryModel,
-					BudgetModel,
-					country,
-					orgField
-				}, params);
-			},
+			budgetVsActual: (params) => generateBudgetVsActual({
+				AccountModel,
+				JournalEntryModel,
+				BudgetModel,
+				country,
+				orgField
+			}, params),
 			revaluation: (params) => generateRevaluation({
 				AccountModel,
 				JournalEntryModel,
@@ -254,98 +1987,9 @@ var AccountingEngine = class {
 			}, params)
 		};
 	}
-	/** Get all posting account types (accounts you can post transactions to) */
-	getPostingAccountTypes() {
-		return this.country.getPostingAccountTypes();
-	}
-	/** Validate an account type code */
-	isValidAccountType(code) {
-		return this.country.isValidAccountType(code);
-	}
-	/** Get account type definition by code */
-	getAccountType(code) {
-		return this.country.getAccountType(code);
-	}
-	/** Get tax codes for a region */
-	getTaxCodesForRegion(region) {
-		return this.country.getTaxCodesForRegion(region);
-	}
-	/**
-	* Create a fully-configured journal entry repository with secure plugin wiring.
-	* This is the **recommended** way to set up journal entry repositories.
-	*
-	* Includes:
-	* - Double-entry plugin with account existence + tenant integrity validation
-	* - Fiscal lock plugin (when FiscalPeriodModel is provided)
-	* - post(), unpost(), reverse(), and duplicate() domain methods
-	*
-	* @param createRepository - The `createRepository` function from @classytic/mongokit
-	* @param models.JournalEntryModel - Mongoose model for journal entries
-	* @param models.AccountModel - Mongoose model for accounts (required for secure posted-create validation)
-	* @param models.FiscalPeriodModel - Mongoose model for fiscal periods (optional, enables fiscal lock)
-	* @param additionalPlugins - Extra plugins to include (e.g. timestampPlugin)
-	* @returns A wired repository with post(), unpost(), reverse(), duplicate(), and all plugins configured
-	*/
-	createJournalEntryRepository(createRepository, models, additionalPlugins = []) {
-		const orgField = this.config.multiTenant?.orgField;
-		const { JournalEntryModel, AccountModel, FiscalPeriodModel } = models;
-		const jeModel = JournalEntryModel;
-		const plugins = [...additionalPlugins, doubleEntryPlugin({
-			JournalEntryModel: jeModel,
-			AccountModel,
-			orgField
-		})];
-		if (FiscalPeriodModel) plugins.push(fiscalLockPlugin({
-			FiscalPeriodModel,
-			JournalEntryModel: jeModel,
-			orgField
-		}));
-		if (this.config.idempotency) plugins.push(idempotencyPlugin({
-			JournalEntryModel: jeModel,
-			orgField
-		}));
-		return wireJournalEntryMethods(createRepository(JournalEntryModel, plugins), JournalEntryModel, orgField, this.config.strictness);
-	}
-	/**
-	* Wire post/reverse domain methods onto a mongokit Repository
-	* for journal entries. The repository must already be created via
-	* `createRepository(Model, plugins)` from @classytic/mongokit.
-	*
-	* **Note:** Prefer `createJournalEntryRepository()` which guarantees
-	* secure plugin wiring. This method only adds domain methods and does
-	* not validate plugin configuration.
-	*
-	* @param repository - An existing mongokit Repository instance
-	* @param JournalEntryModel - The Mongoose model for journal entries
-	* @returns The same repository, now with `.post()` and `.reverse()`
-	*/
-	wireJournalEntryRepository(repository, JournalEntryModel) {
-		const orgField = this.config.multiTenant?.orgField;
-		return wireJournalEntryMethods(repository, JournalEntryModel, orgField, this.config.strictness);
-	}
-	/**
-	* Wire seedAccounts/bulkCreate and posting-account validation onto a
-	* mongokit Repository for accounts. The repository must already be
-	* created via `createRepository(Model, plugins)` from @classytic/mongokit.
-	*
-	* @param repository - An existing mongokit Repository instance
-	* @param AccountModel - The Mongoose model for accounts
-	* @returns The same repository, now with `.seedAccounts()` and `.bulkCreate()`
-	*/
-	wireAccountRepository(repository, AccountModel) {
-		const orgField = this.config.multiTenant?.orgField;
-		return wireAccountMethods(repository, AccountModel, this.country, orgField);
-	}
-	/**
-	* Wire reconcile/unreconcile/getUnreconciled methods onto a mongokit Repository.
-	*/
-	wireReconciliationRepository(repository, ReconciliationModel, JournalEntryModel) {
-		const orgField = this.config.multiTenant?.orgField;
-		return wireReconciliationMethods(repository, ReconciliationModel, JournalEntryModel, orgField);
-	}
 };
-function createAccountingEngine(config, plugins = {}, pagination = {}) {
-	return new AccountingEngine(config, plugins, pagination);
+function createAccountingEngine(config) {
+	return new AccountingEngine(config);
 }
 //#endregion
 //#region src/utils/dimensions.ts
@@ -407,4 +2051,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, createAccountSchema, createAccountingEngine, createFiscalPeriodSchema, createJournalEntrySchema, 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, wireAccountMethods, wireJournalEntryMethods, wireReconciliationMethods };
+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 };