@classytic/ledger 0.2.0 → 0.3.0

package/README.md

@@ -1,26 +1,15 @@
 # @classytic/ledger
 
-Production-grade double-entry accounting engine for MongoDB. Built on [@classytic/mongokit](../mongokit). Designed for multi-tenant SaaS, AI-powered finance, and global tax compliance.
-
-## Features
-
-- **Double-entry bookkeeping** with balance validation and posted-entry protection (optionally immutable via strictness config)
-- **Multi-tenant** isolation via configurable org field
-- **Country packs** for localized chart of accounts and tax codes
-- **Financial reports** — trial balance, balance sheet, income statement, general ledger, cash flow
-- **Fiscal period management** — close and reopen with automatic year-end entries, overlap protection
-- **CSV export** — QuickBooks-compatible and universal field maps
-- **Cents-based Money** arithmetic for precision
-- **Plugin system** — fiscal lock, double-entry validation, idempotency (via mongokit hooks)
-- **Dimension fields** — custom fields on journal items (departmentId, projectId, etc.) preserved through all workflows
-- **Dimension filters** — filter all reports by custom journal item fields
-- **Strictness controls** — configurable immutability, actor tracking, and approval requirements
-- **Subledger contracts** — typed interfaces for integrating billing, inventory, payroll, and other subledgers
+Embeddable double-entry accounting engine for MongoDB. Integer-cents arithmetic, plugin-based, country-agnostic.
+
+Build QuickBooks, Xero, or TaxCycle-grade apps — the engine handles the accounting, you handle the UX.
 
 ## Install
 
 ```bash
 npm install @classytic/ledger @classytic/mongokit mongoose
+npm install @classytic/ledger-ca  # Canada (GIFI, GST/HST, CRA)
+npm install @classytic/ledger-bd  # Bangladesh (BFRS, VAT/TDS, Mushak)
 ```
 
 ## Quick Start
@@ -28,80 +17,188 @@ npm install @classytic/ledger @classytic/mongokit mongoose
 ```typescript
 import { createAccountingEngine } from '@classytic/ledger';
 import { canadaPack } from '@classytic/ledger-ca';
-import mongoose from 'mongoose';
 
-// 1. Create engine
 const accounting = createAccountingEngine({
   country: canadaPack,
   currency: 'CAD',
-  multiTenant: { orgField: 'business', orgRef: 'Business' },
-  audit: { trackActor: true },
-  idempotency: true,
-  strictness: { immutable: true, requireActor: true },
+  multiTenant: { orgField: 'organization', orgRef: 'Organization' },
 });
 
-// 2. Create schemas & models
+// Schemas
 const Account = mongoose.model('Account', accounting.createAccountSchema());
-const JournalEntry = mongoose.model('JournalEntry', accounting.createJournalEntrySchema('Account', {
-  extraItemFields: {
-    departmentId: { type: mongoose.Schema.Types.ObjectId, ref: 'Department' },
-  },
-}));
+const JournalEntry = mongoose.model('JournalEntry', accounting.createJournalEntrySchema('Account'));
 const FiscalPeriod = mongoose.model('FiscalPeriod', accounting.createFiscalPeriodSchema());
 
-// 3. Wire repositories (adds post, reverse, duplicate, unpost, seedAccounts, bulkCreate)
-import { createRepository } from '@classytic/mongokit';
+// Reports
+const reports = accounting.createReports({ Account, JournalEntry });
+const bs = await reports.balanceSheet({ organizationId, dateOption: 'year', dateValue: 2025 });
+```
 
-const journalRepo = accounting.createJournalEntryRepository(
-  createRepository,
-  { JournalEntryModel: JournalEntry, AccountModel: Account, FiscalPeriodModel: FiscalPeriod },
-);
+## Core Features
+
+**Accounting Engine**
+- Double-entry validation with balance enforcement
+- Integer-cents storage — zero floating-point drift
+- Draft → Posted → Reversed state machine
+- Configurable immutability (corrections only via reversal)
+- Multi-tenant isolation at every layer
+- Country packs for localized charts of accounts and tax codes
+
+**10 Reports**
+- Trial Balance (3-column: initial + period + ending)
+- Balance Sheet (with computed retained earnings)
+- Income Statement (revenue, COGS, gross profit, operating expenses, net income)
+- General Ledger (per-account with running balances)
+- Cash Flow (Operating / Investing / Financing)
+- Aged Receivable / Payable (configurable buckets: current, 30, 60, 90+)
+- Budget vs Actual (variance analysis)
+- Dimension Breakdown (by department, project, cost center)
+- Foreign Exchange Revaluation (unrealized gain/loss computation)
+- Fiscal Year Close / Reopen (automatic closing entries)
+
+**Plugins**
+- `doubleEntryPlugin` — validates debits = credits, account existence, tenant integrity
+- `fiscalLockPlugin` — prevents posting to closed fiscal periods
+- `dateLockPlugin` — blocks entries before a configurable lock date
+- `taxHookPlugin` — auto-generates tax lines via user-defined `TaxLineGenerator`
+- `idempotencyPlugin` — prevents duplicate entries by key
+
+**Utilities**
+- `Money` — cents arithmetic, tax splitting, allocation with zero-sum guarantee
+- `buildDimensionFields` — schema helpers for analytic dimensions
+- `suggestMatches` — reconciliation matching suggestions
+- `computeRevaluation` — FX gain/loss computation
+
+## Engine Configuration
 
-const accountRepo = createRepository(Account, []);
-accounting.wireAccountRepository(accountRepo, Account);
+```typescript
+createAccountingEngine({
+  country: canadaPack,                    // required
+  currency: 'CAD',                        // required — base/functional currency
+  multiTenant: { orgField, orgRef },      // optional — multi-tenant scoping
+  multiCurrency: { enabled: true, currencies: ['USD', 'EUR'] },
+  fiscalYearStartMonth: 1,               // 1=Jan (default), 4=Apr, 7=Jul
+  retainedEarningsAccountCode: '3600',   // overrides country pack
+  audit: { trackActor: true },
+  idempotency: true,
+  strictness: {
+    immutable: true,      // disable unpost, corrections via reverse only
+    requireActor: true,   // actorId required on post/reverse
+    requireApproval: true // entries must be approved before posting
+  },
+});
+```
 
-// 4. Generate reports (with optional dimension filters)
-const reports = accounting.createReports({ Account, JournalEntry });
-const bs = await reports.balanceSheet({
-  organizationId: orgId,
-  dateOption: 'year',
-  dateValue: 2025,
-  filters: { 'journalItems.departmentId': deptId },
+## Reports API
+
+```typescript
+const reports = accounting.createReports({ Account, JournalEntry, Budget });
+
+// All reports accept: { organizationId, dateOption, dateValue, filters? }
+await reports.trialBalance({ ... });
+await reports.balanceSheet({ ... });
+await reports.incomeStatement({ ... });
+await reports.generalLedger({ ... });
+await reports.cashFlow({ ... });
+await reports.agedBalance({ type: 'receivable', asOfDate: new Date() });
+await reports.budgetVsActual({ ... });        // requires Budget model
+await reports.dimensionBreakdown({ dimension: 'departmentId', ... });
+await reports.revaluation({ rates: [{ currency: 'USD', rate: 1.40 }], ... });
+```
+
+All report data is sorted by account code. All monetary values are integer cents — use `Money.toDecimal()` at your API boundary.
+
+## Schemas
+
+```typescript
+accounting.createAccountSchema(options?)
+accounting.createJournalEntrySchema(accountModelName, {
+  extraItemFields: { departmentId: { type: ObjectId, ref: 'Department' } },
+})
+accounting.createFiscalPeriodSchema(options?)
+accounting.createBudgetSchema(options?)
+accounting.createReconciliationSchema(accountModelName, journalEntryModelName, options?)
+```
+
+## Plugins
+
+```typescript
+import { dateLockPlugin, taxHookPlugin } from '@classytic/ledger';
+
+// Date lock — block posting before a date
+dateLockPlugin({
+  getLockDate: async (orgId) => db.getOrgLockDate(orgId),
+  JournalEntryModel,
+});
+
+// Tax hook — auto-generate tax lines
+taxHookPlugin({
+  generator: {
+    generateTaxLines(input) {
+      if (!input.taxCode) return [];
+      const tax = Money.percentage(input.amount, 1300); // 13%
+      return [{ account: hstAccountId, debit: 0, credit: tax, taxDetails: [{ taxCode: 'HST' }] }];
+    },
+  },
 });
 ```
 
 ## Subpath Exports
 
-| Import path | Contents |
-|---|---|
-| `@classytic/ledger` | Engine, Money, schemas, plugins, reports, repositories, constants, types |
-| `@classytic/ledger/money` | `Money` class (cents-based arithmetic) |
-| `@classytic/ledger/schemas` | `createAccountSchema`, `createJournalEntrySchema`, `createFiscalPeriodSchema` |
-| `@classytic/ledger/reports` | Report generators (trial balance, balance sheet, etc.) |
-| `@classytic/ledger/plugins` | `doubleEntryPlugin`, `fiscalLockPlugin`, `idempotencyPlugin` |
-| `@classytic/ledger/repositories` | `wireJournalEntryMethods`, `wireAccountMethods` |
-| `@classytic/ledger/exports` | CSV export: `exportToCsv`, `flattenJournalEntries`, field maps |
-| `@classytic/ledger/constants` | Categories, journal types, currencies |
+| Path | Contents |
+|------|----------|
+| `@classytic/ledger` | Engine, Money, all schemas, plugins, reports, types |
+| `@classytic/ledger/money` | `Money` class |
+| `@classytic/ledger/schemas` | Schema factories |
+| `@classytic/ledger/reports` | Report generators |
+| `@classytic/ledger/plugins` | All plugins |
+| `@classytic/ledger/repositories` | Repository wiring |
+| `@classytic/ledger/exports` | CSV export + QuickBooks field maps |
 | `@classytic/ledger/country` | `defineCountryPack`, `CountryPack` interface |
+| `@classytic/ledger/constants` | Categories, journal types, currencies |
+
+## Country Packs
 
-## Documentation
+Build your own or use an existing one:
+
+```typescript
+import { defineCountryPack } from '@classytic/ledger';
+
+export const myPack = defineCountryPack({
+  code: 'US',
+  name: 'United States',
+  defaultCurrency: 'USD',
+  retainedEarningsAccountCode: '3200',
+  accountTypes: [ /* your chart of accounts */ ],
+  taxCodes: { /* your tax codes */ },
+  taxCodesByRegion: {},
+  regions: [],
+});
+```
+
+Available packs: `@classytic/ledger-ca` (Canada), `@classytic/ledger-bd` (Bangladesh).
+
+## Testing
+
+949 tests covering unit, integration, and end-to-end scenarios:
+
+```bash
+npm test                    # run all
+npx vitest run tests/e2e/   # e2e scenarios only
+```
 
-- [Engine & Configuration](docs/engine.md)
-- [Schemas](docs/schemas.md)
-- [Repositories](docs/repositories.md)
-- [Reports](docs/reports.md)
-- [Plugins](docs/plugins.md)
-- [Exports](docs/exports.md)
-- [Country Packs](docs/country-packs.md)
-- [Money](docs/money.md)
-- [Subledger Integration](docs/subledger-integration.md)
+E2E suites include:
+- Canadian small business full-year lifecycle
+- Multi-currency trading with FX revaluation
+- All plugins + dimensions + budgets + fiscal close
+- O-Level / A-Level / university textbook accounting problems
 
 ## Requirements
 
 - Node.js >= 22
 - MongoDB (replica set recommended for transactions)
 - Mongoose >= 9
-- @classytic/mongokit >= 3.3.2
+- @classytic/mongokit >= 3
 
 ## License
 

package/dist/{account.repository-kDKwDt0I.mjs → account.repository-BpkSd6q3.mjs}

@@ -1,5 +1,104 @@
 import { n as Errors } from "./errors-B7yC-Jfw.mjs";
-import { i as requireOrgScope, n as finalizeSession, t as acquireSession } from "./session-Ba8E3Ufa.mjs";
+import { t as requireOrgScope } from "./tenant-guard-Fm6AID_6.mjs";
+//#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 function(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 function(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) 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 function(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/journal-entry.repository.ts
 /** Keys that are either handled explicitly or must not be copied */
 const ITEM_CORE_KEYS = new Set([
@@ -15,12 +114,40 @@ const ITEM_CORE_KEYS = new Set([
 /**
 * 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 - The Mongoose model for journal entries
+* @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) {
+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.
@@ -28,9 +155,10 @@ function wireJournalEntryMethods(repository, JournalEntryModel, orgField, strict
 	repository.post = async function(id, orgId, options = {}) {
 		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for post operations.");
 		requireOrgScope(orgField, orgId);
-		const query = { _id: id };
-		if (orgField && orgId != null) query[orgField] = orgId;
-		const entry = await JournalEntryModel.findOne(query).populate("journalItems.account").session(options.session || null);
+		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");
@@ -40,6 +168,14 @@ function wireJournalEntryMethods(repository, JournalEntryModel, orgField, strict
 		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;
@@ -70,17 +206,12 @@ function wireJournalEntryMethods(repository, JournalEntryModel, orgField, strict
 		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 query = { _id: id };
-		if (orgField && orgId != null) query[orgField] = orgId;
-		const entry = await JournalEntryModel.findOne(query).session(options.session || null);
+		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();
-		if (entry.reversed) {
-			entry.reversed = false;
-			entry.reversedBy = void 0;
-		}
 		await entry.save({ session: options.session });
 		return entry;
 	};
@@ -92,9 +223,7 @@ function wireJournalEntryMethods(repository, JournalEntryModel, orgField, strict
 	repository.archive = async function(id, orgId, options = {}) {
 		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for archive operations.");
 		requireOrgScope(orgField, orgId);
-		const query = { _id: id };
-		if (orgField && orgId != null) query[orgField] = orgId;
-		const entry = await JournalEntryModel.findOne(query).session(options.session || null);
+		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";
@@ -108,9 +237,7 @@ function wireJournalEntryMethods(repository, JournalEntryModel, orgField, strict
 	*/
 	repository.duplicate = async function(id, orgId, options = {}) {
 		requireOrgScope(orgField, orgId);
-		const query = { _id: id };
-		if (orgField && orgId != null) query[orgField] = orgId;
-		const entry = await JournalEntryModel.findOne(query).session(options.session || null);
+		const entry = await findEntry(buildQuery(id, orgId), { session: options.session });
 		if (!entry) throw Errors.notFound("Entry not found");
 		const duplicateData = {
 			journalType: entry.journalType,
@@ -133,15 +260,14 @@ function wireJournalEntryMethods(repository, JournalEntryModel, orgField, strict
 			})
 		};
 		if (orgField && entry[orgField] != null) duplicateData[orgField] = entry[orgField];
-		return await repository.create(duplicateData, options.session ? { session: options.session } : {});
+		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.
 	*
-	* Atomic: creates an internal transaction by default. Pass an external session
-	* to join a caller-managed transaction instead. On standalone MongoDB (no
-	* replica set), falls back to non-atomic execution with a warning.
+	* 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.
@@ -149,12 +275,12 @@ function wireJournalEntryMethods(repository, JournalEntryModel, orgField, strict
 	repository.reverse = async function(id, orgId, options = {}) {
 		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for reverse operations.");
 		requireOrgScope(orgField, orgId);
-		const { session, ownSession } = await acquireSession(JournalEntryModel.db, options.session);
-		let success = false;
-		try {
-			const query = { _id: id };
-			if (orgField && orgId != null) query[orgField] = orgId;
-			const entry = await JournalEntryModel.findOne(query).populate("journalItems.account").session(session || null);
+		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");
@@ -187,20 +313,37 @@ function wireJournalEntryMethods(repository, JournalEntryModel, orgField, strict
 			};
 			if (orgField && entry[orgField] != null) reversalData[orgField] = entry[orgField];
 			if (options.actorId) reversalData.postedBy = options.actorId;
-			const reversalEntry = await repository.create(reversalData, session ? { session } : {});
+			const reversalEntry = await create(reversalData, session ? { session } : {});
 			entry.reversed = true;
-			entry.reversedBy = reversalEntry._id;
+			entry.reversedBy = reversalEntry["_id"];
 			if (options.actorId) entry.reversedByUser = options.actorId;
 			await entry.save({ session });
-			success = true;
 			return {
 				original: entry,
 				reversal: reversalEntry
 			};
-		} finally {
-			await finalizeSession(session, ownSession, success);
-		}
+		};
+		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/account.repository.ts
@@ -384,8 +527,16 @@ function wireAccountMethods(repository, AccountModel, country, orgField) {
 			...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
-export { wireJournalEntryMethods as n, wireAccountMethods as t };
-
-//# sourceMappingURL=account.repository-kDKwDt0I.mjs.map
+export { wireJournalEntryMethods as n, wireReconciliationMethods as r, wireAccountMethods as t };

package/dist/categories-CclX7Q94.mjs

@@ -66,5 +66,3 @@ function extractStatementType(key) {
 }
 //#endregion
 export { extractStatementType as a, getNormalBalance as c, isValidCategory as d, extractMainType as i, isBalanceSheet as l, CATEGORY_KEYS as n, getCategoryMainType as o, categoryKey as r, getCategoryStatementType as s, CATEGORIES as t, isIncomeStatement as u };
-
-//# sourceMappingURL=categories-CclX7Q94.mjs.map

package/dist/core-8Xfnpn6g.d.mts

@@ -100,5 +100,4 @@ interface DateRange {
   endDate: Date;
 }
 //#endregion
-export { TaxMetadata as _, Cents as a, DateRange as c, JournalType as d, MainType as f, TaxDetail as g, StatementType as h, CategoryKey as i, EntryState as l, ObjectId as m, CashFlowCategory as n, Currency as o, NormalBalance as p, Category as r, DateOption as s, AccountType as t, JournalItem as u, TotalAccountOp as v };
-//# sourceMappingURL=core-8Xfnpn6g.d.mts.map
+export { TaxMetadata as _, Cents as a, DateRange as c, JournalType as d, MainType as f, TaxDetail as g, StatementType as h, CategoryKey as i, EntryState as l, ObjectId as m, CashFlowCategory as n, Currency as o, NormalBalance as p, Category as r, DateOption as s, AccountType as t, JournalItem as u, TotalAccountOp as v };

package/dist/country/index.d.mts

@@ -1,2 +1,2 @@
-import { a as TaxReportLine, i as TaxCodesByRegion, n as CountryPackInput, o as TaxReportTemplate, r as TaxCode, s as defineCountryPack, t as CountryPack } from "../index-ZnSiqHYV.mjs";
+import { a as TaxReportLine, i as TaxCodesByRegion, n as CountryPackInput, o as TaxReportTemplate, r as TaxCode, s as defineCountryPack, t as CountryPack } from "../index-CxZqRaOU.mjs";
 export { CountryPack, CountryPackInput, TaxCode, TaxCodesByRegion, TaxReportLine, TaxReportTemplate, defineCountryPack };

package/dist/country/index.mjs

@@ -23,5 +23,3 @@ function defineCountryPack(input) {
 }
 //#endregion
 export { defineCountryPack };
-
-//# sourceMappingURL=index.mjs.map

package/dist/currencies-4WAbFRlw.d.mts

@@ -34,5 +34,4 @@ declare function getCurrency(code: string): Currency | null;
 declare function isValidCurrency(code: string): boolean;
 declare function getMinorUnit(code: string): number;
 //#endregion
-export { getNormalBalance as _, JOURNAL_CODES as a, isValidCategory as b, getJournalTypeCodes as c, CATEGORY_KEYS as d, categoryKey as f, getCategoryStatementType as g, getCategoryMainType as h, isValidCurrency as i, isValidJournalType as l, extractStatementType as m, getCurrency as n, JOURNAL_TYPES as o, extractMainType as p, getMinorUnit as r, getJournalType as s, CURRENCIES as t, CATEGORIES as u, isBalanceSheet as v, isIncomeStatement as y };
-//# sourceMappingURL=currencies-4WAbFRlw.d.mts.map
+export { getNormalBalance as _, JOURNAL_CODES as a, isValidCategory as b, getJournalTypeCodes as c, CATEGORY_KEYS as d, categoryKey as f, getCategoryStatementType as g, getCategoryMainType as h, isValidCurrency as i, isValidJournalType as l, extractStatementType as m, getCurrency as n, JOURNAL_TYPES as o, extractMainType as p, getMinorUnit as r, getJournalType as s, CURRENCIES as t, CATEGORIES as u, isBalanceSheet as v, isIncomeStatement as y };

package/dist/currencies-W8kQAkm0.mjs

@@ -78,5 +78,3 @@ function getMinorUnit(code) {
 }
 //#endregion
 export { isValidCurrency as i, getCurrency as n, getMinorUnit as r, CURRENCIES as t };
-
-//# sourceMappingURL=currencies-W8kQAkm0.mjs.map