@happyvertical/smrt-commerce 0.56.0 → 0.56.2

package/dist/chunks/document-money-oUDvdjOf.js

@@ -0,0 +1,860 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { t as DocumentTaxCollection } from "./DocumentTaxCollection-KOkaQT2M.js";
+import { s as InvoiceStatus } from "./types-Bbm0Xflc.js";
+import { t as CustomerCollection } from "./CustomerCollection-CjGaZSpf.js";
+import { MoneyValidationError, calculateMoneyDocument, resolveLineTaxCode } from "../money.js";
+import { t as allocateFrozenCredit } from "./credit-allocation-yspz0Lab.js";
+import { c as lockDocumentMoneyParents, l as withDocumentMoneyObjectTransaction, o as DOCUMENT_MONEY_WRITE, u as withDocumentMoneyTransaction } from "./TaxSettingsCollection-DYYF-In-.js";
+import { t as InvoiceCollection } from "./InvoiceCollection-BUe_8FT1.js";
+import { n as lockTenantMoneyRuntime, o as withTenantMoneyRuntime, t as lockTenantMoneyMigrationOwner } from "./tenant-money-barrier-y6EAa6vY.js";
+import { r as InvoiceLineItem, t as InvoiceLineItemCollection } from "./InvoiceLineItemCollection-CPQGghyd.js";
+import { t as TaxCodeCollection } from "./TaxCodeCollection-DF2eaJed.js";
+import { t as TaxComponentCollection } from "./TaxComponentCollection-3x24xSNh.js";
+import { getTenantId } from "@happyvertical/smrt-tenancy";
+//#region src/document-money.ts
+var document_money_exports = /* @__PURE__ */ __exportAll({
+	deleteInvoice: () => deleteInvoice,
+	deleteInvoiceLineItem: () => deleteInvoiceLineItem,
+	getInvoiceMoneyFacts: () => getInvoiceMoneyFacts,
+	lockAndReloadInvoice: () => lockAndReloadInvoice,
+	materializeInvoiceMoneyDraft: () => materializeInvoiceMoneyDraft,
+	previewInvoiceMoney: () => previewInvoiceMoney,
+	saveInvoice: () => saveInvoice,
+	saveInvoiceLineItem: () => saveInvoiceLineItem
+});
+var FROZEN_INVOICE_FIELDS = [
+	"kind",
+	"creditedInvoiceId",
+	"tenantId",
+	"customerId",
+	"contractId",
+	"invoiceNumber",
+	"reference",
+	"issueDate",
+	"dueDate",
+	"subtotal",
+	"discountTotal",
+	"taxAmount",
+	"providerTaxAmount",
+	"totalAmount",
+	"currency",
+	"lineAmountType",
+	"taxRoundingScope",
+	"sellerTaxRegistrationsJson",
+	"partyTaxId",
+	"moneySnapshotId",
+	"notes",
+	"customerNotes",
+	"terms"
+];
+var FROZEN_LINE_FIELDS = [
+	"tenantId",
+	"invoiceId",
+	"creditedLineId",
+	"creditCalculationBasisJson",
+	"description",
+	"sku",
+	"productId",
+	"quantity",
+	"unitPrice",
+	"discountType",
+	"discountRate",
+	"discount",
+	"taxMode",
+	"taxCodeId",
+	"taxCodeCode",
+	"taxCodeName",
+	"taxComponentsJson",
+	"taxAmount",
+	"taxRate",
+	"amount",
+	"sourceType",
+	"sourceId",
+	"periodStart",
+	"periodEnd",
+	"revenueAccountId",
+	"sortOrder",
+	"moneySnapshotId"
+];
+function comparable(value) {
+	return value instanceof Date ? value.toISOString() : value ?? null;
+}
+function assertFieldsUnchanged(proposed, persisted, fields, label) {
+	for (const field of fields) if (comparable(proposed[field]) !== comparable(persisted[field])) throw new MoneyValidationError("FROZEN_DOCUMENT", `${label} ${String(field)} is frozen`);
+}
+function assertTenantId(value) {
+	if (!value || value.trim() !== value) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Money v2 requires a tenant-owned invoice");
+}
+function requireId(value, label) {
+	if (!value) throw new MoneyValidationError("INVALID_MONEY_INPUT", `${label} requires a persisted ID`);
+	return value;
+}
+async function lockRuntimeSettings(db, tenantId) {
+	if (!tenantId) return null;
+	return (await lockTenantMoneyRuntime(db, tenantId)).settings;
+}
+function isFrozen(invoice) {
+	return invoice.status !== InvoiceStatus.DRAFT || !!invoice.arJournalId || !!invoice.moneySnapshotId;
+}
+function aggregateSignature(invoice) {
+	return JSON.stringify([
+		invoice.lineAmountType,
+		invoice.taxRoundingScope,
+		invoice.subtotal,
+		invoice.discountTotal,
+		invoice.taxAmount,
+		invoice.totalAmount
+	]);
+}
+async function loadInvoice(db, id) {
+	const collection = await InvoiceCollection.create({ db });
+	const invoice = await collection.get({ id }, { cache: false });
+	if (!invoice) throw new MoneyValidationError("INVALID_MONEY_INPUT", `Invoice ${id} was not found`);
+	return {
+		collection,
+		invoice
+	};
+}
+async function findInvoice(db, id) {
+	return (await InvoiceCollection.create({ db })).get({ id }, { cache: false });
+}
+async function lockAndReloadInvoice(db, invoiceId, tenantId) {
+	const first = await loadInvoice(db, invoiceId);
+	await lockDocumentMoneyParents([{
+		id: invoiceId,
+		tenantId,
+		collection: first.collection
+	}]);
+	const invoice = await first.collection.get({ id: invoiceId }, { cache: false });
+	if (!invoice || invoice.tenantId !== tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice tenant identity changed while acquiring its money lock");
+	return {
+		collection: first.collection,
+		invoice
+	};
+}
+async function lockAndReloadMoneyInvoice(db, invoiceId, tenantId, creditedInvoiceId) {
+	const collection = await InvoiceCollection.create({ db });
+	const ids = [invoiceId, ...creditedInvoiceId ? [creditedInvoiceId] : []];
+	if ((await Promise.all(ids.map((id) => collection.get({ id }, { cache: false })))).some((row) => !row || row.tenantId !== tenantId)) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice money parents must exist in the active tenant");
+	await lockDocumentMoneyParents(ids.map((id) => ({
+		id,
+		tenantId,
+		collection
+	})));
+	const invoice = await collection.get({ id: invoiceId }, { cache: false });
+	const source = creditedInvoiceId ? await collection.get({ id: creditedInvoiceId }, { cache: false }) : null;
+	if (!invoice || invoice.tenantId !== tenantId || source && source.tenantId !== tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice money parent identity changed while acquiring its lock");
+	return {
+		collection,
+		invoice,
+		source
+	};
+}
+function discountInput(line) {
+	if (line.discountType === "percent") return {
+		kind: "percent",
+		rate: String(line.discountRate)
+	};
+	if (line.discountType === "amount" || line.discount !== 0) return {
+		kind: "amount",
+		minor: line.discount
+	};
+	if (line.discountType !== "none") throw new MoneyValidationError("INVALID_MONEY_INPUT", `Unknown discount type: ${line.discountType}`);
+	return { kind: "none" };
+}
+function issuedCredit(invoice) {
+	return invoice.kind === "credit_note" && invoice.status !== InvoiceStatus.DRAFT && invoice.status !== InvoiceStatus.CANCELLED;
+}
+async function refreshIssuedCreditBalance(db, source) {
+	const sourceId = requireId(source.id, "Credited invoice");
+	const credits = await (await InvoiceCollection.create({ db })).list({ where: {
+		tenantId: source.tenantId,
+		creditedInvoiceId: sourceId
+	} });
+	const issued = credits.filter(issuedCredit).sort((left, right) => {
+		const date = left.issueDate.getTime() - right.issueDate.getTime();
+		if (date) return date;
+		return String(left.id) < String(right.id) ? -1 : String(left.id) > String(right.id) ? 1 : 0;
+	});
+	const total = issued.reduce((sum, credit) => sum + credit.totalAmount, 0);
+	if (!Number.isSafeInteger(total) || total < 0) throw new MoneyValidationError("UNSAFE_MONEY", "Issued credit total is not a nonnegative safe integer");
+	let remainingSource = Math.max(0, source.totalAmount - source.amountPaid);
+	for (const credit of credits) {
+		const included = issued.includes(credit);
+		const applied = included ? Math.min(credit.totalAmount, remainingSource) : 0;
+		if (included) remainingSource -= applied;
+		if (credit.creditedAmount !== applied) {
+			credit.creditedAmount = applied;
+			credit.updatePaymentStatus(credit.amountPaid);
+			await credit.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: false });
+		}
+	}
+	source.creditedAmount = total;
+	source.updatePaymentStatus(source.amountPaid);
+	await source.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: false });
+}
+function lineNet(line, parent) {
+	return parent.lineAmountType === "inclusive" ? line.amount - line.taxAmount : line.amount;
+}
+async function prepareCreditLines(db, invoice, lines) {
+	if (!invoice.creditedInvoiceId) throw new MoneyValidationError("CREDIT_TARGET_NOT_ISSUED", "A credit note requires a credited invoice");
+	const sourceInvoice = await findInvoice(db, invoice.creditedInvoiceId);
+	if (sourceInvoice?.kind !== "invoice" || sourceInvoice.tenantId !== invoice.tenantId || sourceInvoice.status === InvoiceStatus.DRAFT || sourceInvoice.status === InvoiceStatus.CANCELLED || !sourceInvoice.moneySnapshotId) throw new MoneyValidationError("CREDIT_TARGET_NOT_ISSUED", "Credit target must be an issued, non-cancelled invoice in the same tenant");
+	if (sourceInvoice.currency !== invoice.currency) throw new MoneyValidationError("CURRENCY_MISMATCH", "Credit note currency must match its credited invoice");
+	if (sourceInvoice.customerId !== invoice.customerId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Credit note customer must match its credited invoice");
+	invoice.lineAmountType = sourceInvoice.lineAmountType;
+	invoice.taxRoundingScope = sourceInvoice.taxRoundingScope;
+	const lineCollection = await InvoiceLineItemCollection.create({ db });
+	const sourceLines = await lineCollection.findByInvoice(requireId(sourceInvoice.id, "Credited invoice"));
+	const sourceTaxes = await (await DocumentTaxCollection.create({ db })).findByDocument(requireId(sourceInvoice.tenantId, "Credited invoice tenant"), "invoice", requireId(sourceInvoice.id, "Credited invoice"));
+	const sourceByLineId = new Map(sourceLines.map((line) => [requireId(line.id, "Credited line"), line]));
+	const priorCredits = (await (await InvoiceCollection.create({ db })).list({ where: {
+		tenantId: invoice.tenantId,
+		creditedInvoiceId: invoice.creditedInvoiceId
+	} })).filter((row) => row.id !== invoice.id && issuedCredit(row));
+	const issuedLines = [];
+	const issuedParentById = new Map(priorCredits.map((row) => [requireId(row.id, "Issued credit note"), row]));
+	const consumptions = [];
+	for (const credit of priorCredits) for (const line of await lineCollection.findByInvoice(requireId(credit.id, "Issued credit note"))) {
+		if (!line.creditedLineId) continue;
+		issuedLines.push(line);
+		const basis = line.creditCalculationBasis;
+		consumptions.push({
+			creditedLineId: line.creditedLineId,
+			quantity: basis?.kind === "quantity" ? basis.quantity : "0",
+			netMinor: lineNet(line, credit),
+			discountMinor: line.discount
+		});
+	}
+	const targeted = lines.filter((line) => line.creditedLineId);
+	const allocation = targeted.length ? allocateFrozenCredit(sourceLines.map((line) => ({
+		id: requireId(line.id, "Credited line"),
+		quantity: String(line.quantity),
+		netMinor: lineNet(line, sourceInvoice),
+		discountMinor: line.discount,
+		unitPrice: line.unitPrice,
+		discountType: line.discountType,
+		discountRate: line.discountRate
+	})), consumptions, targeted.map((line) => {
+		const basis = line.creditCalculationBasis;
+		return basis?.kind === "net_amount" ? {
+			creditedLineId: requireId(line.creditedLineId, "Credited line"),
+			netMinor: basis.netMinor
+		} : {
+			creditedLineId: requireId(line.creditedLineId, "Credited line"),
+			quantity: basis?.kind === "quantity" ? basis.quantity : String(line.quantity)
+		};
+	})) : {
+		allocations: [],
+		exhaustsDocument: false
+	};
+	const allocationByLineId = /* @__PURE__ */ new Map();
+	const targetBySource = new Map(targeted.map((line) => [requireId(line.creditedLineId, "Credited line"), line]));
+	for (const row of allocation.allocations) {
+		const line = targetBySource.get(row.creditedLineId);
+		if (!line) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Credit allocation lost its target line");
+		line.creditCalculationBasis = row.basis;
+		allocationByLineId.set(requireId(line.id, "Credit line"), row);
+	}
+	return {
+		allocationByLineId,
+		sourceByLineId,
+		issuedLines,
+		issuedParentById,
+		sourceInvoice,
+		sourceTaxes,
+		exhaustsDocument: allocation.exhaustsDocument
+	};
+}
+async function recomputeInvoiceAggregate(db, invoice, settings, freezeSnapshotId = "", persist = true, proposedLines) {
+	assertTenantId(invoice.tenantId);
+	const tenantId = invoice.tenantId;
+	const linesCollection = await InvoiceLineItemCollection.create({ db });
+	const codesCollection = await TaxCodeCollection.create({ db });
+	const componentsCollection = await TaxComponentCollection.create({ db });
+	const invoiceId = requireId(invoice.id, "Invoice calculation");
+	const lines = proposedLines ?? await linesCollection.findByInvoice(invoiceId);
+	const credit = invoice.kind === "credit_note" ? await prepareCreditLines(db, invoice, lines) : null;
+	const codes = await codesCollection.list({ where: { tenantId } });
+	const components = await componentsCollection.list({ where: { tenantId } });
+	const componentById = new Map(components.map((row) => [requireId(row.id, "Tax component"), row]));
+	const codeById = new Map(codes.map((row) => [requireId(row.id, "Tax code"), row]));
+	const codeInputs = {};
+	for (const code of codes) {
+		const codeId = requireId(code.id, "Tax code");
+		codeInputs[codeId] = {
+			id: codeId,
+			kind: code.kind,
+			active: code.active,
+			appliesTo: code.appliesTo,
+			components: code.components.map((part) => {
+				const component = componentById.get(part.taxComponentId);
+				if (!component) throw new MoneyValidationError("TAX_CODE_NOT_FOUND", `Tax component ${part.taxComponentId} was not loaded`);
+				return {
+					taxComponentId: requireId(component.id, "Tax component"),
+					percent: component.percent,
+					compound: part.compound
+				};
+			})
+		};
+	}
+	if (credit) for (const source of credit.sourceByLineId.values()) {
+		if (!source.taxCodeId) continue;
+		const frozenKind = credit.sourceTaxes.find((row) => row.taxCodeId === source.taxCodeId)?.kind;
+		codeInputs[source.taxCodeId] = {
+			id: source.taxCodeId,
+			kind: frozenKind ?? (source.taxComponents.length ? "taxable" : "zero-rated"),
+			active: true,
+			appliesTo: "sales",
+			components: source.taxComponents.map((component) => ({
+				taxComponentId: component.taxComponentId,
+				percent: component.percent,
+				compound: false
+			}))
+		};
+	}
+	const exempt = await codesCollection.findByCode("exempt");
+	const outOfScope = await codesCollection.findByCode("out-of-scope");
+	const customers = await CustomerCollection.create({ db });
+	const customer = invoice.customerId ? await customers.get({ id: invoice.customerId }, { cache: false }) : null;
+	if (customer && customer.tenantId !== tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice customer must belong to its tenant");
+	const productIds = [...new Set(lines.filter((line) => !line.creditedLineId).map((line) => line.productId).filter((productId) => !!productId))];
+	const productById = /* @__PURE__ */ new Map();
+	if (productIds.length > 0) {
+		const { ProductCollection } = await import("@happyvertical/smrt-products/collections");
+		const products = await ProductCollection.create({ db });
+		for (const productId of productIds) {
+			const product = await products.get({ id: productId }, { cache: false });
+			if (!product) throw new MoneyValidationError("INVALID_MONEY_INPUT", `Invoice product ${productId} was not found`);
+			if (product.tenantId !== null && product.tenantId !== tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", `Invoice product ${productId} must be global or belong to its tenant`);
+			productById.set(productId, product);
+		}
+	}
+	const resolvedCodes = /* @__PURE__ */ new Map();
+	const calculated = calculateMoneyDocument({
+		currency: invoice.currency,
+		lineAmountType: invoice.lineAmountType,
+		roundingScope: invoice.taxRoundingScope,
+		lines: lines.map((line) => {
+			if (line.tenantId !== tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", `Invoice line ${line.id} must belong to its parent tenant`);
+			const lineId = requireId(line.id, "Invoice line");
+			if (line.creditedLineId) {
+				if (!credit) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Only a credit note may reference a credited line");
+				const source = credit.sourceByLineId.get(line.creditedLineId);
+				const allocation = credit.allocationByLineId.get(lineId);
+				if (!source || !allocation) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Credited line is not part of the frozen source invoice");
+				const taxCode = source.taxCodeId ? codeInputs[source.taxCodeId] ?? null : null;
+				resolvedCodes.set(lineId, source.taxCodeId ? {
+					id: source.taxCodeId,
+					code: source.taxCodeCode,
+					name: source.taxCodeName,
+					kind: taxCode?.kind ?? "zero-rated",
+					components: structuredClone(source.taxComponents)
+				} : null);
+				line.description ||= source.description;
+				line.sku ||= source.sku;
+				line.productId = source.productId;
+				line.revenueAccountId = source.revenueAccountId;
+				if (allocation.basis.kind === "quantity") {
+					line.quantity = Number(allocation.basis.quantity);
+					line.unitPrice = allocation.basis.sourceUnitPrice;
+					line.discountType = allocation.discountMinor ? "amount" : "none";
+					line.discountRate = "0";
+				} else {
+					line.quantity = 1;
+					line.unitPrice = allocation.netMinor ?? allocation.basis.netMinor;
+					line.discountType = "none";
+					line.discountRate = "0";
+				}
+				line.discount = allocation.discountMinor;
+				return {
+					id: lineId,
+					quantity: line.quantity,
+					unitPrice: line.unitPrice,
+					netAmountMinor: allocation.basis.kind === "net_amount" ? allocation.netMinor ?? allocation.basis.netMinor : void 0,
+					discount: allocation.discountMinor ? {
+						kind: "amount",
+						minor: allocation.discountMinor
+					} : { kind: "none" },
+					taxCode
+				};
+			}
+			if (invoice.kind === "invoice" && line.creditCalculationBasis) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Ordinary invoice lines cannot carry a credit calculation basis");
+			if (invoice.kind === "credit_note" && line.taxMode !== "override") throw new MoneyValidationError("INVALID_MONEY_INPUT", "Free-form credit lines require an explicit tax-code override");
+			const resolved = resolveLineTaxCode({
+				lineAmountType: invoice.lineAmountType,
+				lineOverride: line.taxMode === "override" ? line.taxCodeId : null
+			}, {
+				direction: "sales",
+				codes: codeInputs,
+				customerTaxExempt: customer?.taxExempt ?? false,
+				exemptCodeId: exempt?.id,
+				productCodeId: line.productId ? productById.get(line.productId)?.defaultSalesTaxCodeId || null : null,
+				partyCodeId: customer?.defaultTaxCodeId,
+				appDefaultCodeId: settings.defaultSalesTaxCodeId,
+				outOfScopeCodeId: outOfScope?.id
+			});
+			resolvedCodes.set(lineId, resolved.taxCode ? (() => {
+				const code = codeById.get(resolved.taxCode.id);
+				if (!code) throw new MoneyValidationError("TAX_CODE_NOT_FOUND", `Tax code ${resolved.taxCode.id} was not loaded`);
+				return {
+					id: requireId(code.id, "Tax code"),
+					code: code.code,
+					name: code.name,
+					kind: code.kind,
+					components: code.components.map((part) => {
+						const component = componentById.get(part.taxComponentId);
+						if (!component) throw new MoneyValidationError("TAX_CODE_NOT_FOUND", `Tax component ${part.taxComponentId} was not loaded`);
+						return {
+							taxComponentId: part.taxComponentId,
+							name: component.name,
+							percent: component.percent,
+							taxMinor: 0
+						};
+					})
+				};
+			})() : null);
+			return {
+				id: requireId(line.id, "Invoice line"),
+				quantity: line.quantity,
+				unitPrice: line.unitPrice,
+				discount: discountInput(line),
+				taxCode: resolved.taxCode
+			};
+		})
+	});
+	if (credit?.exhaustsDocument) {
+		const resultById = new Map(calculated.lines.map((row) => [row.id, row]));
+		const targeted = lines.filter((line) => !!line.creditedLineId);
+		for (const line of targeted) {
+			const source = credit.sourceByLineId.get(requireId(line.creditedLineId, "Credited line"));
+			const result = resultById.get(requireId(line.id, "Credit line"));
+			if (!source || !result) continue;
+			const prior = credit.issuedLines.filter((candidate) => candidate.creditedLineId === source.id);
+			const priorNet = prior.reduce((sum, candidate) => {
+				const parent = credit.issuedParentById.get(candidate.invoiceId);
+				return sum + (parent ? lineNet(candidate, parent) : 0);
+			}, 0);
+			const desiredNet = lineNet(source, credit.sourceInvoice) - priorNet;
+			const netDelta = desiredNet - result.netMinor;
+			result.netMinor = desiredNet;
+			result.amountMinor += netDelta;
+			for (const sourceComponent of source.taxComponents) {
+				const component = result.components.find((candidate) => candidate.taxComponentId === sourceComponent.taxComponentId);
+				if (!component) continue;
+				const priorTax = prior.reduce((sum, candidate) => sum + (candidate.taxComponents.find((part) => part.taxComponentId === sourceComponent.taxComponentId)?.taxMinor ?? 0), 0);
+				const desiredTax = sourceComponent.taxMinor - priorTax;
+				const taxDelta = desiredTax - component.taxMinor;
+				component.taxMinor = desiredTax;
+				result.taxMinor += taxDelta;
+				if (invoice.lineAmountType === "inclusive") result.amountMinor += taxDelta;
+			}
+		}
+		const rebuilt = /* @__PURE__ */ new Map();
+		for (const result of calculated.lines) {
+			const metadata = resolvedCodes.get(result.id) ?? null;
+			const parts = result.components.length ? result.components : [{
+				taxComponentId: null,
+				taxMinor: 0
+			}];
+			for (const part of parts) {
+				const key = `${metadata?.id ?? ""}\0${part.taxComponentId ?? ""}`;
+				const row = rebuilt.get(key) ?? {
+					taxCodeId: metadata?.id ?? null,
+					taxComponentId: part.taxComponentId,
+					taxableMinor: 0,
+					taxMinor: 0
+				};
+				row.taxableMinor += result.netMinor;
+				row.taxMinor += part.taxMinor;
+				rebuilt.set(key, row);
+			}
+		}
+		calculated.taxes = [...rebuilt.values()].sort((left, right) => {
+			const a = `${left.taxCodeId ?? ""}\0${left.taxComponentId ?? ""}`;
+			const b = `${right.taxCodeId ?? ""}\0${right.taxComponentId ?? ""}`;
+			return a < b ? -1 : a > b ? 1 : 0;
+		});
+		calculated.subtotalMinor = calculated.lines.reduce((sum, row) => sum + row.netMinor, 0);
+		calculated.taxMinor = calculated.lines.reduce((sum, row) => sum + row.taxMinor, 0);
+		calculated.totalMinor = calculated.subtotalMinor + calculated.taxMinor;
+	}
+	if (credit) {
+		const resultById = new Map(calculated.lines.map((row) => [row.id, row]));
+		for (const [lineId, allocation] of credit.allocationByLineId) {
+			if (allocation.basis.kind !== "quantity") continue;
+			const result = resultById.get(lineId);
+			const hasAmountBasisConsumption = credit.issuedLines.some((line) => line.creditedLineId === allocation.creditedLineId && line.creditCalculationBasis?.kind === "net_amount");
+			if (result && Math.abs(result.netMinor) > Math.abs(allocation.remainingNetMinor) && (!allocation.exhaustsLine || hasAmountBasisConsumption)) throw new MoneyValidationError("CREDIT_EXCEEDS_LINE", "Credit quantity exceeds the remaining frozen net amount");
+		}
+	}
+	const lineById = new Map(lines.map((line) => [requireId(line.id, "Invoice line"), line]));
+	for (const result of calculated.lines) {
+		const line = lineById.get(result.id);
+		if (!line) throw new MoneyValidationError("INVALID_MONEY_INPUT", `Calculated line ${result.id} was not loaded`);
+		const code = resolvedCodes.get(requireId(line.id, "Invoice line")) ?? null;
+		line.discount = result.discountMinor;
+		line.amount = result.amountMinor;
+		line.taxAmount = result.taxMinor;
+		line.taxCodeId = code?.id ?? null;
+		line.taxCodeCode = code?.code ?? null;
+		line.taxCodeName = code?.name ?? null;
+		line.taxComponents = result.components.map((entry) => {
+			const component = code?.components.find((candidate) => candidate.taxComponentId === entry.taxComponentId);
+			if (!component) throw new MoneyValidationError("TAX_CODE_NOT_FOUND", `Calculated component ${entry.taxComponentId} was not loaded`);
+			return {
+				taxComponentId: component.taxComponentId,
+				name: component.name,
+				percent: component.percent,
+				taxMinor: entry.taxMinor
+			};
+		});
+		line.taxRate = code ? code.components.reduce((sum, part) => sum + Number(part.percent) / 100, 0) : 0;
+		if (freezeSnapshotId) line.moneySnapshotId = freezeSnapshotId;
+		if (persist) await line.saveDerived(DOCUMENT_MONEY_WRITE, false);
+	}
+	const taxRows = calculated.taxes.map((tax) => {
+		const code = tax.taxCodeId ? [...resolvedCodes.values()].find((candidate) => candidate?.id === tax.taxCodeId) ?? null : null;
+		const snapshotComponent = tax.taxComponentId ? code?.components.find((candidate) => candidate.taxComponentId === tax.taxComponentId) : null;
+		const currentComponent = tax.taxComponentId ? componentById.get(tax.taxComponentId) : null;
+		const sourceTax = credit?.sourceTaxes.find((row) => row.taxCodeId === tax.taxCodeId && row.taxComponentId === tax.taxComponentId);
+		if (tax.taxCodeId && !code) throw new MoneyValidationError("TAX_CODE_NOT_FOUND", `Document tax code ${tax.taxCodeId} was not loaded`);
+		if (tax.taxComponentId && !snapshotComponent) throw new MoneyValidationError("TAX_CODE_NOT_FOUND", `Document tax component ${tax.taxComponentId} was not loaded`);
+		return {
+			tenantId,
+			documentType: invoice.kind,
+			documentId: invoiceId,
+			currency: invoice.currency,
+			taxCodeId: code ? requireId(code.id, "Tax code") : null,
+			taxCodeCode: code?.code ?? null,
+			kind: code?.kind ?? null,
+			taxComponentId: snapshotComponent?.taxComponentId ?? null,
+			taxComponentName: snapshotComponent?.name ?? null,
+			percent: snapshotComponent?.percent ?? null,
+			liabilityAccountId: sourceTax?.liabilityAccountId || currentComponent?.liabilityAccountId || null,
+			taxableMinor: tax.taxableMinor,
+			taxMinor: tax.taxMinor,
+			recoverableMinor: 0
+		};
+	});
+	if (persist) await (await DocumentTaxCollection.create({ db })).replaceDerivedForDocument(DOCUMENT_MONEY_WRITE, {
+		tenantId,
+		documentType: invoice.kind,
+		documentId: invoiceId,
+		rows: taxRows
+	});
+	invoice.subtotal = calculated.subtotalMinor;
+	invoice.discountTotal = calculated.discountTotalMinor;
+	invoice.taxAmount = calculated.taxMinor + invoice.providerTaxAmount;
+	invoice.totalAmount = calculated.totalMinor + invoice.providerTaxAmount;
+	return {
+		lines,
+		taxRows
+	};
+}
+async function previewInvoiceMoneyOnScope(input, settings) {
+	if (!input.tenantId || getTenantId() !== input.tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice preview requires its active principal tenant");
+	const { invoice } = await loadInvoice(input.db, input.invoiceId);
+	if (invoice.tenantId !== input.tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice preview cannot cross tenant boundaries");
+	if (invoice.status !== InvoiceStatus.DRAFT || invoice.moneySnapshotId) throw new MoneyValidationError("FROZEN_DOCUMENT", "Frozen invoice money cannot be previewed as a proposed draft");
+	const proposedHeader = input.draft?.header;
+	if (proposedHeader) {
+		for (const field of [
+			"currency",
+			"lineAmountType",
+			"taxRoundingScope",
+			"providerTaxAmount",
+			"customerId"
+		]) if (proposedHeader[field] !== void 0) invoice[field] = proposedHeader[field];
+	}
+	const storedLines = await (await InvoiceLineItemCollection.create({ db: input.db })).findByInvoice(input.invoiceId);
+	const storedById = new Map(storedLines.map((line) => [line.id, line]));
+	const providedIds = input.draft?.lines?.map((line) => line.id).filter((id) => !!id) ?? [];
+	if (new Set(providedIds).size !== providedIds.length) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice preview line ids must be distinct");
+	const unknownId = providedIds.find((id) => !storedById.has(id));
+	if (unknownId) throw new MoneyValidationError("INVALID_MONEY_INPUT", `Invoice preview line ${unknownId} was not found on the invoice`);
+	const proposedLines = input.draft?.lines ? input.draft.lines.map((proposed) => {
+		const result = (proposed.id ? storedById.get(proposed.id) : void 0) ?? new InvoiceLineItem();
+		for (const field of [
+			"description",
+			"productId",
+			"quantity",
+			"unitPrice",
+			"discountType",
+			"discountRate",
+			"discount",
+			"taxMode",
+			"taxCodeId"
+		]) if (proposed[field] !== void 0) result[field] = proposed[field];
+		result.id ||= crypto.randomUUID();
+		result.invoiceId = input.invoiceId;
+		result.tenantId = input.tenantId;
+		return result;
+	}) : storedLines;
+	const calculated = await recomputeInvoiceAggregate(input.db, invoice, settings, "", false, proposedLines);
+	return {
+		source: "calculated",
+		header: {
+			currency: invoice.currency,
+			lineAmountType: invoice.lineAmountType,
+			taxRoundingScope: invoice.taxRoundingScope,
+			subtotalMinor: invoice.subtotal,
+			discountTotalMinor: invoice.discountTotal,
+			taxAmountMinor: invoice.taxAmount,
+			providerTaxAmountMinor: invoice.providerTaxAmount,
+			totalAmountMinor: invoice.totalAmount
+		},
+		lines: calculated.lines.map((line) => ({
+			id: requireId(line.id, "Preview line"),
+			grossMinor: line.amount + line.discount,
+			discountMinor: line.discount,
+			amountMinor: line.amount,
+			taxMinor: line.taxAmount,
+			taxCodeId: line.taxCodeId,
+			taxCodeCode: line.taxCodeCode,
+			taxCodeName: line.taxCodeName,
+			taxComponents: structuredClone(line.taxComponents)
+		})),
+		taxes: calculated.taxRows
+	};
+}
+async function previewInvoiceMoney(input) {
+	return withTenantMoneyRuntime(input.db, input.tenantId, "v2", async (scope) => previewInvoiceMoneyOnScope({
+		...input,
+		db: scope.db
+	}, scope.barrier.settings));
+}
+async function getInvoiceMoneyFactsOnScope(input) {
+	if (!input.tenantId || getTenantId() !== input.tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice money facts require their active principal tenant");
+	const { invoice } = await loadInvoice(input.db, input.invoiceId);
+	if (invoice.tenantId !== input.tenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice money facts cannot cross tenant boundaries");
+	const lines = await (await InvoiceLineItemCollection.create({ db: input.db })).findByInvoice(input.invoiceId);
+	const taxes = await (await DocumentTaxCollection.create({ db: input.db })).findByDocument(input.tenantId, invoice.kind, input.invoiceId);
+	return {
+		source: "stored",
+		invoiceId: input.invoiceId,
+		moneySnapshotId: invoice.moneySnapshotId,
+		kind: invoice.kind,
+		status: invoice.status,
+		header: {
+			currency: invoice.currency,
+			lineAmountType: invoice.lineAmountType,
+			taxRoundingScope: invoice.taxRoundingScope,
+			subtotalMinor: invoice.subtotal,
+			discountTotalMinor: invoice.discountTotal,
+			taxAmountMinor: invoice.taxAmount,
+			providerTaxAmountMinor: invoice.providerTaxAmount,
+			totalAmountMinor: invoice.totalAmount
+		},
+		lines: lines.map((line) => ({
+			id: requireId(line.id, "Invoice line"),
+			grossMinor: line.amount + line.discount,
+			discountMinor: line.discount,
+			amountMinor: line.amount,
+			taxMinor: line.taxAmount,
+			taxCodeId: line.taxCodeId,
+			taxCodeCode: line.taxCodeCode,
+			taxCodeName: line.taxCodeName,
+			taxComponents: structuredClone(line.taxComponents)
+		})),
+		taxes: taxes.map((row) => ({
+			tenantId: requireId(row.tenantId, "Document tax tenant"),
+			documentType: row.documentType,
+			documentId: row.documentId,
+			currency: row.currency,
+			taxCodeId: row.taxCodeId,
+			taxCodeCode: row.taxCodeCode,
+			kind: row.kind,
+			taxComponentId: row.taxComponentId,
+			taxComponentName: row.taxComponentName,
+			percent: row.percent,
+			liabilityAccountId: row.liabilityAccountId,
+			taxableMinor: row.taxableMinor,
+			taxMinor: row.taxMinor,
+			recoverableMinor: row.recoverableMinor
+		}))
+	};
+}
+async function getInvoiceMoneyFacts(input) {
+	return withTenantMoneyRuntime(input.db, input.tenantId, "v2", async (scope) => getInvoiceMoneyFactsOnScope({
+		...input,
+		db: scope.db
+	}));
+}
+async function saveInvoice(input) {
+	const priorRevision = input.updated_at;
+	try {
+		return await withDocumentMoneyTransaction(input.db, async (tx) => input.withDatabase(tx, async (invoice) => {
+			if (invoice.kind !== "invoice" && invoice.kind !== "credit_note") throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice kind must be invoice or credit_note");
+			if (invoice.kind === "invoice" && invoice.creditedInvoiceId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Only a credit note may reference a credited invoice");
+			if (invoice.kind === "credit_note" && !invoice.creditedInvoiceId) throw new MoneyValidationError("CREDIT_TARGET_NOT_ISSUED", "A credit note requires a credited invoice");
+			const candidateTenantId = getTenantId() ?? invoice.tenantId ?? null;
+			const settings = await lockRuntimeSettings(tx, candidateTenantId);
+			const existing = invoice.id ? await findInvoice(tx, invoice.id) : null;
+			const tenantId = existing?.tenantId ?? candidateTenantId;
+			if (candidateTenantId && existing?.tenantId && existing.tenantId !== candidateTenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice tenant does not match its active money barrier");
+			if (settings?.moneyModel !== "v2") return invoice.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: true });
+			assertTenantId(tenantId);
+			if (!existing) {
+				invoice.tenantId = tenantId;
+				invoice.creditedAmount = 0;
+				let source = null;
+				if (invoice.kind === "credit_note") {
+					source = await findInvoice(tx, requireId(invoice.creditedInvoiceId, "Credited invoice"));
+					if (!source || source.tenantId !== tenantId) throw new MoneyValidationError("CREDIT_TARGET_NOT_ISSUED", "Credit target must exist in the active tenant");
+					await lockDocumentMoneyParents([{
+						id: requireId(source.id, "Credited invoice"),
+						tenantId,
+						collection: await InvoiceCollection.create({ db: tx })
+					}]);
+					if (source.kind !== "invoice" || source.status === InvoiceStatus.DRAFT || source.status === InvoiceStatus.CANCELLED || !source.moneySnapshotId) throw new MoneyValidationError("CREDIT_TARGET_NOT_ISSUED", "Credit target must be an issued, non-cancelled invoice");
+					if (invoice.currency !== source.currency || invoice.customerId !== source.customerId) throw new MoneyValidationError(invoice.currency !== source.currency ? "CURRENCY_MISMATCH" : "INVALID_MONEY_INPUT", "Credit note currency and customer must match its source invoice");
+				}
+				invoice.lineAmountType = invoice.kind === "credit_note" && source ? source.lineAmountType : settings.defaultLineAmountType;
+				invoice.taxRoundingScope = invoice.kind === "credit_note" && source ? source.taxRoundingScope : settings.taxRoundingScope;
+				invoice.subtotal = 0;
+				invoice.discountTotal = 0;
+				invoice.taxAmount = invoice.providerTaxAmount;
+				invoice.totalAmount = invoice.providerTaxAmount;
+				if (invoice.status !== InvoiceStatus.DRAFT || invoice.arJournalId) {
+					const customers = await CustomerCollection.create({ db: tx });
+					const customer = invoice.customerId ? await customers.get({ id: invoice.customerId }, { cache: false }) : null;
+					invoice.moneySnapshotId = crypto.randomUUID();
+					invoice.sellerTaxRegistrations = structuredClone(settings.taxRegistrations);
+					invoice.partyTaxId = customer?.taxId ?? "";
+				}
+				return invoice.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: false });
+			}
+			if (invoice.tenantId !== existing.tenantId) throw new MoneyValidationError("FROZEN_DOCUMENT", "Invoice tenant identity cannot change");
+			if (invoice.kind !== existing.kind || invoice.creditedInvoiceId !== existing.creditedInvoiceId) throw new MoneyValidationError("FROZEN_DOCUMENT", "Invoice kind and credited invoice identity are immutable");
+			const locked = await lockAndReloadMoneyInvoice(tx, requireId(existing.id, "Invoice"), tenantId, existing.creditedInvoiceId);
+			invoice.creditedAmount = locked.invoice.creditedAmount;
+			if (isFrozen(locked.invoice)) {
+				if (invoice.arReversalJournalId !== locked.invoice.arReversalJournalId) throw new MoneyValidationError("FROZEN_DOCUMENT", "Invoice reversal journal identity is server-managed");
+				if (locked.invoice.arJournalId && invoice.arJournalId !== locked.invoice.arJournalId) throw new MoneyValidationError("FROZEN_DOCUMENT", "Invoice revenue journal identity is frozen once assigned");
+				if (invoice.status === InvoiceStatus.CANCELLED && locked.invoice.status !== InvoiceStatus.CANCELLED && locked.invoice.kind === "invoice" && locked.invoice.isPaid()) throw new MoneyValidationError("FROZEN_DOCUMENT", "A paid invoice cannot be cancelled");
+				if (invoice.status === InvoiceStatus.CANCELLED && locked.invoice.status !== InvoiceStatus.CANCELLED && locked.invoice.kind === "credit_note" && locked.invoice.amountPaid > 0) throw new MoneyValidationError("FROZEN_DOCUMENT", "A refunded credit note cannot be cancelled");
+				if (invoice.status === InvoiceStatus.CANCELLED && locked.invoice.status !== InvoiceStatus.CANCELLED && locked.invoice.arJournalId && !locked.invoice.arReversalJournalId) throw new MoneyValidationError("FROZEN_DOCUMENT", "A posted money-v2 invoice requires an atomic reversal before cancellation");
+				assertFieldsUnchanged(invoice, locked.invoice, FROZEN_INVOICE_FIELDS, "Invoice");
+				const saved2 = await invoice.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: false });
+				if (locked.source) await refreshIssuedCreditBalance(tx, locked.source);
+				return saved2;
+			}
+			const freezing = invoice.status !== InvoiceStatus.DRAFT || !!invoice.arJournalId;
+			const snapshotId = freezing ? locked.invoice.moneySnapshotId || crypto.randomUUID() : "";
+			await recomputeInvoiceAggregate(tx, invoice, settings, snapshotId);
+			if (freezing) {
+				const customers = await CustomerCollection.create({ db: tx });
+				const customer = invoice.customerId ? await customers.get({ id: invoice.customerId }, { cache: false }) : null;
+				invoice.sellerTaxRegistrations = structuredClone(settings.taxRegistrations);
+				invoice.partyTaxId = customer?.taxId ?? "";
+				invoice.moneySnapshotId = snapshotId;
+			}
+			const saved = await invoice.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: false });
+			if (locked.source) await refreshIssuedCreditBalance(tx, locked.source);
+			return saved;
+		}));
+	} catch (error) {
+		input.updated_at = priorRevision;
+		throw error;
+	}
+}
+async function materializeInvoiceMoneyDraft(input) {
+	const settings = await lockTenantMoneyMigrationOwner(input.db, input.tenantId, input.migrationId);
+	const { invoice } = await lockAndReloadInvoice(input.db, input.invoiceId, input.tenantId);
+	if (isFrozen(invoice)) throw new MoneyValidationError("FROZEN_DOCUMENT", "Only an unfrozen draft invoice can be migration-recomputed");
+	const result = await recomputeInvoiceAggregate(input.db, invoice, settings);
+	await invoice.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: false });
+	return {
+		invoiceId: input.invoiceId,
+		taxRows: result.taxRows
+	};
+}
+async function saveInvoiceLineItem(input) {
+	return withDocumentMoneyObjectTransaction(input, async (line, tx) => {
+		const candidateTenantId = getTenantId() ?? line.tenantId ?? null;
+		const settings = await lockRuntimeSettings(tx, candidateTenantId);
+		if (settings?.moneyModel !== "v2") return line.saveDerived(DOCUMENT_MONEY_WRITE, true);
+		const persisted = line.id ? await (await InvoiceLineItemCollection.create({ db: tx })).get({ id: line.id }, { cache: false }) : null;
+		const parentId = persisted?.invoiceId ?? line.invoiceId;
+		const first = await loadInvoice(tx, parentId);
+		if (candidateTenantId && first.invoice.tenantId !== candidateTenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice line tenant does not match its active money barrier");
+		assertTenantId(first.invoice.tenantId);
+		const { invoice, source } = await lockAndReloadMoneyInvoice(tx, parentId, first.invoice.tenantId, first.invoice.creditedInvoiceId);
+		if (persisted && line.invoiceId !== persisted.invoiceId) throw new MoneyValidationError("FROZEN_DOCUMENT", "Invoice line cannot move between parents");
+		line.invoiceId = requireId(invoice.id, "Invoice");
+		line.tenantId = invoice.tenantId;
+		if (invoice.kind === "invoice" && line.creditedLineId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Ordinary invoice lines cannot reference credited lines");
+		if (invoice.kind === "credit_note" && line.creditedLineId && (!source || source.id !== invoice.creditedInvoiceId)) throw new MoneyValidationError("CREDIT_TARGET_NOT_ISSUED", "Credit source changed while saving its line");
+		if (isFrozen(invoice)) {
+			if (!persisted) throw new MoneyValidationError("FROZEN_DOCUMENT", "Cannot add a line to a frozen invoice");
+			assertFieldsUnchanged(line, persisted, FROZEN_LINE_FIELDS, "Invoice line");
+			return line.saveDerived(DOCUMENT_MONEY_WRITE, false);
+		}
+		await line.saveDerived(DOCUMENT_MONEY_WRITE, false);
+		const priorAggregate = aggregateSignature(invoice);
+		await recomputeInvoiceAggregate(tx, invoice, settings);
+		if (aggregateSignature(invoice) !== priorAggregate) await invoice.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: false });
+		const refreshed = await (await InvoiceLineItemCollection.create({ db: tx })).get({ id: requireId(line.id, "Invoice line") }, { cache: false });
+		if (refreshed) for (const field of [
+			"discount",
+			"amount",
+			"taxAmount",
+			"taxRate",
+			"taxCodeId",
+			"taxCodeCode",
+			"taxCodeName",
+			"taxComponentsJson",
+			"moneySnapshotId",
+			"updated_at"
+		]) line[field] = refreshed[field];
+		return line;
+	});
+}
+async function deleteInvoiceLineItem(input, options) {
+	await withDocumentMoneyTransaction(input.db, async (tx) => input.withDatabase(tx, async (line) => {
+		const candidateTenantId = getTenantId() ?? line.tenantId ?? null;
+		const settings = await lockRuntimeSettings(tx, candidateTenantId);
+		const persisted = line.id ? await (await InvoiceLineItemCollection.create({ db: tx })).get({ id: line.id }, { cache: false }) : null;
+		if (!persisted) return;
+		const first = await loadInvoice(tx, persisted.invoiceId);
+		if (candidateTenantId && first.invoice.tenantId !== candidateTenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice line tenant does not match its active money barrier");
+		if (settings?.moneyModel !== "v2") {
+			await line.deleteDerived(DOCUMENT_MONEY_WRITE, options);
+			return;
+		}
+		assertTenantId(first.invoice.tenantId);
+		const { invoice } = await lockAndReloadInvoice(tx, persisted.invoiceId, first.invoice.tenantId);
+		if (isFrozen(invoice)) throw new MoneyValidationError("FROZEN_DOCUMENT", "Cannot delete a line from a frozen invoice");
+		await line.deleteDerived(DOCUMENT_MONEY_WRITE, options);
+		const priorAggregate = aggregateSignature(invoice);
+		await recomputeInvoiceAggregate(tx, invoice, settings);
+		if (aggregateSignature(invoice) !== priorAggregate) await invoice.saveDerived(DOCUMENT_MONEY_WRITE, { recomputeLegacy: false });
+	}));
+}
+async function deleteInvoice(input, options) {
+	await withDocumentMoneyTransaction(input.db, async (tx) => input.withDatabase(tx, async (invoice) => {
+		const candidateTenantId = getTenantId() ?? invoice.tenantId ?? null;
+		const settings = await lockRuntimeSettings(tx, candidateTenantId);
+		const persisted = invoice.id ? await findInvoice(tx, invoice.id) : null;
+		if (!persisted) return;
+		if (candidateTenantId && persisted.tenantId !== candidateTenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice tenant does not match its active money barrier");
+		if (settings?.moneyModel === "v2" && isFrozen(persisted)) throw new MoneyValidationError("FROZEN_DOCUMENT", "Cannot delete a frozen invoice");
+		if (settings?.moneyModel === "v2") {
+			assertTenantId(persisted.tenantId);
+			const persistedId = requireId(persisted.id, "Invoice");
+			await lockAndReloadInvoice(tx, persistedId, persisted.tenantId);
+			await (await DocumentTaxCollection.create({ db: tx })).replaceDerivedForDocument(DOCUMENT_MONEY_WRITE, {
+				tenantId: persisted.tenantId,
+				documentType: "invoice",
+				documentId: persistedId,
+				rows: []
+			});
+		}
+		await invoice.deleteDerived(DOCUMENT_MONEY_WRITE, options);
+	}));
+}
+//#endregion
+export { previewInvoiceMoney as a, materializeInvoiceMoneyDraft as i, getInvoiceMoneyFacts as n, lockAndReloadInvoice as r, document_money_exports as t };
+
+//# sourceMappingURL=document-money-oUDvdjOf.js.map