@classytic/ledger 0.3.0 → 0.4.1

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

@@ -1,93 +1,187 @@
-import { n as Errors } from "./errors-B7yC-Jfw.mjs";
-import { t as requireOrgScope } from "./tenant-guard-Fm6AID_6.mjs";
-//#region src/repositories/reconciliation.repository.ts
+import { n as Errors } from "./errors-B_dyYZc_.mjs";
+import { t as requireOrgScope } from "./tenant-guard-r17Se3Bb.mjs";
+//#region src/repositories/account.repository.ts
 /**
-* Wire reconciliation methods onto an existing mongokit Repository.
+* Wire seedAccounts, bulkCreate and posting-account validation
+* 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)
+* @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 wireReconciliationMethods(repository, _ReconciliationModel, JournalEntryModel, orgField) {
-	const create = repository.create.bind(repository);
-	const deleteById = repository.delete.bind(repository);
+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.`);
+	});
 	/**
-	* Create a reconciliation record linking matched journal entries.
-	* Validates that all entries exist, are posted, and belong to the same account/org.
+	* Seed standard posting accounts for an organization.
 	*/
-	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()
+	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
 		};
-		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.");
+		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;
 		}
-		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).
+	* 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.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
+	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 (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"
-	]) {
+	if (typeof repository.registerMethod === "function") for (const name of ["seedAccounts", "bulkCreate"]) {
 		const fn = repository[name];
 		try {
 			delete repository[name];
@@ -152,7 +246,7 @@ function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, stric
 	* Post an entry (draft → posted).
 	* Validates items, balance, and accounts before changing state.
 	*/
-	repository.post = async function(id, orgId, options = {}) {
+	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), {
@@ -202,7 +296,7 @@ function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, stric
 	* 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 function(id, orgId, options = {}) {
+	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);
@@ -220,7 +314,7 @@ function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, stric
 	* 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 function(id, orgId, options = {}) {
+	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 });
@@ -235,7 +329,7 @@ function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, stric
 	* Duplicate an entry as a new draft.
 	* Copies journal items, journal type, and label. Assigns today's date.
 	*/
-	repository.duplicate = async function(id, orgId, options = {}) {
+	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");
@@ -272,7 +366,7 @@ function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, stric
 	* Routes the reversal through repository.create() so all plugins (fiscal-lock,
 	* double-entry) enforce policy on the reversal entry.
 	*/
-	repository.reverse = async function(id, orgId, options = {}) {
+	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);
@@ -315,7 +409,7 @@ function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, stric
 			if (options.actorId) reversalData.postedBy = options.actorId;
 			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 });
 			return {
@@ -346,188 +440,94 @@ function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, stric
 	return repository;
 }
 //#endregion
-//#region src/repositories/account.repository.ts
+//#region src/repositories/reconciliation.repository.ts
 /**
-* Wire seedAccounts, bulkCreate and posting-account validation
-* onto an existing mongokit Repository.
+* Wire reconciliation methods 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')
+* - 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 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.`);
-	});
+function wireReconciliationMethods(repository, _ReconciliationModel, JournalEntryModel, orgField) {
+	const create = repository.create.bind(repository);
+	const deleteById = repository.delete.bind(repository);
 	/**
-	* Seed standard posting accounts for an organization.
+	* Create a reconciliation record linking matched journal entries.
+	* Validates that all entries exist, are posted, and belong to the same account/org.
 	*/
-	repository.seedAccounts = async function(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;
+	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);
 	};
 	/**
-	* 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).
+	* Remove a reconciliation record via repository.delete().
 	*/
-	repository.bulkCreate = async function(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;
-			}
+	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.");
 		}
-		return {
-			summary: {
-				total: accounts.length,
-				created: results.created.length,
-				skipped: results.skipped.length,
-				errors: results.errors.length
-			},
-			...results
+		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 ["seedAccounts", "bulkCreate"]) {
+	if (typeof repository.registerMethod === "function") for (const name of [
+		"reconcile",
+		"unreconcile",
+		"getUnreconciled"
+	]) {
 		const fn = repository[name];
 		try {
 			delete repository[name];
@@ -539,4 +539,4 @@ function wireAccountMethods(repository, AccountModel, country, orgField) {
 	return repository;
 }
 //#endregion
-export { wireJournalEntryMethods as n, wireReconciliationMethods as r, wireAccountMethods as t };
+export { wireJournalEntryMethods as n, wireAccountMethods as r, wireReconciliationMethods as t };