@happyvertical/smrt-commerce 0.57.3 → 0.57.5

package/dist/chunks/DocumentTaxCollection-C6cI5U89.js

@@ -0,0 +1,4395 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { i as CustomerType, n as ContractType, p as VendorStatus, r as CustomerStatus, s as InvoiceStatus, t as ContractStatus } from "./types-Bbm0Xflc.js";
+import { MoneyValidationError, assertIntegerMinorUnits, calculateMoneyDocument, resolveLineTaxCode } from "../money.js";
+import { n as withHistoricalCommerceWrite, t as assertHistoricalCommerceWrite } from "./historical-commerce-internal-C9ButfuH.js";
+import { t as allocateFrozenCredit } from "./credit-allocation-yspz0Lab.js";
+import { _ as withDocumentMoneyTransaction, a as assertCommerceMoneySchemaCurrent, f as DOCUMENT_MONEY_READ_REBIND, g as withDocumentMoneyObjectTransaction, h as lockDocumentMoneyParents, p as DOCUMENT_MONEY_WRITE } from "./detect-DAE-_NAk.js";
+import { s as parseInvoiceRetention, t as InvoiceCollection } from "./InvoiceCollection-BolwughC.js";
+import { n as withTenantMoneyCollectionRead, r as withTenantMoneyRuntime, t as lockTenantMoneyRuntime } from "./tenant-money-barrier-DEVLrpaB.js";
+import { t as TaxCodeCollection } from "./TaxCodeCollection-CW-tWjkU.js";
+import { t as ContractLineItemCollection } from "./ContractLineItemCollection-D5hBzrct.js";
+import { t as TaxComponentCollection } from "./TaxComponentCollection-BiJ9aAe8.js";
+import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, smrt } from "@happyvertical/smrt-core";
+import { TenantScoped, getTenantId, queryGlobal, queryWithGlobals, tenantId, withTenant } from "@happyvertical/smrt-tenancy";
+import { ISO_4217_MINOR_UNITS } from "@happyvertical/smrt-ui/currency";
+import { createHash } from "node:crypto";
+//#region src/party-contacts.ts
+var DEFAULT_PARTY_CONTACT_FIELD_NAMES = {
+	contactId: "contactId",
+	contactName: "contactName",
+	contactLabel: "contactLabel",
+	contactEmail: "contactEmail",
+	contactPhone: "contactPhone",
+	contactAddress: "contactAddress",
+	contactCount: "contactCount"
+};
+var PARTY_CONTACT_MAX_LENGTHS = {
+	name: 160,
+	label: 80,
+	email: 320,
+	phone: 80,
+	address: 500
+};
+var FIELDS = [
+	"name",
+	"label",
+	"email",
+	"phone",
+	"address"
+];
+var PartyContactValidationError = class extends Error {
+	/** Errors aligned with the submitted rows; `undefined` for a valid row. */
+	errors;
+	constructor(errors) {
+		super("One or more contact rows are invalid");
+		this.name = "PartyContactValidationError";
+		this.errors = errors;
+	}
+};
+var PartyContactPayloadError = class extends Error {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "PartyContactPayloadError";
+		this.reason = reason;
+	}
+};
+var PartyContactPartyNotFoundError = class extends Error {
+	constructor(partyId) {
+		super(`Customer or vendor ${partyId} was not found`);
+		this.name = "PartyContactPartyNotFoundError";
+	}
+};
+function text$2(value) {
+	return typeof value === "string" ? value : "";
+}
+function normalizePartyContacts(value) {
+	let input = value;
+	if (typeof input === "string") try {
+		input = JSON.parse(input);
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(input)) return [];
+	const contacts = [];
+	for (const entry of input) {
+		if (!entry || typeof entry !== "object") continue;
+		const row = entry;
+		contacts.push({
+			id: text$2(row.id) || globalThis.crypto.randomUUID(),
+			name: text$2(row.name),
+			label: text$2(row.label),
+			email: text$2(row.email),
+			phone: text$2(row.phone),
+			address: text$2(row.address)
+		});
+	}
+	return contacts;
+}
+function readPartyContactRows(form, fieldNames = {}) {
+	const names = {
+		...DEFAULT_PARTY_CONTACT_FIELD_NAMES,
+		...fieldNames
+	};
+	const column = (name) => form.getAll(name).map(text$2);
+	const columns = {
+		id: column(names.contactId),
+		name: column(names.contactName),
+		label: column(names.contactLabel),
+		email: column(names.contactEmail),
+		phone: column(names.contactPhone),
+		address: column(names.contactAddress)
+	};
+	const markers = column(names.contactCount);
+	if (markers.length !== 1) throw new PartyContactPayloadError(markers.length === 0 ? "missing" : "misaligned", markers.length === 0 ? `Contact payload has no ${names.contactCount} marker; the contact fields were not posted under these names` : `Contact payload has ${markers.length} ${names.contactCount} markers`);
+	const count = columns.id.length;
+	if (markers[0] !== String(count)) throw new PartyContactPayloadError("misaligned", `Contact payload is misaligned: ${names.contactCount} is ${markers[0]} but ${count} contact ids were posted`);
+	for (const [key, values] of Object.entries(columns)) if (values.length !== count) throw new PartyContactPayloadError("misaligned", `Contact payload is misaligned: ${count} contact ids but ${values.length} ${key} values`);
+	return columns.id.map((id, index) => ({
+		id,
+		name: columns.name[index],
+		label: columns.label[index],
+		email: columns.email[index],
+		phone: columns.phone[index],
+		address: columns.address[index]
+	}));
+}
+function defaultParseRemoveIntent(intent) {
+	const match = /^removeContact:(\d+)$/.exec(intent);
+	return match ? Number(match[1]) : void 0;
+}
+function applyPartyContactIntent(rows, intent, intents = {}) {
+	if (intent === (intents.addIntent ?? "addContact")) return {
+		contacts: [...rows, {}],
+		handled: true
+	};
+	const index = (intents.parseRemoveIntent ?? defaultParseRemoveIntent)(intent);
+	if (index !== void 0) return {
+		contacts: rows.filter((_, position) => position !== index),
+		handled: true
+	};
+	return {
+		contacts: [...rows],
+		handled: false
+	};
+}
+var EMAIL = /^[^\s@]+@[^\s@]+$/;
+function validatePartyContactRows(rows) {
+	const contacts = [];
+	const errors = [];
+	let invalid = false;
+	rows.forEach((row, index) => {
+		const trimmed = { id: text$2(row.id).trim() };
+		let rowErrors;
+		for (const field of FIELDS) {
+			const value = text$2(row[field]).trim();
+			trimmed[field] = value;
+			if (value.length > PARTY_CONTACT_MAX_LENGTHS[field]) rowErrors = {
+				...rowErrors,
+				[field]: "too_long"
+			};
+		}
+		if (trimmed.email && !rowErrors?.email && !EMAIL.test(trimmed.email)) rowErrors = {
+			...rowErrors,
+			email: "invalid_email"
+		};
+		errors[index] = rowErrors;
+		if (rowErrors) invalid = true;
+		if (FIELDS.some((field) => trimmed[field])) contacts.push(trimmed);
+	});
+	return invalid ? {
+		contacts,
+		errors
+	} : { contacts };
+}
+async function savePartyContacts(collection, partyId, posted, options = {}) {
+	const rows = Array.isArray(posted) ? posted : readPartyContactRows(posted, options.fieldNames);
+	const party = await collection.get({ id: partyId });
+	if (!party || options.expectedTenantId !== void 0 && party.tenantId !== options.expectedTenantId) throw new PartyContactPartyNotFoundError(partyId);
+	const validation = validatePartyContactRows(rows);
+	const { contacts } = validation;
+	const errors = validation.errors ?? rows.map(() => void 0);
+	const saved = new Set(normalizePartyContacts(party.contacts).map((c) => c.id));
+	let invalid = validation.errors !== void 0;
+	rows.forEach((row, index) => {
+		const id = text$2(row.id).trim();
+		if (id && !saved.has(id)) {
+			errors[index] = {
+				...errors[index],
+				id: "unknown_contact"
+			};
+			invalid = true;
+		}
+	});
+	if (invalid) throw new PartyContactValidationError(errors);
+	const seen = /* @__PURE__ */ new Set();
+	party.contacts = contacts.map((row) => {
+		const id = row.id && !seen.has(row.id) ? row.id : globalThis.crypto.randomUUID();
+		seen.add(id);
+		return {
+			id,
+			name: row.name ?? "",
+			label: row.label ?? "",
+			email: row.email ?? "",
+			phone: row.phone ?? "",
+			address: row.address ?? ""
+		};
+	});
+	await party.save();
+	return party.contacts;
+}
+//#endregion
+//#region src/models/Customer.ts
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass$5 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$5(target, key, result);
+	return result;
+};
+var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+var Customer = class extends SmrtObject {
+	tenantId = null;
+	profileId = "";
+	creditLimit = 0;
+	paymentTerms = "";
+	taxExempt = false;
+	taxId = "";
+	defaultTaxCodeId = "";
+	defaultShippingAddress = {};
+	defaultBillingAddress = {};
+	status = CustomerStatus.ACTIVE;
+	customerType = CustomerType.DTC;
+	notes = "";
+	contacts = [];
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.profileId !== void 0) this.profileId = options.profileId;
+		if (options.creditLimit !== void 0) this.creditLimit = options.creditLimit;
+		if (options.paymentTerms !== void 0) this.paymentTerms = options.paymentTerms;
+		if (options.taxExempt !== void 0) this.taxExempt = options.taxExempt;
+		if (options.taxId !== void 0) this.taxId = options.taxId;
+		if (options.defaultTaxCodeId !== void 0) this.defaultTaxCodeId = options.defaultTaxCodeId;
+		if (options.defaultShippingAddress !== void 0) this.defaultShippingAddress = options.defaultShippingAddress;
+		if (options.defaultBillingAddress !== void 0) this.defaultBillingAddress = options.defaultBillingAddress;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.customerType !== void 0 && options.customerType !== null) this.customerType = options.customerType;
+		if (options.notes !== void 0) this.notes = options.notes;
+		if (options.contacts !== void 0) this.contacts = normalizePartyContacts(options.contacts);
+	}
+	/**
+	* Re-normalize contacts after the framework's option-override pass, which
+	* re-applies raw option values (including a stored JSON string).
+	*/
+	async initialize() {
+		await super.initialize();
+		this.contacts = normalizePartyContacts(this.contacts);
+		return this;
+	}
+	/** Save with a final contacts normalization against direct assignment. */
+	async save() {
+		this.contacts = normalizePartyContacts(this.contacts);
+		return super.save();
+	}
+	/**
+	* Convenience predicate: is this a wholesale customer?
+	*/
+	isWholesale() {
+		return this.customerType === CustomerType.WHOLESALE;
+	}
+	/**
+	* Check if customer is active
+	*/
+	isActive() {
+		return this.status === CustomerStatus.ACTIVE;
+	}
+	/**
+	* Check if customer has available credit
+	*/
+	hasAvailableCredit(amount) {
+		return this.creditLimit >= amount;
+	}
+	/**
+	* Get the profile ID for external lookup.
+	*
+	* To get the actual Profile object, use the ProfileCollection from smrt-profiles:
+	* ```typescript
+	* const profiles = await ProfileCollection.create(options);
+	* const profile = await profiles.get({ id: customer.profileId });
+	* ```
+	*
+	* @returns The profile ID or empty string if not set
+	*/
+	getProfileId() {
+		return this.profileId;
+	}
+};
+__publicField$5(Customer, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$5([tenantId({ nullable: true })], Customer.prototype, "tenantId", 2);
+__decorateClass$5([crossPackageRef("@happyvertical/smrt-profiles:Profile", { description: "Links this customer to their profile record, where their name and contact details are kept." })], Customer.prototype, "profileId", 2);
+__decorateClass$5([field({
+	description: "The most this customer may owe you at one time. Leave it at zero if you do not set limits.",
+	ui: { format: "money" }
+})], Customer.prototype, "creditLimit", 2);
+__decorateClass$5([field({ description: "How long the customer has to pay, written the way you would say it, for example \"Net 30\"." })], Customer.prototype, "paymentTerms", 2);
+__decorateClass$5([field({ description: "Turn this on if you do not charge this customer sales tax." })], Customer.prototype, "taxExempt", 2);
+__decorateClass$5([field({
+	sensitive: true,
+	description: "The tax or VAT number of the customer, kept on file for tax-exempt sales."
+})], Customer.prototype, "taxId", 2);
+__decorateClass$5([foreignKey("TaxCode", { description: "The tax code normally used when selling to this customer." })], Customer.prototype, "defaultTaxCodeId", 2);
+__decorateClass$5([field({ description: "Where you usually send goods to this customer, so you do not retype it on every order." })], Customer.prototype, "defaultShippingAddress", 2);
+__decorateClass$5([field({ description: "Where you send invoices to this customer." })], Customer.prototype, "defaultBillingAddress", 2);
+__decorateClass$5([field({ description: "Whether you are still dealing with this customer: active, inactive or suspended." })], Customer.prototype, "status", 2);
+__decorateClass$5([field({ description: "The kind of customer: a direct shopper, a wholesale buyer or a retail customer." })], Customer.prototype, "customerType", 2);
+__decorateClass$5([field({
+	description: "Anything worth remembering about this customer.",
+	ui: { widget: "textarea" }
+})], Customer.prototype, "notes", 2);
+__decorateClass$5([field({ description: "The people you deal with at this customer, with their role and how to reach them." })], Customer.prototype, "contacts", 2);
+Customer = __decorateClass$5([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], Customer);
+//#endregion
+//#region src/collections/CustomerCollection.ts
+var CustomerCollection = class extends SmrtCollection {
+	static _itemClass = Customer;
+	/**
+	* Find customers by profile ID
+	*
+	* @param profileId - Profile ID from smrt-profiles
+	* @returns Array of customers linked to this profile
+	*/
+	async findByProfile(profileId) {
+		return await this.list({
+			where: { profileId },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Find all active customers
+	*
+	* @returns Array of active customers
+	*/
+	async findActive() {
+		return await this.list({
+			where: { status: CustomerStatus.ACTIVE },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Find customers by status
+	*
+	* @param status - Customer status
+	* @returns Array of customers
+	*/
+	async findByStatus(status) {
+		return await this.list({
+			where: { status },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Get or create a customer for a profile
+	*
+	* @param profileId - Profile ID
+	* @param defaults - Default values if creating
+	* @returns Customer
+	*/
+	async getOrCreateForProfile(profileId, defaults = {}) {
+		const existing = await this.findByProfile(profileId);
+		if (existing.length > 0) return existing[0];
+		const customer = await this.create({
+			profileId,
+			creditLimit: defaults.creditLimit ?? 0,
+			paymentTerms: defaults.paymentTerms ?? "",
+			status: CustomerStatus.ACTIVE
+		});
+		await customer.save();
+		return customer;
+	}
+	/**
+	* Find all customers belonging to a specific tenant
+	*
+	* @param tenantId - Tenant ID
+	* @returns Array of customers for the tenant
+	*/
+	async findByTenant(tenantId) {
+		return this.list({ where: { tenantId } });
+	}
+	/**
+	* Find all global customers (not associated with any tenant).
+	*
+	* Routes through the shared tenant-global helper so it does not throw under
+	* an active tenant context (an explicit `tenant_id IS NULL` filter would be
+	* flagged as an isolation violation). (#1600)
+	*
+	* @returns Array of global customers
+	*/
+	async findGlobal() {
+		return queryGlobal(this);
+	}
+	/**
+	* Find customers for a tenant including global customers.
+	*
+	* Fails closed if an active tenant context requests a different tenant's
+	* rows; the admin/system path keeps the cross-tenant capability. (#1600)
+	*
+	* @param tenantId - Tenant ID
+	* @returns Array of tenant-specific and global customers
+	*/
+	async findWithGlobals(tenantId) {
+		return queryWithGlobals(this, tenantId, "Customer.findWithGlobals");
+	}
+};
+//#endregion
+//#region src/models/InvoiceLineItem.ts
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass$4 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$4(target, key, result);
+	return result;
+};
+var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+var InvoiceLineItem = class extends SmrtObject {
+	/** @internal Collection read guard returns this snapshot on its root DB. */
+	rebindMoneyRead(capability, db) {
+		if (capability !== DOCUMENT_MONEY_READ_REBIND) throw new MoneyValidationError("FROZEN_DOCUMENT", "Invoice line read rebinding requires the owning capability");
+		this._db = db;
+		this.options.db = db;
+		return this;
+	}
+	tenantId = null;
+	invoiceId = "";
+	creditedLineId = null;
+	creditCalculationBasisJson = "";
+	get creditCalculationBasis() {
+		try {
+			const value = JSON.parse(this.creditCalculationBasisJson);
+			if (!value || typeof value !== "object" || !("kind" in value)) return null;
+			const basis = value;
+			if (basis.kind !== "quantity" && basis.kind !== "net_amount" || typeof basis.sourceQuantity !== "string" || !Number.isSafeInteger(basis.sourceUnitPrice) || basis.sourceDiscountType !== "none" && basis.sourceDiscountType !== "percent" && basis.sourceDiscountType !== "amount" || typeof basis.sourceDiscountRate !== "string" || !Number.isSafeInteger(basis.sourceDiscountMinor) || basis.kind === "quantity" && typeof basis.quantity !== "string" || basis.kind === "net_amount" && !Number.isSafeInteger(basis.netMinor)) return null;
+			return basis;
+		} catch {
+			return null;
+		}
+	}
+	set creditCalculationBasis(value) {
+		this.creditCalculationBasisJson = value ? JSON.stringify(value) : "";
+	}
+	description = "";
+	/**
+	* SKU or item code
+	*/
+	sku = "";
+	productId = null;
+	quantity = 1;
+	unitPrice = 0;
+	discount = 0;
+	discountType = "none";
+	discountRate = "0.0";
+	taxRate = 0;
+	taxMode = "inherit";
+	taxCodeId = null;
+	taxCodeCode = null;
+	taxCodeName = null;
+	taxComponentsJson = null;
+	get taxComponents() {
+		if (this.taxComponentsJson === null) return [];
+		try {
+			const value = JSON.parse(this.taxComponentsJson);
+			if (!Array.isArray(value)) return [];
+			return value.filter((entry) => !!entry && typeof entry === "object" && typeof entry.taxComponentId === "string" && typeof entry.name === "string" && typeof entry.percent === "string" && Number.isSafeInteger(entry.taxMinor));
+		} catch {
+			return [];
+		}
+	}
+	set taxComponents(value) {
+		this.taxComponentsJson = JSON.stringify(value);
+	}
+	taxAmount = 0;
+	/** Stable document snapshot identity; ordinary lifecycle saves do not change it. */
+	moneySnapshotId = "";
+	amount = 0;
+	/**
+	* Type of source ('campaign' | 'contract' | 'manual' | etc.)
+	*/
+	sourceType = "";
+	/**
+	* ID of the source (e.g., campaign ID, contract ID)
+	*/
+	sourceId = "";
+	/**
+	* Service period start (for time-based billing)
+	*/
+	periodStart = null;
+	/**
+	* Service period end (for time-based billing)
+	*/
+	periodEnd = null;
+	revenueAccountId = null;
+	/**
+	* Sort order within the invoice
+	*/
+	sortOrder = 0;
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.invoiceId !== void 0) this.invoiceId = options.invoiceId;
+		if (options.creditedLineId !== void 0) this.creditedLineId = options.creditedLineId;
+		if (options.creditCalculationBasisJson !== void 0) this.creditCalculationBasisJson = options.creditCalculationBasisJson;
+		if (options.creditCalculationBasis !== void 0) this.creditCalculationBasis = structuredClone(options.creditCalculationBasis);
+		if (options.description !== void 0) this.description = options.description;
+		if (options.sku !== void 0) this.sku = options.sku;
+		if (options.productId !== void 0) this.productId = options.productId;
+		if (options.quantity !== void 0) this.quantity = options.quantity;
+		if (options.unitPrice !== void 0) this.unitPrice = options.unitPrice;
+		if (options.discount !== void 0) this.discount = options.discount;
+		if (options.discountType !== void 0) this.discountType = options.discountType;
+		if (options.discountRate !== void 0) this.discountRate = options.discountRate;
+		if (options.taxRate !== void 0) this.taxRate = options.taxRate;
+		if (options.taxMode !== void 0) this.taxMode = options.taxMode;
+		if (options.taxCodeId !== void 0) this.taxCodeId = options.taxCodeId;
+		if (options.taxCodeCode !== void 0) this.taxCodeCode = options.taxCodeCode;
+		if (options.taxCodeName !== void 0) this.taxCodeName = options.taxCodeName;
+		if (options.taxComponentsJson !== void 0) this.taxComponentsJson = options.taxComponentsJson;
+		if (options.taxComponents !== void 0) this.taxComponents = structuredClone(options.taxComponents);
+		if (options.taxAmount !== void 0) this.taxAmount = options.taxAmount;
+		if (options.moneySnapshotId !== void 0) this.moneySnapshotId = options.moneySnapshotId;
+		if (options.amount !== void 0) this.amount = options.amount;
+		if (options.sourceType !== void 0) this.sourceType = options.sourceType;
+		if (options.sourceId !== void 0) this.sourceId = options.sourceId;
+		if (options.periodStart !== void 0) this.periodStart = options.periodStart;
+		if (options.periodEnd !== void 0) this.periodEnd = options.periodEnd;
+		if (options.revenueAccountId !== void 0) this.revenueAccountId = options.revenueAccountId;
+		if (options.sortOrder !== void 0) this.sortOrder = options.sortOrder;
+	}
+	/** Refuse an old-format row read from the database. */
+	async initialize() {
+		await super.initialize();
+		if (this.isPersisted) {
+			const { assertHydratedMoneyRowCurrent } = await import("./detect-DAE-_NAk.js").then((n) => n.c);
+			await assertHydratedMoneyRowCurrent(this);
+		}
+		return this;
+	}
+	/** Persist through the invoice money aggregate. */
+	async save() {
+		const { saveInvoiceLineItem } = await Promise.resolve().then(() => document_money_exports);
+		return await saveInvoiceLineItem(this);
+	}
+	/** @internal Aggregate persistence only. */
+	async saveDerived(capability) {
+		if (capability !== DOCUMENT_MONEY_WRITE) throw new Error("Invoice line money write capability is required");
+		for (const [field2, value] of [["unitPrice", this.unitPrice], ["discount", this.discount]]) if (!Number.isSafeInteger(value)) throw new MoneyValidationError("UNSAFE_MONEY", `Invoice line ${field2} ${value} must be a safe integer number of minor units`);
+		return await super.save();
+	}
+	async delete(options = {}) {
+		const { deleteInvoiceLineItem } = await Promise.resolve().then(() => document_money_exports);
+		await deleteInvoiceLineItem(this, options);
+	}
+	/** @internal Aggregate persistence only. */
+	async deleteDerived(capability, options = {}) {
+		if (capability !== DOCUMENT_MONEY_WRITE) throw new Error("Invoice line money write capability is required");
+		await super.delete(options);
+	}
+	/**
+	* Check if line item has source tracking
+	*/
+	hasSource() {
+		return !!this.sourceType && !!this.sourceId;
+	}
+	/**
+	* Check if line item has a service period
+	*/
+	hasPeriod() {
+		return !!this.periodStart && !!this.periodEnd;
+	}
+};
+__publicField$4(InvoiceLineItem, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$4([tenantId({ nullable: true })], InvoiceLineItem.prototype, "tenantId", 2);
+__decorateClass$4([field({ description: "The invoice this line belongs to." }), foreignKey("Invoice", { role: "items" })], InvoiceLineItem.prototype, "invoiceId", 2);
+__decorateClass$4([foreignKey("InvoiceLineItem", { nullable: true })], InvoiceLineItem.prototype, "creditedLineId", 2);
+__decorateClass$4([field({ description: "Frozen source basis used to cap and reproduce an issued credit line." })], InvoiceLineItem.prototype, "creditCalculationBasisJson", 2);
+__decorateClass$4([field({ description: "What is being billed on this line." })], InvoiceLineItem.prototype, "description", 2);
+__decorateClass$4([crossPackageRef("@happyvertical/smrt-products:Product", { nullable: true })], InvoiceLineItem.prototype, "productId", 2);
+__decorateClass$4([field({ description: "How many." })], InvoiceLineItem.prototype, "quantity", 2);
+__decorateClass$4([field({
+	description: "The price of one, before discount; includes tax when the document's prices include tax.",
+	ui: { format: "money" }
+})], InvoiceLineItem.prototype, "unitPrice", 2);
+__decorateClass$4([field({ ui: { format: "money" } })], InvoiceLineItem.prototype, "discount", 2);
+__decorateClass$4([field({ type: "decimal" })], InvoiceLineItem.prototype, "discountRate", 2);
+__decorateClass$4([field({ description: "The stored fractional tax rate for this line (0.05 means 5%)." })], InvoiceLineItem.prototype, "taxRate", 2);
+__decorateClass$4([foreignKey("TaxCode", { nullable: true })], InvoiceLineItem.prototype, "taxCodeId", 2);
+__decorateClass$4([field({ ui: { format: "money" } })], InvoiceLineItem.prototype, "taxAmount", 2);
+__decorateClass$4([field({
+	description: "The line amount: net of discount, and including tax only when the document's prices include tax.",
+	ui: { format: "money" }
+})], InvoiceLineItem.prototype, "amount", 2);
+__decorateClass$4([crossPackageRef("@happyvertical/smrt-ledgers:Account", { nullable: true })], InvoiceLineItem.prototype, "revenueAccountId", 2);
+InvoiceLineItem = __decorateClass$4([TenantScoped({ mode: "optional" }), smrt({
+	api: {
+		include: [
+			"list",
+			"get",
+			"create",
+			"update",
+			"delete"
+		],
+		writable: [
+			"invoiceId",
+			"description",
+			"sku",
+			"productId",
+			"quantity",
+			"unitPrice",
+			"discount",
+			"discountType",
+			"discountRate",
+			"taxRate",
+			"taxMode",
+			"taxCodeId",
+			"sourceType",
+			"sourceId",
+			"periodStart",
+			"periodEnd",
+			"revenueAccountId",
+			"sortOrder"
+		]
+	},
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], InvoiceLineItem);
+//#endregion
+//#region src/collections/InvoiceLineItemCollection.ts
+var InvoiceLineItemCollection = class extends SmrtCollection {
+	static _itemClass = InvoiceLineItem;
+	async withMoneyRead(operation) {
+		const rootDb = this.db;
+		const tenantId = getTenantId();
+		if (!tenantId) {
+			await assertCommerceMoneySchemaCurrent(rootDb);
+			return operation();
+		}
+		const result = await withTenantMoneyCollectionRead(rootDb, tenantId, (boundDb) => this.withDatabase(boundDb, operation));
+		if (result instanceof InvoiceLineItem) result.rebindMoneyRead(DOCUMENT_MONEY_READ_REBIND, rootDb);
+		else if (Array.isArray(result)) {
+			for (const item of result) if (item instanceof InvoiceLineItem) item.rebindMoneyRead(DOCUMENT_MONEY_READ_REBIND, rootDb);
+		}
+		return result;
+	}
+	async get(filter, options = {}) {
+		return this.withMoneyRead(() => super.get(filter, options));
+	}
+	async list(options = {}) {
+		return this.withMoneyRead(() => super.list(options));
+	}
+	/**
+	* Find line items by invoice
+	*
+	* @param invoiceId - Invoice ID
+	* @returns Array of line items, sorted by sortOrder
+	*/
+	async findByInvoice(invoiceId) {
+		return await this.list({
+			where: { invoiceId },
+			orderBy: "sortOrder ASC"
+		});
+	}
+	/**
+	* Find line items by source
+	*
+	* @param sourceType - Source type (e.g., 'campaign', 'contract')
+	* @param sourceId - Source ID
+	* @returns Array of line items
+	*/
+	async findBySource(sourceType, sourceId) {
+		return await this.list({
+			where: {
+				sourceType,
+				sourceId
+			},
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Find line items by source type only
+	*
+	* @param sourceType - Source type (e.g., 'campaign')
+	* @returns Array of line items
+	*/
+	async findBySourceType(sourceType) {
+		return await this.list({
+			where: { sourceType },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Calculate total amount for an invoice
+	*
+	* @param invoiceId - Invoice ID
+	* @returns Total amount
+	*/
+	async getTotalForInvoice(invoiceId) {
+		return (await this.findByInvoice(invoiceId)).reduce((sum, item) => sum + item.amount, 0);
+	}
+	/**
+	* Get the next sort order for an invoice
+	*
+	* @param invoiceId - Invoice ID
+	* @returns Next sort order number
+	*/
+	async getNextSortOrder(invoiceId) {
+		const lineItems = await this.findByInvoice(invoiceId);
+		if (lineItems.length === 0) return 0;
+		return Math.max(...lineItems.map((item) => item.sortOrder)) + 1;
+	}
+	/**
+	* Find all invoice line items belonging to a specific tenant
+	*
+	* @param tenantId - Tenant ID
+	* @returns Array of invoice line items for the tenant
+	*/
+	async findByTenant(tenantId) {
+		return this.list({ where: { tenantId } });
+	}
+	/**
+	* Find all global invoice line items (not associated with any tenant).
+	*
+	* Routes through the shared tenant-global helper so it does not throw under
+	* an active tenant context (an explicit `tenant_id IS NULL` filter would be
+	* flagged as an isolation violation). (#1600)
+	*
+	* @returns Array of global invoice line items
+	*/
+	async findGlobal() {
+		return queryGlobal(this);
+	}
+	/**
+	* Find invoice line items for a tenant including global line items.
+	*
+	* Fails closed if an active tenant context requests a different tenant's
+	* rows; the admin/system path keeps the cross-tenant capability. (#1600)
+	*
+	* @param tenantId - Tenant ID
+	* @returns Array of tenant-specific and global invoice line items
+	*/
+	async findWithGlobals(tenantId) {
+		return queryWithGlobals(this, tenantId, "InvoiceLineItem.findWithGlobals");
+	}
+};
+//#endregion
+//#region src/models/HistoricalSalesLine.ts
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass$3 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$3(target, key, result);
+	return result;
+};
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var HistoricalSalesLine = class extends SmrtObject {
+	tenantId = "";
+	invoiceId = "";
+	creditedLineId = null;
+	sourceKey = "";
+	sourceKeyHash = "";
+	description = "";
+	netMinor = 0;
+	taxMinor = null;
+	grossMinor = null;
+	quantityText = null;
+	unitRateText = null;
+	sourceFieldsJson = "{}";
+	moneySnapshotId = "";
+	constructor(options = {}) {
+		super(options);
+		for (const key of [
+			"tenantId",
+			"invoiceId",
+			"creditedLineId",
+			"sourceKey",
+			"sourceKeyHash",
+			"description",
+			"netMinor",
+			"taxMinor",
+			"grossMinor",
+			"quantityText",
+			"unitRateText",
+			"sourceFieldsJson",
+			"moneySnapshotId"
+		]) if (options[key] !== void 0) Object.assign(this, { [key]: options[key] });
+		if (options.sourceFields !== void 0) this.sourceFieldsJson = JSON.stringify(options.sourceFields);
+	}
+	async save(options) {
+		assertHistoricalCommerceWrite(this);
+		if (!this.tenantId || !this.invoiceId || !this.sourceKey || !this.sourceKeyHash || !this.moneySnapshotId) throw new Error("Historical source line identity is incomplete");
+		if (this.id && await this.db.get(this.tableName, { id: this.id })) throw new Error("Historical sales source lines are immutable");
+		return super.save(options);
+	}
+	async delete() {
+		throw new Error("Historical sales source lines cannot be deleted");
+	}
+};
+__publicField$3(HistoricalSalesLine, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$3([tenantId()], HistoricalSalesLine.prototype, "tenantId", 2);
+__decorateClass$3([foreignKey("Invoice")], HistoricalSalesLine.prototype, "invoiceId", 2);
+__decorateClass$3([foreignKey("HistoricalSalesLine", { nullable: true })], HistoricalSalesLine.prototype, "creditedLineId", 2);
+__decorateClass$3([field({ ui: { format: "money" } })], HistoricalSalesLine.prototype, "netMinor", 2);
+__decorateClass$3([field({
+	type: "integer",
+	nullable: true,
+	ui: { format: "money" }
+})], HistoricalSalesLine.prototype, "taxMinor", 2);
+__decorateClass$3([field({
+	type: "integer",
+	nullable: true,
+	ui: { format: "money" }
+})], HistoricalSalesLine.prototype, "grossMinor", 2);
+__decorateClass$3([field({
+	type: "text",
+	nullable: true
+})], HistoricalSalesLine.prototype, "quantityText", 2);
+__decorateClass$3([field({
+	type: "text",
+	nullable: true
+})], HistoricalSalesLine.prototype, "unitRateText", 2);
+HistoricalSalesLine = __decorateClass$3([TenantScoped({ mode: "required" }), smrt({
+	tableName: "historical_sales_lines",
+	indexes: [{
+		name: "historical_sales_line_source_key",
+		columns: [
+			"tenantId",
+			"invoiceId",
+			"sourceKeyHash"
+		],
+		unique: true
+	}],
+	api: { include: ["get", "list"] },
+	cli: { include: ["get", "list"] },
+	mcp: { include: ["get", "list"] }
+})], HistoricalSalesLine);
+//#endregion
+//#region src/collections/HistoricalSalesLineCollection.ts
+var HistoricalSalesLineCollection = class extends SmrtCollection {
+	static _itemClass = HistoricalSalesLine;
+};
+//#endregion
+//#region src/models/Vendor.ts
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$2(target, key, result);
+	return result;
+};
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var Vendor = class extends SmrtObject {
+	tenantId = null;
+	profileId = "";
+	leadTimeDays = 0;
+	minimumOrderAmount = 0;
+	paymentTerms = "";
+	currency = "USD";
+	taxId = "";
+	defaultTaxCodeId = "";
+	defaultContactEmail = "";
+	defaultContactPhone = "";
+	status = VendorStatus.ACTIVE;
+	notes = "";
+	payoutAddresses = {};
+	contacts = [];
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.profileId !== void 0) this.profileId = options.profileId;
+		if (options.leadTimeDays !== void 0) this.leadTimeDays = options.leadTimeDays;
+		if (options.minimumOrderAmount !== void 0) this.minimumOrderAmount = options.minimumOrderAmount;
+		if (options.paymentTerms !== void 0) this.paymentTerms = options.paymentTerms;
+		if (options.currency !== void 0) this.currency = options.currency;
+		if (options.taxId !== void 0) this.taxId = options.taxId;
+		if (options.defaultTaxCodeId !== void 0) this.defaultTaxCodeId = options.defaultTaxCodeId;
+		if (options.defaultContactEmail !== void 0) this.defaultContactEmail = options.defaultContactEmail;
+		if (options.defaultContactPhone !== void 0) this.defaultContactPhone = options.defaultContactPhone;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.notes !== void 0) this.notes = options.notes;
+		if (options.payoutAddresses !== void 0) this.payoutAddresses = Vendor.normalizePayoutAddresses(options.payoutAddresses);
+		if (options.contacts !== void 0) this.contacts = normalizePartyContacts(options.contacts);
+	}
+	/**
+	* The framework's {@link SmrtObject.initialize} re-applies `options` keys on
+	* top of constructor-set values so option data always wins over field
+	* initializers. That means our constructor's normalization runs *before*
+	* `initializePropertiesFromOptions` overwrites `payoutAddresses` with the
+	* raw cloned value. Re-normalize once super has finished so consumers
+	* who pass a string, a partially-typed map, or `null` end up with a
+	* clean `Record<string, string>` before any save / read happens.
+	*/
+	async initialize() {
+		await super.initialize();
+		this.payoutAddresses = Vendor.normalizePayoutAddresses(this.payoutAddresses);
+		this.contacts = normalizePartyContacts(this.contacts);
+		return this;
+	}
+	/**
+	* Save with a final normalization pass so direct field assignments
+	* (`vendor.payoutAddresses = somethingFunny`) can't smuggle non-string
+	* values into the persisted row.
+	*/
+	async save() {
+		this.payoutAddresses = Vendor.normalizePayoutAddresses(this.payoutAddresses);
+		this.contacts = normalizePartyContacts(this.contacts);
+		return super.save();
+	}
+	/**
+	* Check if vendor is active
+	*/
+	isActive() {
+		return this.status === VendorStatus.ACTIVE;
+	}
+	/**
+	* Check if order meets minimum requirements
+	*/
+	meetsMinimumOrder(amount) {
+		return amount >= this.minimumOrderAmount;
+	}
+	/**
+	* Get the profile ID for external lookup.
+	*
+	* To get the actual Profile object, use the ProfileCollection from smrt-profiles:
+	* ```typescript
+	* const profiles = await ProfileCollection.create(options);
+	* const profile = await profiles.get({ id: vendor.profileId });
+	* ```
+	*
+	* @returns The profile ID or empty string if not set
+	*/
+	getProfileId() {
+		return this.profileId;
+	}
+	/**
+	* Look up the payout destination for a single currency. Returns
+	* `undefined` if the vendor has no entry for that currency — caller's
+	* job to decide whether that means "skip the option" or "raise a
+	* configuration error". The lookup is case-sensitive; the contract is
+	* that the currency code passed in matches exactly what was stored
+	* (`USDC-base`, not `usdc-base`).
+	*/
+	getPayoutAddress(currency) {
+		const map = this.payoutAddresses;
+		if (!map || typeof map !== "object") return void 0;
+		const value = map[currency];
+		return typeof value === "string" ? value : void 0;
+	}
+	/**
+	* Set the payout destination for a single currency. Mutates the live
+	* map and returns `this` for chaining. Use {@link clearPayoutAddress}
+	* to remove a single entry.
+	*/
+	setPayoutAddress(currency, destination) {
+		this.payoutAddresses = {
+			...this.payoutAddresses ?? {},
+			[currency]: destination
+		};
+		return this;
+	}
+	/**
+	* Remove a single currency entry from the payout map. No-op if the
+	* currency was already absent.
+	*/
+	clearPayoutAddress(currency) {
+		if (!this.payoutAddresses || !(currency in this.payoutAddresses)) return this;
+		const next = { ...this.payoutAddresses };
+		delete next[currency];
+		this.payoutAddresses = next;
+		return this;
+	}
+	/**
+	* Normalize an input value (object, pre-serialized JSON string, or
+	* `null`/`undefined`) into a plain `Record<string, string>`. Used by
+	* the constructor so consumers can pass either shape into
+	* `VendorCollection.create({ payoutAddresses: ... })`.
+	*
+	* Non-string values inside an input object are silently dropped — a
+	* `Record<string, string>` invariant is what consumers downstream
+	* (`PaymentIntent` builders, payout SDK adapters) rely on.
+	*/
+	static normalizePayoutAddresses(value) {
+		if (value == null) return {};
+		let parsed = value;
+		if (typeof value === "string") try {
+			parsed = JSON.parse(value);
+		} catch {
+			return {};
+		}
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		const out = {};
+		for (const [key, v] of Object.entries(parsed)) if (typeof v === "string") out[key] = v;
+		return out;
+	}
+};
+__publicField$2(Vendor, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$2([tenantId({ nullable: true })], Vendor.prototype, "tenantId", 2);
+__decorateClass$2([crossPackageRef("@happyvertical/smrt-profiles:Profile", { description: "Links this vendor to their profile record, where their name and contact details are kept." })], Vendor.prototype, "profileId", 2);
+__decorateClass$2([field({ description: "How many days the vendor usually takes between your order and delivery." })], Vendor.prototype, "leadTimeDays", 2);
+__decorateClass$2([field({
+	description: "The smallest order the vendor will accept.",
+	ui: { format: "money" }
+})], Vendor.prototype, "minimumOrderAmount", 2);
+__decorateClass$2([field({ description: "How long you have to pay this vendor, written the way you would say it, for example \"Net 30\"." })], Vendor.prototype, "paymentTerms", 2);
+__decorateClass$2([field({
+	description: "The currency this vendor bills you in.",
+	ui: { widget: "currency" }
+})], Vendor.prototype, "currency", 2);
+__decorateClass$2([field({
+	sensitive: true,
+	description: "The vendor tax or VAT registration number kept on file."
+})], Vendor.prototype, "taxId", 2);
+__decorateClass$2([foreignKey("TaxCode", { description: "The tax code normally used when buying from this vendor." })], Vendor.prototype, "defaultTaxCodeId", 2);
+__decorateClass$2([field({
+	description: "The email address you normally use to reach this vendor.",
+	ui: { widget: "email" }
+})], Vendor.prototype, "defaultContactEmail", 2);
+__decorateClass$2([field({
+	description: "The phone number you normally use to reach this vendor.",
+	ui: { widget: "phone" }
+})], Vendor.prototype, "defaultContactPhone", 2);
+__decorateClass$2([field({ description: "Whether you still buy from this vendor: active, inactive or suspended." })], Vendor.prototype, "status", 2);
+__decorateClass$2([field({
+	description: "Anything worth remembering about this vendor.",
+	ui: { widget: "textarea" }
+})], Vendor.prototype, "notes", 2);
+__decorateClass$2([field({
+	sensitive: true,
+	description: "Where payments to this vendor should be sent."
+})], Vendor.prototype, "payoutAddresses", 2);
+__decorateClass$2([field({ description: "The people you deal with at this vendor, with their role and how to reach them." })], Vendor.prototype, "contacts", 2);
+Vendor = __decorateClass$2([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], Vendor);
+//#endregion
+//#region src/models/Contract.ts
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp$1(target, key, result);
+	return result;
+};
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var CONTRACT_STATUS_TRANSITIONS = {
+	[ContractStatus.DRAFT]: [
+		ContractStatus.SENT,
+		ContractStatus.ACCEPTED,
+		ContractStatus.DECLINED,
+		ContractStatus.CANCELLED
+	],
+	[ContractStatus.SENT]: [
+		ContractStatus.ACCEPTED,
+		ContractStatus.DECLINED,
+		ContractStatus.CANCELLED
+	],
+	[ContractStatus.ACCEPTED]: [ContractStatus.COMPLETED, ContractStatus.CANCELLED],
+	[ContractStatus.DECLINED]: [],
+	[ContractStatus.COMPLETED]: [],
+	[ContractStatus.CANCELLED]: []
+};
+var loadedContractStatus = /* @__PURE__ */ new WeakMap();
+function classifyContractPurchase(contract) {
+	return "vendorId" in contract;
+}
+function isContractSnapshotReportEligible(contract) {
+	return !(contract instanceof SupplierQuote) && contract.status !== ContractStatus.DRAFT && contract.status !== ContractStatus.CANCELLED;
+}
+var Contract = class extends SmrtObject {
+	/** @internal Collection read guard returns this snapshot on its root DB. */
+	rebindMoneyRead(capability, db) {
+		if (capability !== DOCUMENT_MONEY_READ_REBIND) throw new Error("Contract read rebinding requires the owning capability");
+		this._db = db;
+		this.options.db = db;
+		return this;
+	}
+	tenantId = null;
+	contractType = ContractType.ORDER;
+	status = ContractStatus.DRAFT;
+	subtotal = 0;
+	discountTotal = 0;
+	taxAmount = 0;
+	totalAmount = 0;
+	currency = "USD";
+	moneyAuthority = "calculated";
+	/** Guarded received evidence; write through the public received purchase/sales contract commands only. */
+	receivedPurchaseMoneyJson = "";
+	billingScheduleJson = "";
+	/** Pricing interpretation fixed before the Contract leaves draft. */
+	lineAmountType = "exclusive";
+	/** Component rounding scope fixed before the Contract leaves draft. */
+	taxRoundingScope = "line";
+	/** Immutable seller registration snapshot once the Contract leaves draft. */
+	sellerTaxRegistrationsJson = "[]";
+	get sellerTaxRegistrations() {
+		try {
+			const value = JSON.parse(this.sellerTaxRegistrationsJson);
+			if (!Array.isArray(value)) return [];
+			return value.filter((entry) => !!entry && typeof entry === "object" && typeof entry.taxComponentId === "string" && typeof entry.number === "string" && typeof entry.label === "string");
+		} catch {
+			return [];
+		}
+	}
+	set sellerTaxRegistrations(value) {
+		this.sellerTaxRegistrationsJson = JSON.stringify(value);
+	}
+	/** Immutable customer or vendor tax identifier snapshot after issue. */
+	partyTaxId = "";
+	/** Stable issue/freeze identity, independent of lifecycle updated_at. */
+	moneySnapshotId = "";
+	issueDate = /* @__PURE__ */ new Date();
+	dueDate = null;
+	expiryDate = null;
+	reference = "";
+	notes = "";
+	terms = "";
+	channelId = "";
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.contractType !== void 0) this.contractType = options.contractType;
+		if (options.status !== void 0) this.status = options.status;
+		if (options.billingScheduleJson !== void 0) this.billingScheduleJson = options.billingScheduleJson;
+		if (options.moneyAuthority !== void 0) this.moneyAuthority = options.moneyAuthority;
+		if (options.receivedPurchaseMoneyJson !== void 0) this.receivedPurchaseMoneyJson = options.receivedPurchaseMoneyJson;
+		if (options.subtotal !== void 0) this.subtotal = options.subtotal;
+		if (options.discountTotal !== void 0) this.discountTotal = options.discountTotal;
+		if (options.taxAmount !== void 0) this.taxAmount = options.taxAmount;
+		if (options.totalAmount !== void 0) this.totalAmount = options.totalAmount;
+		if (options.currency !== void 0) this.currency = options.currency;
+		if (options.lineAmountType !== void 0) this.lineAmountType = options.lineAmountType;
+		if (options.taxRoundingScope !== void 0) this.taxRoundingScope = options.taxRoundingScope;
+		if (options.sellerTaxRegistrationsJson !== void 0) this.sellerTaxRegistrationsJson = options.sellerTaxRegistrationsJson;
+		if (options.sellerTaxRegistrations !== void 0) this.sellerTaxRegistrations = structuredClone(options.sellerTaxRegistrations);
+		if (options.partyTaxId !== void 0) this.partyTaxId = options.partyTaxId;
+		if (options.moneySnapshotId !== void 0) this.moneySnapshotId = options.moneySnapshotId;
+		if (options.issueDate !== void 0) this.issueDate = options.issueDate;
+		if (options.dueDate !== void 0) this.dueDate = options.dueDate;
+		if (options.expiryDate !== void 0) this.expiryDate = options.expiryDate;
+		if (options.reference !== void 0) this.reference = options.reference;
+		if (options.notes !== void 0) this.notes = options.notes;
+		if (options.terms !== void 0) this.terms = options.terms;
+		if (options.channelId !== void 0) this.channelId = options.channelId;
+	}
+	/**
+	* Check if contract is in draft state
+	*/
+	isDraft() {
+		return this.status === ContractStatus.DRAFT;
+	}
+	/**
+	* Check if contract is accepted
+	*/
+	isAccepted() {
+		return this.status === ContractStatus.ACCEPTED;
+	}
+	/**
+	* Check if contract is completed
+	*/
+	isCompleted() {
+		return this.status === ContractStatus.COMPLETED;
+	}
+	/**
+	* Check if contract is expired (for estimates)
+	*/
+	isExpired() {
+		if (!this.expiryDate) return false;
+		return /* @__PURE__ */ new Date() > this.expiryDate;
+	}
+	/**
+	* Check if contract is overdue
+	*/
+	isOverdue() {
+		if (!this.dueDate) return false;
+		if (this.status === ContractStatus.COMPLETED) return false;
+		return /* @__PURE__ */ new Date() > this.dueDate;
+	}
+	/**
+	* Calculate and update totals from line items
+	*/
+	async recalculateTotals() {
+		const { recalculateContractTotals } = await import("./contract-money-BMsq4cpL.js");
+		await recalculateContractTotals(this);
+	}
+	/**
+	* Capture the status the row was loaded with so the save-time transition
+	* guard can reject illegal status flips made via raw field assignment
+	* (mass-assignment on the generated update route, a stale caller, etc.).
+	* Only persisted rows carry a prior status.
+	*/
+	async initialize() {
+		await super.initialize();
+		if (this.isPersisted) {
+			const { assertHydratedMoneyRowCurrent } = await import("./detect-DAE-_NAk.js").then((n) => n.c);
+			await assertHydratedMoneyRowCurrent(this);
+		}
+		if (await this.isSaved()) loadedContractStatus.set(this, this.status);
+		return this;
+	}
+	/**
+	* Validate the amounts and the status transition before persisting, then
+	* save. Inherited by every STI subtype (Estimate/Order/Lease/.../LicenseSale),
+	* so a forged `status` on any of them is caught here. LicenseSale layers its
+	* own rights-immutability guard on top via `super.save()`. See S5 audit
+	* #1390.
+	*
+	* `subtotal` / `taxAmount` / `totalAmount` are mass-assignable on the
+	* generated create/update routes, so the minor-units check runs on every
+	* write surface (#2401).
+	*/
+	async save() {
+		const { saveContract } = await import("./contract-money-BMsq4cpL.js");
+		return await saveContract(this);
+	}
+	/** Received purchase monetary history cannot be deleted. */
+	async delete(options = {}) {
+		const { deleteContract } = await import("./contract-money-BMsq4cpL.js");
+		await deleteContract(this, options);
+	}
+	/** @internal Contract aggregate persistence only. */
+	async deleteDerived(capability, options = {}) {
+		if (capability !== DOCUMENT_MONEY_WRITE) throw new Error("Contract money write capability is required");
+		await super.delete(options);
+	}
+	/** @internal Contract aggregate persistence only. */
+	async saveDerived(capability) {
+		if (capability !== DOCUMENT_MONEY_WRITE) throw new Error("Contract money write capability is required");
+		assertIntegerMinorUnits("Contract", this.reference || this.id || "<new>", [
+			["subtotal", this.subtotal],
+			["discountTotal", this.discountTotal],
+			["taxAmount", this.taxAmount],
+			["totalAmount", this.totalAmount]
+		]);
+		const prior = await this.resolvePriorStatus();
+		this.assertContractStatusTransition(prior);
+		const result = await super.save();
+		loadedContractStatus.set(this, this.status);
+		return result;
+	}
+	/**
+	* Reject an illegal status flip done via raw assignment. No-op transitions
+	* and brand-new rows are always allowed.
+	*/
+	assertContractStatusTransition(prior) {
+		if (prior === void 0) return;
+		if (prior === this.status) return;
+		if (!(CONTRACT_STATUS_TRANSITIONS[prior] ?? []).includes(this.status)) throw new Error(`Contract ${this.reference || this.id}: illegal status transition '${prior}' \u2192 '${this.status}'.`);
+	}
+	/**
+	* Resolve the AUTHORITATIVE prior status (S5 audit #1390 round 5, codex
+	* MEDIUM#2). The WeakMap is only populated when {@link initialize} loaded the
+	* row from the DB; it is empty for an instance built via
+	* `collection.create({ id: <existing>, _skipLoad: true })` — the upsert path
+	* that lets a caller write onto an existing row without hydrating it. Trusting
+	* an empty WeakMap there would treat the write as a brand-new row and skip the
+	* transition guard entirely (a poisonable prior-state). Mirrors the
+	* authoritative-prior-load applied to Payment/PaymentIntent/Invoice/Payout.
+	*
+	* So when this instance carries an `id`, read the persisted row straight from
+	* the database and treat its `status` as the prior — a create-onto-existing is
+	* an update. Only when no row exists in the DB (truly new) do we fall back to
+	* the WeakMap (which is also empty then), i.e. `undefined` = genuinely new.
+	* The raw row's `status` column is single-word (no snake_case transform).
+	*/
+	async resolvePriorStatus() {
+		if (this.id) try {
+			const row = await this.db.get(this.tableName, { id: this.id });
+			if (row && row.status != null) return row.status;
+		} catch {}
+		return loadedContractStatus.get(this);
+	}
+};
+__publicField$1(Contract, "__smrtPackage__", "@happyvertical/smrt-commerce");
+/**
+* STI discriminator field
+*/
+__publicField$1(Contract, "_stiField", "contractType");
+__decorateClass$1([tenantId({ nullable: true })], Contract.prototype, "tenantId", 2);
+__decorateClass$1([field({ description: "The kind of contract: order, estimate, lease, agreement and so on." })], Contract.prototype, "contractType", 2);
+__decorateClass$1([field({ description: "Where the order or agreement stands, for example draft, sent, accepted or completed." })], Contract.prototype, "status", 2);
+__decorateClass$1([field({
+	description: "The amount before tax.",
+	ui: { format: "money" }
+})], Contract.prototype, "subtotal", 2);
+__decorateClass$1([field({ ui: { format: "money" } })], Contract.prototype, "discountTotal", 2);
+__decorateClass$1([field({
+	description: "The tax charged.",
+	ui: { format: "money" }
+})], Contract.prototype, "taxAmount", 2);
+__decorateClass$1([field({
+	description: "The full amount, tax included.",
+	ui: { format: "money" }
+})], Contract.prototype, "totalAmount", 2);
+__decorateClass$1([field({
+	description: "The currency of the amounts.",
+	ui: { widget: "currency" }
+})], Contract.prototype, "currency", 2);
+__decorateClass$1([field({ description: "Whether amounts were calculated or recorded from reviewed original paperwork." })], Contract.prototype, "moneyAuthority", 2);
+__decorateClass$1([field({ type: "text" })], Contract.prototype, "billingScheduleJson", 2);
+__decorateClass$1([field({ description: "The date it was issued or placed." })], Contract.prototype, "issueDate", 2);
+__decorateClass$1([field({ description: "The date payment or delivery is due." })], Contract.prototype, "dueDate", 2);
+__decorateClass$1([field({ description: "The last day the price or offer is good for." })], Contract.prototype, "expiryDate", 2);
+__decorateClass$1([field({ description: "Your own number or note for finding this later, such as a purchase order or quote number." })], Contract.prototype, "reference", 2);
+__decorateClass$1([field({
+	description: "Anything worth remembering about this.",
+	ui: { widget: "textarea" }
+})], Contract.prototype, "notes", 2);
+__decorateClass$1([field({
+	description: "The conditions agreed, such as deposits, payment or delivery conditions.",
+	ui: { widget: "textarea" }
+})], Contract.prototype, "terms", 2);
+__decorateClass$1([field({ description: "Where it came from, for example your shop, a marketplace or a phone call." })], Contract.prototype, "channelId", 2);
+Contract = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt({
+	tableStrategy: "sti",
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], Contract);
+var SalesContract = class extends Contract {
+	customerId = null;
+	constructor(options = {}) {
+		super(options);
+		if (options.customerId !== void 0) this.customerId = options.customerId;
+	}
+};
+__publicField$1(SalesContract, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Customer, { description: "The customer a sales order or agreement is for." })], SalesContract.prototype, "customerId", 2);
+SalesContract = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt({ abstract: true })], SalesContract);
+var PurchaseContract = class extends Contract {
+	vendorId = null;
+	constructor(options = {}) {
+		super(options);
+		if (options.vendorId !== void 0) this.vendorId = options.vendorId;
+	}
+};
+__publicField$1(PurchaseContract, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Vendor, { description: "The vendor supplying this quote or purchase contract." })], PurchaseContract.prototype, "vendorId", 2);
+PurchaseContract = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt({ abstract: true })], PurchaseContract);
+var Estimate = class extends SalesContract {
+	customerId = null;
+	contractType = ContractType.ESTIMATE;
+	constructor(options = {}) {
+		super(options);
+		if (options.customerId !== void 0) this.customerId = options.customerId;
+	}
+};
+__publicField$1(Estimate, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Customer, { required: true })], Estimate.prototype, "customerId", 2);
+Estimate = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], Estimate);
+var Order = class extends SalesContract {
+	customerId = null;
+	contractType = ContractType.ORDER;
+	constructor(options = {}) {
+		super(options);
+		if (options.customerId !== void 0) this.customerId = options.customerId;
+	}
+};
+__publicField$1(Order, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Customer, { required: true })], Order.prototype, "customerId", 2);
+Order = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], Order);
+var Lease = class extends SalesContract {
+	customerId = null;
+	contractType = ContractType.LEASE;
+	constructor(options = {}) {
+		super(options);
+		if (options.customerId !== void 0) this.customerId = options.customerId;
+	}
+};
+__publicField$1(Lease, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Customer, { required: true })], Lease.prototype, "customerId", 2);
+Lease = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], Lease);
+var Agreement = class extends SalesContract {
+	customerId = null;
+	contractType = ContractType.AGREEMENT;
+	constructor(options = {}) {
+		super(options);
+		if (options.customerId !== void 0) this.customerId = options.customerId;
+	}
+};
+__publicField$1(Agreement, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Customer, { required: true })], Agreement.prototype, "customerId", 2);
+Agreement = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], Agreement);
+var SupplierQuote = class extends PurchaseContract {
+	vendorId = null;
+	contractType = ContractType.SUPPLIER_QUOTE;
+	constructor(options = {}) {
+		super(options);
+		if (options.vendorId !== void 0) this.vendorId = options.vendorId;
+	}
+};
+__publicField$1(SupplierQuote, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Vendor, { required: true })], SupplierQuote.prototype, "vendorId", 2);
+SupplierQuote = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], SupplierQuote);
+var PurchaseOrder = class extends PurchaseContract {
+	vendorId = null;
+	contractType = ContractType.PURCHASE_ORDER;
+	expectedDate = "";
+	shipTo = "";
+	/** Construct a purchase order with its optional delivery header. */
+	constructor(options = {}) {
+		super(options);
+		if (options.vendorId !== void 0) this.vendorId = options.vendorId;
+		if (options.expectedDate !== void 0) this.expectedDate = options.expectedDate;
+		if (options.shipTo !== void 0) this.shipTo = options.shipTo;
+	}
+};
+__publicField$1(PurchaseOrder, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Vendor, { required: true })], PurchaseOrder.prototype, "vendorId", 2);
+__decorateClass$1([field({ description: "The date you expect the delivery, as YYYY-MM-DD. Leave blank if it is not known." })], PurchaseOrder.prototype, "expectedDate", 2);
+__decorateClass$1([field({ description: "Where this order should be delivered, including any delivery instructions." })], PurchaseOrder.prototype, "shipTo", 2);
+PurchaseOrder = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], PurchaseOrder);
+var WholesaleOrder = class extends SalesContract {
+	customerId = null;
+	contractType = ContractType.WHOLESALE_ORDER;
+	constructor(options = {}) {
+		super(options);
+		if (options.customerId !== void 0) this.customerId = options.customerId;
+	}
+};
+__publicField$1(WholesaleOrder, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$1([foreignKey(Customer, { required: true })], WholesaleOrder.prototype, "customerId", 2);
+WholesaleOrder = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], WholesaleOrder);
+var ProductionOrder = class extends PurchaseContract {
+	contractType = ContractType.PRODUCTION_ORDER;
+	/**
+	* Plain string reference to the upstream product the order is asked
+	* to make. Cross-package id; never `@foreignKey()`. Required by
+	* `ProductionService.consumeMaterials` unless `bomId` is supplied.
+	*/
+	productId = "";
+	/**
+	* Optional explicit BOM revision the order locked to at posting
+	* time. When set, manufacturing uses this exact row even if the
+	* product's active BOM has since changed. When empty, falls back
+	* to the active BOM for `productId`.
+	*/
+	bomId = "";
+};
+__publicField$1(ProductionOrder, "__smrtPackage__", "@happyvertical/smrt-commerce");
+ProductionOrder = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], ProductionOrder);
+var Cart = class extends SalesContract {
+	contractType = ContractType.CART;
+};
+__publicField$1(Cart, "__smrtPackage__", "@happyvertical/smrt-commerce");
+Cart = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], Cart);
+var issuedRightsSnapshot = /* @__PURE__ */ new WeakMap();
+var LicenseSale = class extends SalesContract {
+	contractType = ContractType.LICENSE_SALE;
+	/**
+	* Plain string reference to the upstream `Sku` (from
+	* `@happyvertical/smrt-products`) that this license was sold against.
+	* Cross-package id; never `@foreignKey()`.
+	*/
+	skuId = "";
+	/**
+	* Plain string reference to the `Payment` that satisfied the
+	* purchase. Cross-model reference matches the rest of the
+	* package's convention.
+	*/
+	paymentId = "";
+	/**
+	* The licensee's email address — the primary identity carried
+	* forward into PDF generation and any downstream hash-registry
+	* publication. Required; without it, downstream rights cannot be
+	* attributed.
+	*/
+	licenseeEmail = "";
+	/**
+	* Optional legal-entity name of the licensee for purchases that
+	* warrant it (typically high-tier B2B licenses). Empty string for
+	* individual-buyer licenses where the email *is* the legal identity.
+	*/
+	licenseeLegalEntity = "";
+	/**
+	* Optional ISO-3166 jurisdiction code of the licensee, captured for
+	* tax / disclosure / governing-law purposes. Empty when not
+	* required.
+	*/
+	licenseeJurisdiction = "";
+	/** Permitted media — `web,print,social`, `broadcast`, etc. */
+	rightsMedium = "";
+	/** Distribution scope — `worldwide`, `territorial`, `private`, etc. */
+	rightsDistributionScope = "";
+	/** Exclusivity — `exclusive` / `non-exclusive` / `co-exclusive`. */
+	rightsExclusivity = "";
+	/** Duration — `perpetual` / `12-months` / `event-only`, etc. */
+	rightsDuration = "";
+	/** Territory — ISO-3166 list, `worldwide`, region name, etc. */
+	rightsTerritory = "";
+	/** Whether the licensee may sublicense the rights. */
+	rightsSublicensing = false;
+	/** Whether the licensee may create derivative works. */
+	rightsDerivatives = false;
+	/** URL of the signed PDF (typically a cloud-storage public URL). */
+	pdfUrl = "";
+	/**
+	* SHA-256 of the signed PDF bytes (hex string, no `0x` prefix).
+	* Lets downstream consumers verify the PDF the licensee holds is
+	* the one this row was issued for, without re-fetching.
+	*/
+	pdfHash = "";
+	/**
+	* Optional reference to an on-chain hash-registry entry — set when
+	* the LicenseSale's `pdfHash` has been anchored on a public chain
+	* for tamper-evidence. Format is whatever the hash-registry
+	* service emits (e.g. `chain:tx-hash:log-index`). Empty for
+	* deployments that don't publish hashes on-chain.
+	*/
+	onChainHashRegistryRef = "";
+	constructor(options = {}) {
+		super(options);
+		if (options.skuId !== void 0) this.skuId = options.skuId;
+		if (options.paymentId !== void 0) this.paymentId = options.paymentId;
+		if (options.licenseeEmail !== void 0) this.licenseeEmail = options.licenseeEmail;
+		if (options.licenseeLegalEntity !== void 0) this.licenseeLegalEntity = options.licenseeLegalEntity;
+		if (options.licenseeJurisdiction !== void 0) this.licenseeJurisdiction = options.licenseeJurisdiction;
+		if (options.rightsMedium !== void 0) this.rightsMedium = options.rightsMedium;
+		if (options.rightsDistributionScope !== void 0) this.rightsDistributionScope = options.rightsDistributionScope;
+		if (options.rightsExclusivity !== void 0) this.rightsExclusivity = options.rightsExclusivity;
+		if (options.rightsDuration !== void 0) this.rightsDuration = options.rightsDuration;
+		if (options.rightsTerritory !== void 0) this.rightsTerritory = options.rightsTerritory;
+		if (options.rightsSublicensing !== void 0) this.rightsSublicensing = options.rightsSublicensing;
+		if (options.rightsDerivatives !== void 0) this.rightsDerivatives = options.rightsDerivatives;
+		if (options.pdfUrl !== void 0) this.pdfUrl = options.pdfUrl;
+		if (options.pdfHash !== void 0) this.pdfHash = options.pdfHash;
+		if (options.onChainHashRegistryRef !== void 0) this.onChainHashRegistryRef = options.onChainHashRegistryRef;
+	}
+	/**
+	* Once `super.initialize()` has applied the framework's option-
+	* override pass, capture the rights snapshot if (and only if) the
+	* row arrived already issued. That's how the immutability guard
+	* tells "freshly drafting a license" (snapshot still mutable) apart
+	* from "loaded an already-issued row" (snapshot frozen).
+	*/
+	async initialize() {
+		await super.initialize();
+		if (this.status === ContractStatus.ACCEPTED && await this.isSaved()) issuedRightsSnapshot.set(this, this.serializeRightsSnapshot());
+		return this;
+	}
+	/**
+	* Return the current rights snapshot as a typed object. Read-only
+	* for callers — mutation should go through assignment to the
+	* individual `rights*` fields, gated by the issued-immutability
+	* guard.
+	*/
+	getRightsSnapshot() {
+		return {
+			medium: this.rightsMedium,
+			distributionScope: this.rightsDistributionScope,
+			exclusivity: this.rightsExclusivity,
+			duration: this.rightsDuration,
+			territory: this.rightsTerritory,
+			sublicensing: this.rightsSublicensing,
+			derivatives: this.rightsDerivatives
+		};
+	}
+	/**
+	* Revoke an issued license — moves status to `CANCELLED` without
+	* touching the rights snapshot (which stays frozen). Throws if
+	* called on a non-issued license; a draft license should be
+	* deleted, not revoked.
+	*/
+	revoke() {
+		if (this.status !== ContractStatus.ACCEPTED) throw new Error(`LicenseSale ${this.id ?? "<new>"}: cannot revoke from status '${this.status}' \u2014 only ACCEPTED licenses can be revoked`);
+		this.status = ContractStatus.CANCELLED;
+	}
+	/**
+	* Save with the immutability check: if the row was loaded with
+	* `ACCEPTED` status, the rights snapshot at save time must match
+	* the snapshot at load time. Anything else means an out-of-band
+	* mutation crept in and we surface it instead of letting the row
+	* drift silently.
+	*
+	* Newly-drafted licenses (where the row was constructed without
+	* `ACCEPTED` status) capture their snapshot at the moment the
+	* caller transitions to `ACCEPTED` and saves — `validateImmutable`
+	* picks that up post-save on the next call.
+	*/
+	async save() {
+		this.validateImmutable();
+		const result = await super.save();
+		if (this.status === ContractStatus.ACCEPTED && !issuedRightsSnapshot.has(this)) issuedRightsSnapshot.set(this, this.serializeRightsSnapshot());
+		return result;
+	}
+	/**
+	* Compare the current rights against the captured snapshot
+	* (populated either at load time by `initialize` or at first
+	* issuance by `save`). Throws on mismatch.
+	*/
+	validateImmutable() {
+		const captured = issuedRightsSnapshot.get(this);
+		if (!captured) return;
+		if (captured !== this.serializeRightsSnapshot()) throw new Error(`LicenseSale ${this.id ?? "<new>"}: rights snapshot is immutable once issued (status=ACCEPTED). Use revoke() to cancel the existing license and issue a new one with the updated rights.`);
+	}
+	serializeRightsSnapshot() {
+		return JSON.stringify({
+			medium: this.rightsMedium,
+			distributionScope: this.rightsDistributionScope,
+			exclusivity: this.rightsExclusivity,
+			duration: this.rightsDuration,
+			territory: this.rightsTerritory,
+			sublicensing: this.rightsSublicensing,
+			derivatives: this.rightsDerivatives
+		});
+	}
+};
+__publicField$1(LicenseSale, "__smrtPackage__", "@happyvertical/smrt-commerce");
+LicenseSale = __decorateClass$1([TenantScoped({ mode: "optional" }), smrt()], LicenseSale);
+//#endregion
+//#region src/collections/PurchaseContractCollection.ts
+var PurchaseContractCollection = class extends SmrtCollection {
+	static _itemClass = PurchaseContract;
+	async findByVendor(vendorId) {
+		return this.list({
+			where: { vendorId },
+			orderBy: "created_at DESC"
+		});
+	}
+};
+//#endregion
+//#region src/collections/SalesContractCollection.ts
+var SalesContractCollection = class extends SmrtCollection {
+	static _itemClass = SalesContract;
+	async findByCustomer(customerId) {
+		return this.list({
+			where: { customerId },
+			orderBy: "created_at DESC"
+		});
+	}
+};
+//#endregion
+//#region src/collections/ContractCollection.ts
+var ContractCollection = class extends SmrtCollection {
+	static _itemClass = Contract;
+	async withMoneyRead(operation) {
+		const rootDb = this.db;
+		const tenantId = getTenantId();
+		if (!tenantId) {
+			await assertCommerceMoneySchemaCurrent(rootDb);
+			return operation();
+		}
+		const result = await withTenantMoneyCollectionRead(rootDb, tenantId, (boundDb) => this.withDatabase(boundDb, operation));
+		if (result instanceof Contract) result.rebindMoneyRead(DOCUMENT_MONEY_READ_REBIND, rootDb);
+		else if (Array.isArray(result)) {
+			for (const item of result) if (item instanceof Contract) item.rebindMoneyRead(DOCUMENT_MONEY_READ_REBIND, rootDb);
+		}
+		return result;
+	}
+	async get(filter, options = {}) {
+		return this.withMoneyRead(() => super.get(filter, options));
+	}
+	async list(options = {}) {
+		return this.withMoneyRead(() => super.list(options));
+	}
+	/**
+	* Find contracts by customer
+	*
+	* @param customerId - Customer ID
+	* @returns Array of contracts
+	* @deprecated Use SalesContractCollection.findByCustomer.
+	*/
+	async findByCustomer(customerId) {
+		return (await SalesContractCollection.create({
+			...this.options,
+			db: this.db
+		})).findByCustomer(customerId);
+	}
+	/**
+	* Find contracts by vendor
+	*
+	* @param vendorId - Vendor ID
+	* @returns Array of contracts
+	* @deprecated Use PurchaseContractCollection.findByVendor.
+	*/
+	async findByVendor(vendorId) {
+		return (await PurchaseContractCollection.create({
+			...this.options,
+			db: this.db
+		})).findByVendor(vendorId);
+	}
+	/**
+	* Hydrate a bounded tenant/date report candidate set once, retaining exact
+	* STI descendants so callers can classify custom purchase types safely.
+	*/
+	async listSnapshotReportContracts(options) {
+		return (await this.list({
+			where: {
+				tenantId: options.tenantId,
+				"issueDate >=": options.from.toISOString(),
+				"issueDate <=": options.to.toISOString()
+			},
+			orderBy: "issueDate ASC"
+		})).filter(isContractSnapshotReportEligible);
+	}
+	/**
+	* Find contracts by type (STI)
+	*
+	* @param contractType - Contract type
+	* @returns Array of contracts
+	*/
+	async findByType(contractType) {
+		return await this.list({
+			where: { contractType },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Find contracts by status
+	*
+	* @param status - Contract status
+	* @returns Array of contracts
+	*/
+	async findByStatus(status) {
+		return await this.list({
+			where: { status },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Find all draft contracts
+	*
+	* @returns Array of draft contracts
+	*/
+	async findDrafts() {
+		return await this.findByStatus(ContractStatus.DRAFT);
+	}
+	/**
+	* Find all accepted contracts
+	*
+	* @returns Array of accepted contracts
+	*/
+	async findAccepted() {
+		return await this.findByStatus(ContractStatus.ACCEPTED);
+	}
+	/**
+	* Find overdue contracts
+	*
+	* @returns Array of overdue contracts
+	*/
+	async findOverdue() {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return (await this.list({
+			where: { "dueDate <": now },
+			orderBy: "dueDate ASC"
+		})).filter((c) => c.status !== ContractStatus.COMPLETED && c.status !== ContractStatus.CANCELLED);
+	}
+	/**
+	* Find expired estimates/quotes
+	*
+	* @returns Array of expired estimates
+	*/
+	async findExpired() {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		return (await this.list({
+			where: {
+				contractType: ContractType.ESTIMATE,
+				"expiryDate <": now
+			},
+			orderBy: "expiryDate ASC"
+		})).filter((c) => c.status !== ContractStatus.ACCEPTED && c.status !== ContractStatus.DECLINED && c.status !== ContractStatus.CANCELLED);
+	}
+	/**
+	* Find contracts in date range
+	*
+	* @param startDate - Start date
+	* @param endDate - End date
+	* @returns Array of contracts
+	*/
+	async findByDateRange(startDate, endDate) {
+		return await this.list({
+			where: {
+				"issueDate >=": startDate.toISOString(),
+				"issueDate <=": endDate.toISOString()
+			},
+			orderBy: "issueDate DESC"
+		});
+	}
+	/**
+	* Find all contracts belonging to a specific tenant
+	*
+	* @param tenantId - Tenant ID
+	* @returns Array of contracts for the tenant
+	*/
+	async findByTenant(tenantId) {
+		return this.list({ where: { tenantId } });
+	}
+	/**
+	* Find all global contracts (not associated with any tenant).
+	*
+	* Routes through the shared tenant-global helper so it does not throw under
+	* an active tenant context (an explicit `tenant_id IS NULL` filter would be
+	* flagged as an isolation violation). (#1600)
+	*
+	* @returns Array of global contracts
+	*/
+	async findGlobal() {
+		return queryGlobal(this);
+	}
+	/**
+	* Find contracts for a tenant including global contracts.
+	*
+	* Fails closed if an active tenant context requests a different tenant's
+	* rows; the admin/system path keeps the cross-tenant capability. (#1600)
+	*
+	* @param tenantId - Tenant ID
+	* @returns Array of tenant-specific and global contracts
+	*/
+	async findWithGlobals(tenantId) {
+		return queryWithGlobals(this, tenantId, "Contract.findWithGlobals");
+	}
+};
+//#endregion
+//#region src/contract-billing-schedule.ts
+function invalid$3(message) {
+	throw new MoneyValidationError("INVALID_MONEY_INPUT", message);
+}
+function text$1(value, label) {
+	if (typeof value !== "string" || !value || value.trim() !== value) invalid$3(`${label} must be nonempty trimmed text`);
+	return value;
+}
+function integer$1(value, label, signed = false) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || !signed && value < 0) invalid$3(`${label} must be a ${signed ? "" : "nonnegative "}safe integer`);
+	return value;
+}
+function safe(value) {
+	return integer$1(Number(value), "Computed amount");
+}
+function context(input) {
+	text$1(input.tenantId, "Tenant");
+	text$1(input.contractId, "Contract");
+	text$1(input.requestId, "Request");
+	if (getTenantId() !== input.tenantId) invalid$3("Schedule command requires its active tenant context");
+}
+function milestones(value) {
+	if (!Array.isArray(value) || value.length === 0) invalid$3("A schedule requires milestones");
+	const keys = /* @__PURE__ */ new Set();
+	return value.map((entry) => {
+		if (!entry || typeof entry !== "object") invalid$3("Invalid milestone");
+		const key = text$1(entry.key, "Milestone key");
+		if (keys.has(key)) invalid$3("Milestone keys must be unique");
+		keys.add(key);
+		return {
+			key,
+			label: text$1(entry.label, "Milestone label"),
+			amountMinor: integer$1(entry.amountMinor, "Milestone amount")
+		};
+	});
+}
+function money(value) {
+	if (!value || typeof value !== "object") invalid$3("Approved invoice money is required");
+	const netMinor = integer$1(value.netMinor, "Approved net");
+	const taxMinor = integer$1(value.taxMinor, "Approved tax");
+	const grossMinor = integer$1(value.grossMinor, "Approved gross");
+	if (BigInt(netMinor) + BigInt(taxMinor) !== BigInt(grossMinor)) invalid$3("Approved invoice money must reconcile");
+	return {
+		netMinor,
+		taxMinor,
+		grossMinor
+	};
+}
+function allocateContractMilestones(totalMinor, weights) {
+	integer$1(totalMinor, "Total");
+	if (!Array.isArray(weights) || !weights.length) invalid$3("Milestone weights are required");
+	const values = weights.map((value) => {
+		integer$1(value, "Weight");
+		if (!value) invalid$3("Weights must be positive");
+		return BigInt(value);
+	});
+	const sum = values.reduce((a, b) => a + b, 0n);
+	let remaining = BigInt(totalMinor);
+	return values.map((value, index) => {
+		const amount = index === values.length - 1 ? remaining : BigInt(totalMinor) * value / sum;
+		remaining -= amount;
+		return safe(amount);
+	});
+}
+function getContractBillingSchedule(contract) {
+	if (!contract.billingScheduleJson) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(contract.billingScheduleJson);
+	} catch {
+		invalid$3("Stored billing schedule is invalid");
+	}
+	if (parsed.version !== 1 || parsed.capacityPolicy !== "issued-consumed" || !Array.isArray(parsed.revisions) || !parsed.revisions.length || !Array.isArray(parsed.claims)) invalid$3("Stored billing schedule is invalid");
+	return parsed;
+}
+async function loadContract(db, tenantId, contractId) {
+	const collection = await ContractCollection.create({ db });
+	await lockDocumentMoneyParents([{
+		id: contractId,
+		tenantId,
+		collection
+	}]);
+	const contract = await collection.get({ id: contractId }, { cache: false });
+	if (!(contract instanceof Order || contract instanceof Agreement) || contract.tenantId !== tenantId || !contract.customerId || contract.status !== ContractStatus.ACCEPTED || !contract.moneySnapshotId) invalid$3("Schedule requires an accepted customer contract in the active tenant");
+	return contract;
+}
+async function approveContractBillingSchedule(input) {
+	context(input);
+	const expectedRevision = integer$1(input.expectedRevision, "Expected revision");
+	const proposal = {
+		requestId: input.requestId,
+		approvalEvidenceRef: text$1(input.approvalEvidenceRef, "Approval evidence"),
+		taxPolicyEvidenceRef: text$1(input.taxPolicyEvidenceRef, "Tax policy evidence"),
+		currency: text$1(input.currency, "Currency"),
+		basis: input.basis,
+		amendmentMinor: integer$1(input.amendmentMinor, "Amendment", true),
+		milestones: milestones(input.milestones)
+	};
+	if (proposal.basis !== "net" && proposal.basis !== "gross") invalid$3("Schedule basis must explicitly be net or gross");
+	return withTenantMoneyRuntime(input.db, input.tenantId, async ({ db }) => {
+		const contract = await loadContract(db, input.tenantId, input.contractId);
+		const stored = getContractBillingSchedule(contract);
+		const replay = stored?.revisions.find((entry) => entry.requestId === input.requestId);
+		if (replay) {
+			const { revision: revision2, approvedTotalMinor: _total, ...old } = replay;
+			if (revision2 !== expectedRevision + 1 || JSON.stringify(old) !== JSON.stringify(proposal)) invalid$3("Schedule request changed");
+			return replay;
+		}
+		if (stored?.claims.some((entry) => entry.requestId === input.requestId)) invalid$3("Request identity already used");
+		const previous = stored?.revisions.at(-1);
+		if ((previous?.revision ?? 0) !== expectedRevision) invalid$3("Schedule revision changed");
+		if (contract.currency !== proposal.currency || previous && (previous.currency !== proposal.currency || previous.basis !== proposal.basis)) invalid$3("Schedule currency and basis must match original approval");
+		const originalAmountMinor = stored?.originalAmountMinor ?? (proposal.basis === "net" ? contract.subtotal : contract.totalAmount);
+		integer$1(originalAmountMinor, "Original contract amount");
+		if (!stored) {
+			if (proposal.amendmentMinor !== 0) invalid$3("Initial schedule cannot amend original contract value");
+			if ((await (await InvoiceCollection.create({ db })).findByContract(input.contractId)).some((invoice) => invoice.kind === "invoice" && !!invoice.moneySnapshotId)) invalid$3("Existing issued contract invoices prevent initial schedule approval");
+		}
+		const approvedTotalMinor = safe(BigInt(previous?.approvedTotalMinor ?? originalAmountMinor) + BigInt(proposal.amendmentMinor));
+		if (proposal.milestones.reduce((sum, entry) => sum + BigInt(entry.amountMinor), 0n) !== BigInt(approvedTotalMinor)) invalid$3("Milestone total must equal original contract plus approved amendments");
+		for (const claim of stored?.claims ?? []) {
+			const prior = stored?.revisions.find((entry) => entry.revision === claim.revision)?.milestones.find((entry) => entry.key === claim.milestoneKey);
+			const next = proposal.milestones.find((entry) => entry.key === claim.milestoneKey);
+			if (!prior || !next || JSON.stringify(prior) !== JSON.stringify(next)) invalid$3("An issued milestone cannot be removed or changed");
+		}
+		const revision = {
+			revision: expectedRevision + 1,
+			...proposal,
+			approvedTotalMinor
+		};
+		const state = stored ?? {
+			version: 1,
+			originalAmountMinor,
+			capacityPolicy: "issued-consumed",
+			revisions: [],
+			claims: []
+		};
+		state.revisions.push(revision);
+		contract.billingScheduleJson = JSON.stringify(state);
+		await contract.saveDerived(DOCUMENT_MONEY_WRITE);
+		return revision;
+	});
+}
+var issuePermissions = /* @__PURE__ */ new WeakMap();
+async function assertContractScheduleInvoiceFreeze(db, invoice) {
+	if (invoice.kind !== "invoice" || !invoice.contractId) return;
+	const contract = await (await ContractCollection.create({ db })).get({ id: invoice.contractId }, { cache: false });
+	if (!contract) return;
+	if (contract.tenantId !== invoice.tenantId) invalid$3("Invoice contract must belong to its active tenant");
+	if (!getContractBillingSchedule(contract)) return;
+	if (invoice.status === InvoiceStatus.CANCELLED && !invoice.moneySnapshotId && !invoice.arJournalId) return;
+	if (!(contract instanceof Order || contract instanceof Agreement)) invalid$3("Scheduled contract must be a customer contract");
+	const permission = invoice.id ? issuePermissions.get(db)?.get(invoice.id) : void 0;
+	if (!permission || permission.contractId !== invoice.contractId) invalid$3("Scheduled contract invoices must use issueContractMilestoneInvoice");
+	if (invoice.customerId !== contract.customerId || invoice.currency !== contract.currency) invalid$3("Milestone invoice must match contract customer and currency");
+	const actual = {
+		netMinor: invoice.subtotal,
+		taxMinor: invoice.taxAmount,
+		grossMinor: invoice.totalAmount
+	};
+	if (JSON.stringify(actual) !== JSON.stringify(permission.approvedMoney) || (permission.basis === "net" ? invoice.subtotal : invoice.totalAmount) !== permission.amountMinor) invalid$3("Milestone invoice money differs from approved amounts");
+}
+async function issueContractMilestoneInvoice(input) {
+	context(input);
+	const request = {
+		requestId: input.requestId,
+		revision: integer$1(input.revision, "Revision"),
+		milestoneKey: text$1(input.milestoneKey, "Milestone key"),
+		invoiceId: text$1(input.invoiceId, "Invoice"),
+		approvedMoney: money(input.approvedMoney),
+		invoiceApprovalEvidenceRef: text$1(input.invoiceApprovalEvidenceRef, "Invoice approval evidence")
+	};
+	return withTenantMoneyRuntime(input.db, input.tenantId, async ({ db }) => {
+		const contract = await loadContract(db, input.tenantId, input.contractId);
+		const state = getContractBillingSchedule(contract);
+		if (!state) invalid$3("Contract has no approved billing schedule");
+		const replay = state.claims.find((entry) => entry.requestId === request.requestId);
+		if (replay) {
+			const { moneySnapshotId: _snapshot, ...prior } = replay;
+			if (JSON.stringify(prior) !== JSON.stringify(request)) invalid$3("Milestone issue request changed");
+			return replay;
+		}
+		if (state.revisions.some((entry) => entry.requestId === request.requestId)) invalid$3("Request identity already used");
+		const revision = state.revisions.at(-1);
+		if (!revision || revision.revision !== request.revision) invalid$3("Schedule revision changed");
+		const milestone = revision.milestones.find((entry) => entry.key === request.milestoneKey);
+		if (!milestone) invalid$3("Milestone does not exist in approved revision");
+		if (state.claims.some((entry) => entry.milestoneKey === request.milestoneKey || entry.invoiceId === request.invoiceId)) invalid$3("Milestone or invoice already consumed");
+		const invoices = await InvoiceCollection.create({ db });
+		await lockDocumentMoneyParents([{
+			id: request.invoiceId,
+			tenantId: input.tenantId,
+			collection: invoices
+		}]);
+		const invoice = await invoices.get({ id: request.invoiceId }, { cache: false });
+		if (!invoice || invoice.tenantId !== input.tenantId || invoice.kind !== "invoice" || invoice.status !== InvoiceStatus.DRAFT || invoice.moneySnapshotId || invoice.contractId !== input.contractId || invoice.customerId !== contract.customerId || invoice.currency !== revision.currency) invalid$3("Milestone requires a matching unissued draft in the active tenant");
+		const permissions = issuePermissions.get(db) ?? /* @__PURE__ */ new Map();
+		permissions.set(request.invoiceId, {
+			contractId: input.contractId,
+			amountMinor: milestone.amountMinor,
+			basis: revision.basis,
+			approvedMoney: request.approvedMoney
+		});
+		issuePermissions.set(db, permissions);
+		try {
+			invoice.markSent();
+			await invoice.save();
+		} finally {
+			permissions.delete(request.invoiceId);
+			if (!permissions.size) issuePermissions.delete(db);
+		}
+		if (!invoice.moneySnapshotId) invalid$3("Milestone invoice was not frozen");
+		const claim = {
+			...request,
+			moneySnapshotId: invoice.moneySnapshotId
+		};
+		state.claims.push(claim);
+		contract.billingScheduleJson = JSON.stringify(state);
+		await contract.saveDerived(DOCUMENT_MONEY_WRITE);
+		return claim;
+	});
+}
+//#endregion
+//#region src/document-money.ts
+var document_money_exports = /* @__PURE__ */ __exportAll({
+	deleteInvoice: () => deleteInvoice,
+	deleteInvoiceLineItem: () => deleteInvoiceLineItem,
+	getInvoiceMoneyFacts: () => getInvoiceMoneyFacts,
+	lockAndReloadInvoice: () => lockAndReloadInvoice,
+	previewInvoiceMoney: () => previewInvoiceMoney,
+	refreshIssuedCreditBalance: () => refreshIssuedCreditBalance,
+	saveInvoice: () => saveInvoice,
+	saveInvoiceLineItem: () => saveInvoiceLineItem
+});
+var FROZEN_INVOICE_FIELDS = [
+	"moneyAuthority",
+	"historicalSalesMoneyJson",
+	"historicalSourceKeyHash",
+	"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) {
+	if (value instanceof Date) return value.toISOString();
+	return value === "" || value === void 0 ? null : value;
+}
+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", "Invoice money 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) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Commerce money documents require a tenant");
+	return lockTenantMoneyRuntime(db, tenantId);
+}
+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
+		},
+		limit: 100001
+	});
+	if (credits.length > 1e5) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Issued credit scope exceeds its bounded source limit");
+	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);
+	const managed = /* @__PURE__ */ new Map();
+	if (source.retentionAccountingStateJson || source.ordinaryAccountingStateJson) {
+		const providerState = JSON.parse(source.retentionAccountingStateJson || source.ordinaryAccountingStateJson);
+		for (const entry of providerState.credits) {
+			const credit = issued.find((candidate) => candidate.id === entry.creditId);
+			const retainedMinor = source.retentionAccountingStateJson ? entry.retainedMinor : 0;
+			const frozen = retainedMinor + entry.appliedMinor;
+			if (!credit || managed.has(entry.creditId) || !Number.isSafeInteger(retainedMinor) || retainedMinor < 0 || !Number.isSafeInteger(entry.appliedMinor) || entry.appliedMinor < 0 || !Number.isSafeInteger(frozen) || frozen > credit.totalAmount || frozen !== credit.creditedAmount || frozen > remainingSource) throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", "Provider-managed credit allocation cannot change without an explicit reversal contract");
+			managed.set(entry.creditId, frozen);
+			remainingSource -= frozen;
+		}
+	}
+	for (const credit of [...issued, ...credits.filter((entry) => !issued.includes(entry))]) {
+		const included = issued.includes(credit);
+		const frozen = managed.get(requireId(credit.id, "Credit invoice"));
+		const applied = frozen ?? (included ? Math.min(credit.totalAmount, remainingSource) : 0);
+		if (included && frozen === void 0) remainingSource -= applied;
+		if (credit.creditedAmount !== applied) {
+			credit.creditedAmount = applied;
+			credit.updatePaymentStatus(credit.amountPaid);
+			if (included && credit.status === InvoiceStatus.DRAFT) credit.status = InvoiceStatus.SENT;
+			await credit.saveDerived(DOCUMENT_MONEY_WRITE);
+		}
+	}
+	if ((source.retentionAccountingStateJson || source.ordinaryAccountingStateJson) && total !== source.creditedAmount) {
+		const state = JSON.parse(source.retentionAccountingStateJson || source.ordinaryAccountingStateJson);
+		if (state.status !== "ready" || state.steps.some((step) => step.status !== "confirmed")) throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", "Provider retention operation must reconcile before changing source credits");
+	}
+	source.creditedAmount = total;
+	source.updatePaymentStatus(source.amountPaid);
+	await source.saveDerived(DOCUMENT_MONEY_WRITE);
+}
+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.moneyAuthority === "historical") throw new MoneyValidationError("INVALID_MONEY_INPUT", "Historical source credits require exact original monetary facts and concrete historical source line lineage, not calculated quantity or inferred tax");
+	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: component.compound ?? false
+			}))
+		};
+	}
+	const exempt = await codesCollection.findByCode("exempt", tenantId);
+	const outOfScope = await codesCollection.findByCode("out-of-scope", tenantId);
+	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,
+							...part.compound ? { compound: true } : {},
+							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;
+				if (sourceComponent.compound) {
+					component.compound = true;
+					component.taxableMinor = (sourceComponent.taxableMinor ?? 0) - prior.reduce((sum, candidate) => sum + (candidate.taxComponents.find((part) => part.taxComponentId === sourceComponent.taxComponentId)?.taxableMinor ?? 0), 0);
+				}
+				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,
+				compound: false,
+				taxableMinor: void 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 += part.taxableMinor ?? result.netMinor;
+				if (part.compound) row.netMinor = (row.netMinor ?? 0) + 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,
+				...entry.compound ? {
+					compound: true,
+					taxableMinor: entry.taxableMinor
+				} : {}
+			};
+		});
+		line.taxRate = result.components.some((part) => part.compound) ? result.netMinor === 0 ? 0 : result.taxMinor / result.netMinor : 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);
+	}
+	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,
+			netMinor: tax.netMinor ?? null,
+			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, async (scope) => previewInvoiceMoneyOnScope({
+		...input,
+		db: scope.db
+	}, scope.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);
+	const historical = getHistoricalSalesMoney(invoice);
+	return {
+		source: "stored",
+		...historical ? { historical: {
+			snapshot: historical,
+			lines: (await readHistoricalSalesLines(input.db, invoice)).map((line) => ({
+				sourceKey: line.sourceKey,
+				lineId: String(line.id)
+			}))
+		} } : {},
+		...invoice.retentionStateJson ? { payable: invoice.getPayableFacts() } : {},
+		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,
+			...row.netMinor !== null ? { netMinor: row.netMinor } : {},
+			taxMinor: row.taxMinor,
+			recoverableMinor: row.recoverableMinor
+		}))
+	};
+}
+async function getInvoiceMoneyFacts(input) {
+	return withTenantMoneyRuntime(input.db, input.tenantId, 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 (invoice.retentionAccountingStateJson !== (existing?.retentionAccountingStateJson ?? "") || invoice.ordinaryAccountingStateJson !== (existing?.ordinaryAccountingStateJson ?? "")) throw new MoneyValidationError("FROZEN_DOCUMENT", "Retention accounting state is managed by provider commands");
+			if (invoice.moneyAuthority !== (existing?.moneyAuthority ?? "calculated") || invoice.historicalSalesMoneyJson !== (existing?.historicalSalesMoneyJson ?? "") || invoice.historicalSourceKeyHash !== (existing?.historicalSourceKeyHash ?? null)) throw new MoneyValidationError("FROZEN_DOCUMENT", "Historical source authority is managed only by historical sales commands");
+			if (existing?.moneyAuthority === "historical") getHistoricalSalesMoney(existing);
+			if (invoice.retentionStateJson !== (existing?.retentionStateJson ?? "")) throw new MoneyValidationError("FROZEN_DOCUMENT", "Retention state is managed by retention commands");
+			if (candidateTenantId && existing?.tenantId && existing.tenantId !== candidateTenantId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Invoice tenant does not match its active money barrier");
+			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) {
+					await assertContractScheduleInvoiceFreeze(tx, invoice);
+					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);
+			}
+			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 invoice requires an atomic reversal before cancellation");
+				assertFieldsUnchanged(invoice, locked.invoice, FROZEN_INVOICE_FIELDS, "Invoice");
+				const saved2 = await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
+				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) {
+				await assertContractScheduleInvoiceFreeze(tx, invoice);
+				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);
+			if (locked.source) await refreshIssuedCreditBalance(tx, locked.source);
+			return saved;
+		}));
+	} catch (error) {
+		input.updated_at = priorRevision;
+		throw error;
+	}
+}
+async function saveInvoiceLineItem(input) {
+	return withDocumentMoneyObjectTransaction(input, async (line, tx) => {
+		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;
+		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);
+		}
+		await line.saveDerived(DOCUMENT_MONEY_WRITE);
+		const priorAggregate = aggregateSignature(invoice);
+		await recomputeInvoiceAggregate(tx, invoice, settings);
+		if (aggregateSignature(invoice) !== priorAggregate) await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
+		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");
+		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);
+	}));
+}
+async function deleteInvoice(input, options) {
+	await withDocumentMoneyTransaction(input.db, async (tx) => input.withDatabase(tx, async (invoice) => {
+		const candidateTenantId = getTenantId() ?? invoice.tenantId ?? null;
+		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 (isFrozen(persisted)) throw new MoneyValidationError("FROZEN_DOCUMENT", "Cannot delete a frozen invoice");
+		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
+//#region src/historical-sales-validation.ts
+function invalid$2() {
+	throw new MoneyValidationError("INVALID_MONEY_INPUT", "Historical sales require exact supported source facts and explicit unknown values");
+}
+function historicalText(value, max = 2e3) {
+	if (typeof value !== "string" || !value.trim() || value.trim() !== value || value.length > max) invalid$2();
+	return value;
+}
+function historicalCalendarDate(value) {
+	const date = historicalText(value);
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || !Number.isFinite(Date.parse(date)) || new Date(date).toISOString().slice(0, 10) !== date) invalid$2();
+	return date;
+}
+function record(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) invalid$2();
+	return value;
+}
+function fields(input, allowed) {
+	const value = record(input);
+	if (Object.keys(value).some((key) => !allowed.includes(key))) invalid$2();
+	return value;
+}
+function integer(value) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value)) invalid$2();
+	return value;
+}
+function nullableInteger(value) {
+	return value === null ? null : integer(value);
+}
+function nullableText(value) {
+	return value === null ? null : historicalText(value);
+}
+function sum(values) {
+	const result = values.reduce((total, value) => total + BigInt(value), 0n);
+	if (result > BigInt(Number.MAX_SAFE_INTEGER) || result < BigInt(Number.MIN_SAFE_INTEGER)) invalid$2();
+	return Number(result);
+}
+function sameAmount(net, tax, gross) {
+	if (sum([net, tax]) !== gross) invalid$2();
+}
+function historicalSalesMagnitudes(facts) {
+	const sign = facts.kind === "credit_note" && facts.polarity === "signed" ? -1 : 1;
+	const result = {
+		netMinor: facts.netMinor * sign,
+		taxMinor: facts.taxMinor * sign,
+		grossMinor: facts.grossMinor * sign
+	};
+	if (Object.values(result).some((value) => value < 0)) invalid$2();
+	return result;
+}
+function validateHistoricalSalesSource(input) {
+	const value = fields(input, [
+		"namespace",
+		"key",
+		"version",
+		"issuedOn",
+		"dueOn",
+		"timeZone",
+		"approval",
+		"retention"
+	]);
+	const retention = value.retention == null ? value.retention : (() => {
+		const r = fields(value.retention, [
+			"retainedMinor",
+			"creditPolicy",
+			"policyRef",
+			"effectiveOn",
+			"evidenceRef",
+			"originalActorRef",
+			"releases"
+		]);
+		if (r.creditPolicy !== "retained-first" || !Array.isArray(r.releases) || r.releases.length > 1e4) invalid$2();
+		const retainedMinor = integer(r.retainedMinor);
+		if (retainedMinor <= 0) invalid$2();
+		const effectiveOn = historicalCalendarDate(r.effectiveOn);
+		const keys = /* @__PURE__ */ new Set();
+		const releases = r.releases.map((input2) => {
+			const event = fields(input2, [
+				"sourceKey",
+				"amountMinor",
+				"effectiveOn",
+				"evidenceRef",
+				"originalActorRef",
+				"sameDayCreditOrder"
+			]);
+			const sourceKey = historicalText(event.sourceKey), amountMinor = integer(event.amountMinor), on = historicalCalendarDate(event.effectiveOn);
+			if (keys.has(sourceKey) || amountMinor <= 0 || on < effectiveOn) invalid$2();
+			keys.add(sourceKey);
+			return {
+				...event.sameDayCreditOrder === void 0 ? {} : { sameDayCreditOrder: event.sameDayCreditOrder === null || event.sameDayCreditOrder === "credit-before-release" || event.sameDayCreditOrder === "release-before-credit" ? event.sameDayCreditOrder : invalid$2() },
+				sourceKey,
+				amountMinor,
+				effectiveOn: on,
+				evidenceRef: historicalText(event.evidenceRef),
+				originalActorRef: nullableText(event.originalActorRef)
+			};
+		});
+		if (sum(releases.map((event) => event.amountMinor)) > retainedMinor) invalid$2();
+		return {
+			retainedMinor,
+			creditPolicy: "retained-first",
+			policyRef: historicalText(r.policyRef),
+			effectiveOn,
+			evidenceRef: historicalText(r.evidenceRef),
+			originalActorRef: nullableText(r.originalActorRef),
+			releases
+		};
+	})();
+	if (retention && retention.effectiveOn !== historicalCalendarDate(value.issuedOn)) invalid$2();
+	const timeZone = historicalText(value.timeZone);
+	try {
+		new Intl.DateTimeFormat("en", { timeZone }).format(0);
+	} catch {
+		invalid$2();
+	}
+	const approval = value.approval === null ? null : fields(value.approval, ["actorRef", "approvedOn"]);
+	return {
+		...retention === void 0 ? {} : { retention },
+		namespace: historicalText(value.namespace),
+		key: historicalText(value.key),
+		version: historicalText(value.version),
+		issuedOn: historicalCalendarDate(value.issuedOn),
+		dueOn: value.dueOn === null ? null : historicalCalendarDate(value.dueOn),
+		timeZone,
+		approval: approval === null ? null : {
+			actorRef: historicalText(approval.actorRef),
+			approvedOn: approval.approvedOn === null ? null : historicalCalendarDate(approval.approvedOn)
+		}
+	};
+}
+function validateHistoricalSalesMoneyFacts(input) {
+	const value = fields(input, [
+		"currency",
+		"kind",
+		"polarity",
+		"netMinor",
+		"taxMinor",
+		"grossMinor",
+		"taxComponents",
+		"detail"
+	]);
+	const currency = historicalText(value.currency);
+	if (!ISO_4217_MINOR_UNITS.has(currency) || ISO_4217_MINOR_UNITS.get(currency) === null || !["invoice", "credit_note"].includes(value.kind) || !["signed", "magnitudes"].includes(value.polarity)) invalid$2();
+	const netMinor = integer(value.netMinor), taxMinor = integer(value.taxMinor), grossMinor = integer(value.grossMinor);
+	sameAmount(netMinor, taxMinor, grossMinor);
+	const seenComponents = /* @__PURE__ */ new Set();
+	const taxComponents = value.taxComponents === null ? null : (() => {
+		if (!Array.isArray(value.taxComponents) || value.taxComponents.length > 1e3) invalid$2();
+		return value.taxComponents.map((inputComponent) => {
+			const component = fields(inputComponent, [
+				"sourceKey",
+				"label",
+				"amountMinor",
+				"classification",
+				"taxCodeId",
+				"taxComponentId",
+				"taxableMinor",
+				"netMinor",
+				"liabilityAccountId"
+			]), sourceKey = historicalText(component.sourceKey);
+			if (seenComponents.has(sourceKey)) invalid$2();
+			seenComponents.add(sourceKey);
+			if (component.classification !== null && ![
+				"taxable",
+				"zero-rated",
+				"exempt",
+				"out-of-scope"
+			].includes(component.classification)) invalid$2();
+			const classification = component.classification;
+			const amountMinor = integer(component.amountMinor), taxableMinor = nullableInteger(component.taxableMinor);
+			if (classification !== null && classification !== "taxable" && amountMinor !== 0) invalid$2();
+			return {
+				sourceKey,
+				label: historicalText(component.label),
+				amountMinor,
+				classification,
+				taxCodeId: nullableText(component.taxCodeId),
+				taxComponentId: nullableText(component.taxComponentId),
+				taxableMinor,
+				netMinor: nullableInteger(component.netMinor),
+				liabilityAccountId: nullableText(component.liabilityAccountId)
+			};
+		});
+	})();
+	if (taxComponents !== null && sum(taxComponents.map((component) => component.amountMinor)) !== taxMinor) invalid$2();
+	const detailInput = fields(value.detail, record(value.detail).kind === "header-only" ? ["kind"] : ["kind", "lines"]);
+	let detail;
+	if (detailInput.kind === "header-only") detail = { kind: "header-only" };
+	else if (detailInput.kind === "lines") {
+		if (!Array.isArray(detailInput.lines) || !detailInput.lines.length || detailInput.lines.length > 1e5) invalid$2();
+		const seen = /* @__PURE__ */ new Set();
+		const lines = detailInput.lines.map((inputLine) => {
+			const line = fields(inputLine, [
+				"sourceKey",
+				"creditedLineId",
+				"description",
+				"netMinor",
+				"taxMinor",
+				"grossMinor",
+				"quantityText",
+				"unitRateText",
+				"sourceFields"
+			]), sourceKey = historicalText(line.sourceKey);
+			if (seen.has(sourceKey)) invalid$2();
+			seen.add(sourceKey);
+			const sourceFields = record(line.sourceFields);
+			if (Object.keys(sourceFields).length > 100 || Object.entries(sourceFields).some(([key, cell]) => key.length > 200 || typeof cell !== "string" || cell.length > 1e4)) invalid$2();
+			const netMinor2 = integer(line.netMinor), taxMinor2 = nullableInteger(line.taxMinor), grossMinor2 = nullableInteger(line.grossMinor);
+			if (taxMinor2 !== null && grossMinor2 !== null) sameAmount(netMinor2, taxMinor2, grossMinor2);
+			if (typeof line.description !== "string" || line.description.length > 1e4) invalid$2();
+			return {
+				sourceKey,
+				description: line.description,
+				creditedLineId: nullableText(line.creditedLineId),
+				netMinor: netMinor2,
+				taxMinor: taxMinor2,
+				grossMinor: grossMinor2,
+				quantityText: nullableText(line.quantityText),
+				unitRateText: nullableText(line.unitRateText),
+				sourceFields: Object.fromEntries(Object.entries(sourceFields))
+			};
+		});
+		if (sum(lines.map((line) => line.netMinor)) !== netMinor || lines.every((line) => line.taxMinor !== null) && sum(lines.map((line) => line.taxMinor)) !== taxMinor || lines.every((line) => line.grossMinor !== null) && sum(lines.map((line) => line.grossMinor)) !== grossMinor) invalid$2();
+		detail = {
+			kind: "lines",
+			lines
+		};
+	} else invalid$2();
+	const result = {
+		currency,
+		kind: value.kind,
+		polarity: value.polarity,
+		netMinor,
+		taxMinor,
+		grossMinor,
+		taxComponents,
+		detail
+	};
+	historicalSalesMagnitudes(result);
+	return result;
+}
+//#endregion
+//#region src/historical-sales-money.ts
+function hash(value) {
+	return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function identity$1(value) {
+	const h = hash(value);
+	return `${h.slice(0, 8)}-${h.slice(8, 12)}-5${h.slice(13, 16)}-a${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+function invalid$1(message) {
+	throw new MoneyValidationError("INVALID_MONEY_INPUT", message);
+}
+function historicalSalesSourceHash(source) {
+	return hash([source.namespace, source.key]);
+}
+function snapshotIdentity(invoice, snapshot) {
+	return identity$1({
+		tenantId: invoice.tenantId,
+		invoiceId: invoice.id,
+		customerId: invoice.customerId,
+		invoiceNumber: invoice.invoiceNumber,
+		snapshot
+	});
+}
+function originalRetentionState(snapshot) {
+	const r = snapshot.source.retention;
+	if (!r) return null;
+	return {
+		version: 1,
+		currency: snapshot.facts.currency,
+		creditPolicy: r.creditPolicy,
+		retainedMinor: r.retainedMinor,
+		requestId: `historical-retention:${snapshot.requestId}`,
+		policyVersion: r.policyRef,
+		evidenceRef: r.evidenceRef,
+		actorId: snapshot.review.actorId,
+		reason: "Original source retention",
+		recordedAt: snapshot.recordedAt,
+		effectiveOn: r.effectiveOn,
+		releases: r.releases.map((event) => ({
+			requestId: `historical-release:${event.sourceKey}`,
+			policyVersion: r.policyRef,
+			evidenceRef: event.evidenceRef,
+			actorId: snapshot.review.actorId,
+			reason: "Original source release",
+			recordedAt: snapshot.recordedAt,
+			effectiveOn: event.effectiveOn,
+			...event.sameDayCreditOrder === void 0 ? {} : { sameDayCreditOrder: event.sameDayCreditOrder },
+			amountMinor: event.amountMinor
+		}))
+	};
+}
+function getHistoricalSalesMoney(invoice) {
+	if (invoice.moneyAuthority === "calculated" && !invoice.historicalSalesMoneyJson && invoice.historicalSourceKeyHash === null) return null;
+	if (invoice.moneyAuthority !== "historical" || !invoice.historicalSalesMoneyJson) invalid$1("Historical invoice authority is incomplete");
+	const value = JSON.parse(invoice.historicalSalesMoneyJson);
+	if (value.version !== 1) invalid$1("Historical invoice snapshot version is unsupported");
+	const snapshot = {
+		version: 1,
+		requestId: historicalText(value.requestId),
+		evidenceRef: historicalText(value.evidenceRef),
+		review: {
+			actorId: historicalText(value.review?.actorId),
+			policyRef: historicalText(value.review?.policyRef)
+		},
+		recordedAt: historicalText(value.recordedAt),
+		source: validateHistoricalSalesSource(value.source),
+		facts: validateHistoricalSalesMoneyFacts(value.facts),
+		creditedSource: value.creditedSource === null ? null : {
+			invoiceId: historicalText(value.creditedSource?.invoiceId),
+			moneySnapshotId: historicalText(value.creditedSource?.moneySnapshotId)
+		}
+	};
+	const amounts = historicalSalesMagnitudes(snapshot.facts);
+	if (invoice.currency !== snapshot.facts.currency || invoice.kind !== snapshot.facts.kind || invoice.subtotal !== amounts.netMinor || invoice.taxAmount !== amounts.taxMinor || invoice.totalAmount !== amounts.grossMinor || invoice.discountTotal !== 0 || invoice.providerTaxAmount !== 0 || invoice.historicalSourceKeyHash !== historicalSalesSourceHash(snapshot.source) || invoice.moneySnapshotId !== snapshotIdentity(invoice, snapshot)) invalid$1("Historical invoice no longer matches its immutable original monetary authority");
+	if (invoice.issueDate.toISOString().slice(0, 10) !== snapshot.source.issuedOn || (invoice.dueDate?.toISOString().slice(0, 10) ?? null) !== snapshot.source.dueOn) invalid$1("Historical source calendar dates changed");
+	if (snapshot.facts.kind === "credit_note" ? invoice.creditedInvoiceId !== snapshot.creditedSource?.invoiceId : snapshot.creditedSource !== null) invalid$1("Historical credit source lineage changed");
+	const expectedRetention = originalRetentionState(snapshot), retained = parseInvoiceRetention(invoice.retentionStateJson);
+	if (expectedRetention) {
+		if (!retained) invalid$1("Original retention authority is missing");
+		for (const key of Object.keys(expectedRetention)) {
+			if (key === "releases") continue;
+			if (retained[key] !== expectedRetention[key]) invalid$1("Original retention source projection changed");
+		}
+		if (JSON.stringify(retained.releases.slice(0, expectedRetention.releases.length)) !== JSON.stringify(expectedRetention.releases)) invalid$1("Original retention release projection changed");
+	} else if (retained) invalid$1("Historical invoice has no original retention authority");
+	return structuredClone(snapshot);
+}
+function lineIdentity(invoiceId, sourceKey) {
+	return identity$1({
+		kind: "historical-sales-line:v1",
+		invoiceId,
+		sourceKey
+	});
+}
+async function readHistoricalSalesLines(db, invoice) {
+	const snapshot = getHistoricalSalesMoney(invoice);
+	if (!snapshot) return [];
+	const lines = await (await HistoricalSalesLineCollection.create({ db })).list({
+		where: {
+			tenantId: invoice.tenantId,
+			invoiceId: invoice.id
+		},
+		limit: 100001
+	});
+	const expected = snapshot.facts.detail.kind === "lines" ? snapshot.facts.detail.lines : [];
+	if (lines.length !== expected.length) invalid$1("Historical invoice source child identities are incomplete");
+	const byKey = new Map(lines.map((line) => [line.sourceKey, line]));
+	if (byKey.size !== lines.length) invalid$1("Historical source child identity is ambiguous");
+	return expected.map((source) => {
+		const line = byKey.get(source.sourceKey);
+		if (!line || line.id !== lineIdentity(String(invoice.id), source.sourceKey) || line.sourceKeyHash !== hash(source.sourceKey) || line.moneySnapshotId !== invoice.moneySnapshotId || line.description !== source.description || line.creditedLineId !== source.creditedLineId || line.netMinor !== source.netMinor || line.taxMinor !== source.taxMinor || line.grossMinor !== source.grossMinor || line.quantityText !== source.quantityText || line.unitRateText !== source.unitRateText || line.sourceFieldsJson !== JSON.stringify(source.sourceFields)) invalid$1("Historical invoice source child no longer matches its original facts");
+		return line;
+	});
+}
+async function assertSourceLineCapacity(db, invoices, source, snapshot) {
+	if (snapshot.facts.detail.kind !== "lines") return;
+	const linked = snapshot.facts.detail.lines.filter((line) => line.creditedLineId !== null);
+	if (!linked.length) return;
+	if (!source || snapshot.facts.kind !== "credit_note") invalid$1("Only an exact historical credit may link original historical lines");
+	const sourceLines = new Map((await readHistoricalSalesLines(db, source)).map((line) => [line.id, line]));
+	const collection = await HistoricalSalesLineCollection.create({ db });
+	const requestSign = snapshot.facts.polarity === "signed" ? -1 : 1;
+	const pending = /* @__PURE__ */ new Map();
+	for (const request of linked) {
+		const original = sourceLines.get(request.creditedLineId ?? "");
+		if (!original) invalid$1("Historical credit line does not belong to its exact original source invoice");
+		const inRequest = pending.get(String(original.id)) ?? {
+			netMinor: 0n,
+			taxMinor: 0n,
+			grossMinor: 0n
+		};
+		const previous = await collection.list({
+			where: {
+				tenantId: source.tenantId,
+				creditedLineId: original.id
+			},
+			limit: 100001
+		});
+		if (previous.length > 1e5) invalid$1("Historical source line capacity exceeds the bounded credit scope");
+		const consumed = {
+			netMinor: 0n,
+			taxMinor: 0n,
+			grossMinor: 0n
+		};
+		for (const line of previous) {
+			const parent = await invoices.get({
+				id: line.invoiceId,
+				tenantId: source.tenantId
+			}, { cache: false });
+			if (!parent || parent.kind !== "credit_note" || parent.creditedInvoiceId !== source.id) invalid$1("Historical source line has invalid credit lineage");
+			if (parent.status === InvoiceStatus.DRAFT || parent.status === InvoiceStatus.CANCELLED) continue;
+			const prior = getHistoricalSalesMoney(parent);
+			if (!prior) invalid$1("Historical source line has no original monetary authority");
+			const sign = prior.facts.polarity === "signed" ? -1 : 1;
+			for (const field of [
+				"netMinor",
+				"taxMinor",
+				"grossMinor"
+			]) if (line[field] !== null) consumed[field] += BigInt(line[field]) * BigInt(sign);
+		}
+		for (const field of [
+			"netMinor",
+			"taxMinor",
+			"grossMinor"
+		]) {
+			const originalAmount = original[field], requestedAmount = request[field];
+			if (originalAmount === null || requestedAmount === null) continue;
+			const magnitude = originalAmount < 0 ? -1n : 1n;
+			const originalMagnitude = BigInt(originalAmount) * magnitude;
+			const requestMagnitude = BigInt(requestedAmount) * BigInt(requestSign) * magnitude;
+			if (requestMagnitude < 0n || (consumed[field] + inRequest[field]) * magnitude + requestMagnitude > originalMagnitude) invalid$1("Historical credit exceeds an exact original source line monetary capacity");
+		}
+		for (const field of [
+			"netMinor",
+			"taxMinor",
+			"grossMinor"
+		]) if (request[field] !== null) inRequest[field] += BigInt(request[field]) * BigInt(requestSign);
+		pending.set(String(original.id), inRequest);
+	}
+}
+function stableRequest(snapshot) {
+	return {
+		source: snapshot.source,
+		facts: snapshot.facts,
+		evidenceRef: snapshot.evidenceRef,
+		policyRef: snapshot.review.policyRef,
+		creditedSource: snapshot.creditedSource
+	};
+}
+async function recordHistoricalSalesMoney(input) {
+	if (getTenantId() !== input.tenantId) invalid$1("Historical sales require the explicit active tenant");
+	const facts = validateHistoricalSalesMoneyFacts(input.facts), source = validateHistoricalSalesSource(input.source);
+	const snapshot = {
+		version: 1,
+		requestId: historicalText(input.requestId),
+		evidenceRef: historicalText(input.evidenceRef),
+		review: {
+			actorId: historicalText(input.review?.actorId),
+			policyRef: historicalText(input.review?.policyRef)
+		},
+		recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		source,
+		facts,
+		creditedSource: input.creditedSource ? {
+			invoiceId: historicalText(input.creditedSource.invoiceId),
+			moneySnapshotId: historicalText(input.creditedSource.moneySnapshotId)
+		} : null
+	};
+	if (facts.kind === "credit_note" !== Boolean(snapshot.creditedSource)) invalid$1("Historical credits require the exact original issued invoice snapshot");
+	return withTenantMoneyRuntime(input.db, input.tenantId, async ({ db }) => {
+		const { invoice } = await lockAndReloadInvoice(db, historicalText(input.invoiceId), input.tenantId);
+		if (invoice.tenantId !== input.tenantId) invalid$1("Historical invoice is not owned by the active tenant");
+		const existing = getHistoricalSalesMoney(invoice);
+		if (existing) {
+			if (hash(stableRequest(existing)) !== hash(stableRequest(snapshot))) invalid$1("Historical invoice retry differs from its original facts or reviewed policy");
+			return {
+				snapshot: existing,
+				invoiceId: String(invoice.id),
+				moneySnapshotId: invoice.moneySnapshotId,
+				lines: (await readHistoricalSalesLines(db, invoice)).map((line) => ({
+					sourceKey: line.sourceKey,
+					lineId: String(line.id)
+				}))
+			};
+		}
+		if (invoice.status !== InvoiceStatus.DRAFT || invoice.moneySnapshotId || invoice.arJournalId || invoice.amountPaid || invoice.creditedAmount || invoice.retentionStateJson || invoice.externalId || invoice.externalProvider || invoice.providerTaxAmount) invalid$1("Historical source money requires an empty unfrozen invoice without current financial effects");
+		if (invoice.kind !== facts.kind || invoice.currency !== facts.currency) invalid$1("Historical source kind/currency must match its draft invoice");
+		if (!(invoice.customerId ? await (await CustomerCollection.create({ db })).get({
+			id: invoice.customerId,
+			tenantId: input.tenantId
+		}, { cache: false }) : null)) invalid$1("Historical sales require a customer owned by the active tenant");
+		if ((await (await InvoiceLineItemCollection.create({ db })).findByInvoice(String(invoice.id))).length) invalid$1("Historical source money cannot mix with calculated invoice lines");
+		const invoices = await InvoiceCollection.create({ db });
+		const duplicate = (await invoices.list({
+			where: {
+				tenantId: input.tenantId,
+				historicalSourceKeyHash: historicalSalesSourceHash(source)
+			},
+			limit: 1
+		}))[0];
+		if (duplicate && duplicate.id !== invoice.id) invalid$1("Historical source identity already belongs to another canonical invoice");
+		for (const component of facts.taxComponents ?? []) {
+			const code = component.taxCodeId ? await (await TaxCodeCollection.create({ db })).get({
+				id: component.taxCodeId,
+				tenantId: input.tenantId
+			}, { cache: false }) : null;
+			if (component.taxCodeId && (!code || component.classification !== null && code.kind !== component.classification)) invalid$1("Historical source tax code is not owned by its tenant with the reviewed classification");
+			if (component.taxComponentId) {
+				const tax = await (await TaxComponentCollection.create({ db })).get({
+					id: component.taxComponentId,
+					tenantId: input.tenantId
+				}, { cache: false });
+				if (!tax || code && !code.components.some((part) => part.taxComponentId === tax.id)) invalid$1("Historical source tax component is not owned by its declared tenant/code");
+			}
+			if (component.liabilityAccountId) {
+				const { AccountCollection } = await import("@happyvertical/smrt-ledgers");
+				const account = await (await AccountCollection.create({ db })).get({
+					id: component.liabilityAccountId,
+					tenantId: input.tenantId
+				}, { cache: false });
+				if (!account || account.type !== "liability") invalid$1("Historical source tax liability account is not owned by its tenant with the required type");
+			}
+		}
+		let credited = null;
+		const amounts = historicalSalesMagnitudes(facts);
+		if (snapshot.creditedSource) {
+			credited = (await lockAndReloadInvoice(db, snapshot.creditedSource.invoiceId, input.tenantId)).invoice;
+			if (credited.kind !== "invoice" || credited.tenantId !== input.tenantId || credited.customerId !== invoice.customerId || credited.currency !== invoice.currency || !credited.moneySnapshotId || credited.moneySnapshotId !== snapshot.creditedSource.moneySnapshotId || credited.status === InvoiceStatus.DRAFT || credited.status === InvoiceStatus.CANCELLED || invoice.creditedInvoiceId !== credited.id) invalid$1("Historical credit original invoice/customer/currency/snapshot does not match");
+			const prior = (await invoices.list({
+				where: {
+					tenantId: input.tenantId,
+					creditedInvoiceId: credited.id
+				},
+				limit: 100001
+			}).then((rows) => {
+				if (rows.length > 1e5) invalid$1("Historical credit scope exceeds its bounded source limit");
+				return rows;
+			})).filter((row) => row.id !== invoice.id && row.status !== InvoiceStatus.DRAFT && row.status !== InvoiceStatus.CANCELLED);
+			if (prior.length > 1e5) invalid$1("Historical credit scope exceeds its bounded source limit");
+			const retention = parseInvoiceRetention(credited.retentionStateJson);
+			if (retention) {
+				const credits = [...prior.map((row) => ({
+					on: getHistoricalSalesMoney(row)?.source.issuedOn ?? row.issueDate.toISOString().slice(0, 10),
+					amount: row.totalAmount
+				})), {
+					on: source.issuedOn,
+					amount: amounts.grossMinor
+				}];
+				let remaining = retention.retainedMinor;
+				const events = [...credits.map((event) => ({
+					...event,
+					kind: "credit",
+					rank: 1
+				})), ...retention.releases.map((release) => {
+					const on = release.effectiveOn ?? release.recordedAt.slice(0, 10);
+					if (credits.some((event) => event.on === on) && !release.sameDayCreditOrder) invalid$1("Same-day original retention release/credit requires explicit reviewed ordering");
+					return {
+						on,
+						amount: release.amountMinor,
+						kind: "release",
+						rank: release.sameDayCreditOrder === "release-before-credit" ? 0 : 2
+					};
+				})].sort((left, right) => left.on.localeCompare(right.on) || left.rank - right.rank);
+				for (const event of events) if (event.kind === "credit") remaining = Math.max(0, remaining - event.amount);
+				else {
+					if (event.amount > remaining) invalid$1("Original retention release exceeds retained-first capacity at its source date");
+					remaining -= event.amount;
+				}
+			}
+			for (const [field, value] of [
+				["subtotal", amounts.netMinor],
+				["taxAmount", amounts.taxMinor],
+				["totalAmount", amounts.grossMinor]
+			]) if (prior.reduce((sum, row) => sum + BigInt(row[field]), 0n) + BigInt(value) > BigInt(credited[field])) invalid$1("Historical credit exceeds the remaining exact original net/tax/gross capacity");
+		}
+		await assertSourceLineCapacity(db, invoices, credited, snapshot);
+		if (source.retention && (facts.kind !== "invoice" || source.retention.retainedMinor > amounts.grossMinor)) invalid$1("Historical retention must match original invoice gross");
+		const originalRetention = originalRetentionState(snapshot);
+		invoice.retentionStateJson = originalRetention ? JSON.stringify(originalRetention) : "";
+		invoice.moneyAuthority = "historical";
+		invoice.historicalSalesMoneyJson = JSON.stringify(snapshot);
+		invoice.historicalSourceKeyHash = historicalSalesSourceHash(source);
+		invoice.subtotal = amounts.netMinor;
+		invoice.discountTotal = 0;
+		invoice.taxAmount = amounts.taxMinor;
+		invoice.providerTaxAmount = 0;
+		invoice.totalAmount = amounts.grossMinor;
+		invoice.issueDate = /* @__PURE__ */ new Date(`${source.issuedOn}T00:00:00Z`);
+		invoice.dueDate = source.dueOn === null ? null : /* @__PURE__ */ new Date(`${source.dueOn}T00:00:00Z`);
+		invoice.moneySnapshotId = snapshotIdentity(invoice, snapshot);
+		invoice.status = InvoiceStatus.SENT;
+		await assertContractScheduleInvoiceFreeze(db, invoice);
+		await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
+		if (facts.detail.kind === "lines") for (const line of facts.detail.lines) {
+			const child = await new HistoricalSalesLine({
+				db,
+				id: lineIdentity(String(invoice.id), line.sourceKey),
+				tenantId: input.tenantId,
+				invoiceId: String(invoice.id),
+				...line,
+				sourceKeyHash: hash(line.sourceKey),
+				moneySnapshotId: invoice.moneySnapshotId
+			}).initialize();
+			await withHistoricalCommerceWrite(child, () => child.save());
+		}
+		if (credited) await refreshIssuedCreditBalance(db, credited);
+		return {
+			snapshot: structuredClone(snapshot),
+			invoiceId: String(invoice.id),
+			moneySnapshotId: invoice.moneySnapshotId,
+			lines: (await readHistoricalSalesLines(db, invoice)).map((line) => ({
+				sourceKey: line.sourceKey,
+				lineId: String(line.id)
+			}))
+		};
+	});
+}
+//#endregion
+//#region src/historical-sales-reports.ts
+var HistoricalSalesTaxClassificationRequired = class extends Error {
+	constructor(invoiceId) {
+		super(`Historical invoice ${invoiceId} retains exact header totals, but this tax breakdown requires explicit reviewed source classification, tax identity and taxable basis. Read the historical header facts or resolve the source assessment; never infer a rate or line allocation.`);
+		this.invoiceId = invoiceId;
+		this.name = "HistoricalSalesTaxClassificationRequired";
+	}
+	invoiceId;
+	code = "HISTORICAL_SALES_TAX_CLASSIFICATION_REQUIRED";
+};
+function classified(invoice) {
+	const snapshot = getHistoricalSalesMoney(invoice);
+	if (!snapshot) return false;
+	const components = snapshot.facts.taxComponents;
+	return Boolean(components?.length && components.every((component) => component.classification !== null && component.taxCodeId && component.taxableMinor !== null && component.netMinor !== null && (component.classification !== "taxable" || component.taxComponentId)));
+}
+function historicalSalesTaxReportFacts(invoice) {
+	const snapshot = getHistoricalSalesMoney(invoice);
+	if (!snapshot) return [];
+	if (snapshot.facts.netMinor === 0 && snapshot.facts.taxMinor === 0) return [];
+	if (!classified(invoice)) throw new HistoricalSalesTaxClassificationRequired(String(invoice.id));
+	const sign = snapshot.facts.kind === "credit_note" && snapshot.facts.polarity === "signed" ? -1 : 1;
+	return (snapshot.facts.taxComponents ?? []).map((component) => {
+		if (component.classification === null || !component.taxCodeId || component.taxableMinor === null) throw new HistoricalSalesTaxClassificationRequired(String(invoice.id));
+		return {
+			tenantId: String(invoice.tenantId),
+			documentType: invoice.kind,
+			documentId: String(invoice.id),
+			documentNumber: invoice.invoiceNumber,
+			partyId: invoice.customerId,
+			documentKind: invoice.kind,
+			issueDate: invoice.issueDate.toISOString(),
+			status: invoice.status,
+			direction: "sales",
+			currency: invoice.currency,
+			taxCodeId: component.taxCodeId,
+			taxCodeKind: component.classification,
+			taxableMinor: component.taxableMinor * sign,
+			...component.netMinor === null ? {} : { netMinor: component.netMinor * sign },
+			taxMinor: component.amountMinor * sign,
+			recoverableMinor: 0,
+			taxComponentId: component.taxComponentId,
+			componentName: component.label,
+			liabilityAccountId: component.liabilityAccountId,
+			commitmentId: null,
+			commitmentLineId: null
+		};
+	});
+}
+async function historicalSalesReportInvoices(db, options) {
+	const rows = await (await InvoiceCollection.create({ db })).list({
+		where: {
+			tenantId: options.tenantId,
+			moneyAuthority: "historical",
+			"issueDate >=": options.from.toISOString(),
+			"issueDate <=": options.to.toISOString(),
+			"status not in": ["draft", "cancelled"],
+			...options.currency ? { currency: options.currency } : {}
+		},
+		limit: 100001
+	});
+	if (rows.length > 1e5) throw new Error("Historical sales report scope exceeds the bounded document limit; select a smaller scope");
+	return rows;
+}
+async function listHistoricalSalesHeaderFacts(input) {
+	if (getTenantId() !== input.tenantId) throw new Error("Historical sales reporting requires the explicit active tenant");
+	if (!(input.from instanceof Date) || !(input.to instanceof Date) || !Number.isFinite(input.from.getTime()) || !Number.isFinite(input.to.getTime()) || input.from > input.to) throw new Error("Historical sales report requires an explicit valid period");
+	return withTenantMoneyRuntime(input.db, input.tenantId, async ({ db }) => (await historicalSalesReportInvoices(db, input)).map((invoice) => {
+		const snapshot = getHistoricalSalesMoney(invoice);
+		if (!snapshot) throw new Error("Historical source monetary authority is unavailable");
+		return {
+			invoiceId: String(invoice.id),
+			moneySnapshotId: invoice.moneySnapshotId,
+			customerId: invoice.customerId,
+			invoiceNumber: invoice.invoiceNumber,
+			kind: invoice.kind,
+			issueDate: invoice.issueDate.toISOString(),
+			currency: invoice.currency,
+			...historicalSalesMagnitudes(snapshot.facts),
+			taxBreakdownKnown: classified(invoice)
+		};
+	}));
+}
+//#endregion
+//#region src/models/DocumentTax.ts
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+	var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+	for (var i = decorators.length - 1, decorator; i >= 0; i--) if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+	if (kind && result) __defProp(target, key, result);
+	return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var DocumentTax = class extends SmrtObject {
+	tenantId = "";
+	documentType = "invoice";
+	documentId = "";
+	currency = "USD";
+	taxCodeId = null;
+	taxCodeCode = null;
+	kind = null;
+	taxComponentId = null;
+	taxComponentName = null;
+	percent = null;
+	liabilityAccountId = null;
+	taxableMinor = 0;
+	netMinor = null;
+	taxMinor = 0;
+	recoverableMinor = 0;
+	constructor(options = {}) {
+		super(options);
+		if (options.tenantId !== void 0) this.tenantId = options.tenantId;
+		if (options.documentType !== void 0) this.documentType = options.documentType;
+		if (options.documentId !== void 0) this.documentId = options.documentId;
+		if (options.currency !== void 0) this.currency = options.currency;
+		if (options.taxCodeId !== void 0) this.taxCodeId = options.taxCodeId;
+		if (options.taxCodeCode !== void 0) this.taxCodeCode = options.taxCodeCode;
+		if (options.kind !== void 0) this.kind = options.kind;
+		if (options.taxComponentId !== void 0) this.taxComponentId = options.taxComponentId;
+		if (options.taxComponentName !== void 0) this.taxComponentName = options.taxComponentName;
+		if (options.percent !== void 0) this.percent = options.percent;
+		if (options.liabilityAccountId !== void 0) this.liabilityAccountId = options.liabilityAccountId;
+		if (options.taxableMinor !== void 0) this.taxableMinor = options.taxableMinor;
+		if (options.netMinor !== void 0) this.netMinor = options.netMinor;
+		if (options.taxMinor !== void 0) this.taxMinor = options.taxMinor;
+		if (options.recoverableMinor !== void 0) this.recoverableMinor = options.recoverableMinor;
+	}
+	assertValidDerivedRow() {
+		if (![
+			"invoice",
+			"contract",
+			"credit_note"
+		].includes(this.documentType)) throw new MoneyValidationError("INVALID_MONEY_INPUT", `Unknown document tax type: ${this.documentType}`);
+		for (const [label, value] of [
+			["tenantId", this.tenantId],
+			["documentId", this.documentId],
+			["currency", this.currency]
+		]) if (!value || value.trim() !== value) throw new MoneyValidationError("INVALID_MONEY_INPUT", `DocumentTax ${label} must be a nonempty value`);
+		for (const [label, value] of [
+			["taxableMinor", this.taxableMinor],
+			["netMinor", this.netMinor ?? this.taxableMinor],
+			["taxMinor", this.taxMinor],
+			["recoverableMinor", this.recoverableMinor]
+		]) if (!Number.isSafeInteger(value)) throw new MoneyValidationError("UNSAFE_MONEY", `DocumentTax ${label} must be safe integer minor units`);
+		if (this.taxCodeId === null) {
+			if (this.taxComponentId !== null || this.taxCodeCode !== null || this.kind !== null || this.taxComponentName !== null || this.percent !== null || this.liabilityAccountId !== null || this.taxMinor !== 0 || this.recoverableMinor !== 0) throw new MoneyValidationError("INVALID_MONEY_INPUT", "An unassigned DocumentTax row cannot carry code/component snapshots or tax");
+			return;
+		}
+		if (!this.taxCodeCode || !this.kind) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Assigned DocumentTax rows require code and kind snapshots");
+		if (this.taxComponentId === null) {
+			if (this.kind === "taxable" || this.taxComponentName !== null || this.percent !== null || this.liabilityAccountId !== null || this.taxMinor !== 0 || this.recoverableMinor !== 0) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Component-less DocumentTax rows must be non-taxable zero-tax snapshots");
+			return;
+		}
+		if (this.kind !== "taxable" || !this.taxComponentName || !this.percent) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Component DocumentTax rows require taxable component snapshots");
+		if (this.recoverableMinor !== 0 && this.recoverableMinor !== this.taxMinor) throw new MoneyValidationError("INVALID_MONEY_INPUT", "DocumentTax recoverableMinor must be zero or the component tax total");
+	}
+	async save() {
+		throw new MoneyValidationError("FROZEN_DOCUMENT", "DocumentTax rows are derived and cannot be saved directly");
+	}
+	async delete(_options = {}) {
+		throw new MoneyValidationError("FROZEN_DOCUMENT", "DocumentTax rows are derived and cannot be deleted directly");
+	}
+	/** @internal Aggregate persistence only. */
+	async saveDerived(capability) {
+		if (capability !== DOCUMENT_MONEY_WRITE) throw new MoneyValidationError("FROZEN_DOCUMENT", "DocumentTax write capability is required");
+		this.assertValidDerivedRow();
+		return await super.save();
+	}
+	/** @internal Aggregate persistence only. */
+	async deleteDerived(capability, options = {}) {
+		if (capability !== DOCUMENT_MONEY_WRITE) throw new MoneyValidationError("FROZEN_DOCUMENT", "DocumentTax write capability is required");
+		await super.delete(options);
+	}
+};
+__publicField(DocumentTax, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass([tenantId()], DocumentTax.prototype, "tenantId", 2);
+__decorateClass([field({ required: true })], DocumentTax.prototype, "documentType", 2);
+__decorateClass([field({ required: true })], DocumentTax.prototype, "documentId", 2);
+__decorateClass([field({ required: true })], DocumentTax.prototype, "currency", 2);
+__decorateClass([field({ nullable: true })], DocumentTax.prototype, "taxCodeId", 2);
+__decorateClass([field({ nullable: true })], DocumentTax.prototype, "taxCodeCode", 2);
+__decorateClass([field({ nullable: true })], DocumentTax.prototype, "kind", 2);
+__decorateClass([field({ nullable: true })], DocumentTax.prototype, "taxComponentId", 2);
+__decorateClass([field({ nullable: true })], DocumentTax.prototype, "taxComponentName", 2);
+__decorateClass([field({
+	type: "decimal",
+	nullable: true
+})], DocumentTax.prototype, "percent", 2);
+__decorateClass([field({ nullable: true })], DocumentTax.prototype, "liabilityAccountId", 2);
+__decorateClass([field({
+	description: "Actual component taxable basis, including prior compound taxes.",
+	ui: { format: "money" }
+})], DocumentTax.prototype, "taxableMinor", 2);
+__decorateClass([field({
+	type: "integer",
+	nullable: true,
+	description: "Net basis when different from the component taxable basis.",
+	ui: { format: "money" }
+})], DocumentTax.prototype, "netMinor", 2);
+__decorateClass([field({
+	description: "Tax total in integer minor units.",
+	ui: { format: "money" }
+})], DocumentTax.prototype, "taxMinor", 2);
+__decorateClass([field({
+	description: "Recoverable purchase tax in integer minor units.",
+	ui: { format: "money" }
+})], DocumentTax.prototype, "recoverableMinor", 2);
+DocumentTax = __decorateClass([TenantScoped({ mode: "required" }), smrt({
+	tableName: "document_taxes",
+	conflictColumns: [
+		"document_type",
+		"document_id",
+		"tax_code_id",
+		"tax_component_id"
+	],
+	api: { include: ["list", "get"] },
+	mcp: { include: ["list", "get"] },
+	cli: { include: ["list", "get"] }
+})], DocumentTax);
+//#endregion
+//#region src/collections/VendorCollection.ts
+var VendorCollection = class extends SmrtCollection {
+	static _itemClass = Vendor;
+	/**
+	* Find vendors by profile ID
+	*
+	* @param profileId - Profile ID from smrt-profiles
+	* @returns Array of vendors linked to this profile
+	*/
+	async findByProfile(profileId) {
+		return await this.list({
+			where: { profileId },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Find all active vendors
+	*
+	* @returns Array of active vendors
+	*/
+	async findActive() {
+		return await this.list({
+			where: { status: VendorStatus.ACTIVE },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Find vendors by status
+	*
+	* @param status - Vendor status
+	* @returns Array of vendors
+	*/
+	async findByStatus(status) {
+		return await this.list({
+			where: { status },
+			orderBy: "created_at DESC"
+		});
+	}
+	/**
+	* Get or create a vendor for a profile
+	*
+	* @param profileId - Profile ID
+	* @param defaults - Default values if creating
+	* @returns Vendor
+	*/
+	async getOrCreateForProfile(profileId, defaults = {}) {
+		const existing = await this.findByProfile(profileId);
+		if (existing.length > 0) return existing[0];
+		const vendor = await this.create({
+			profileId,
+			leadTimeDays: defaults.leadTimeDays ?? 0,
+			minimumOrderAmount: defaults.minimumOrderAmount ?? 0,
+			paymentTerms: defaults.paymentTerms ?? "",
+			status: VendorStatus.ACTIVE
+		});
+		await vendor.save();
+		return vendor;
+	}
+	/**
+	* Find all vendors belonging to a specific tenant
+	*
+	* @param tenantId - Tenant ID
+	* @returns Array of vendors for the tenant
+	*/
+	async findByTenant(tenantId) {
+		return this.list({ where: { tenantId } });
+	}
+	/**
+	* Find all global vendors (not associated with any tenant).
+	*
+	* Routes through the shared tenant-global helper so it does not throw under
+	* an active tenant context (an explicit `tenant_id IS NULL` filter would be
+	* flagged as an isolation violation). (#1600)
+	*
+	* @returns Array of global vendors
+	*/
+	async findGlobal() {
+		return queryGlobal(this);
+	}
+	/**
+	* Find vendors for a tenant including global vendors.
+	*
+	* Fails closed if an active tenant context requests a different tenant's
+	* rows; the admin/system path keeps the cross-tenant capability. (#1600)
+	*
+	* @param tenantId - Tenant ID
+	* @returns Array of tenant-specific and global vendors
+	*/
+	async findWithGlobals(tenantId) {
+		return queryWithGlobals(this, tenantId, "Vendor.findWithGlobals");
+	}
+};
+//#endregion
+//#region src/received-purchase-money.ts
+async function recordReceivedSalesContractMoney(input) {
+	if (Object.hasOwn(input, "sourceQuote")) invalid("Sales agreement evidence cannot reference a supplier quote");
+	if (input.facts.taxComponents?.some((component) => component.recoverableMinor !== null)) invalid("Purchase tax recovery is not applicable to sales agreement evidence; retain null");
+	return recordReceivedContractMoney(input, "sales");
+}
+function getReceivedSalesContractMoney(contract) {
+	if (!(contract instanceof Order || contract instanceof Agreement)) return null;
+	return getReceivedPurchaseMoney(contract);
+}
+function invalid(message) {
+	throw new MoneyValidationError("INVALID_MONEY_INPUT", message);
+}
+function object(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) invalid(`${label} must be an object`);
+	return value;
+}
+function text(value, label) {
+	if (typeof value !== "string" || !value || value.trim() !== value) invalid(`${label} must be nonempty trimmed text`);
+	return value;
+}
+function minor(value, label) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) invalid(`${label} must be a nonnegative safe integer`);
+	return value;
+}
+function amounts(value, label) {
+	const netMinor = minor(value.netMinor, `${label} net`);
+	const taxMinor = minor(value.taxMinor, `${label} tax`);
+	const grossMinor = minor(value.grossMinor, `${label} gross`);
+	if (BigInt(netMinor) + BigInt(taxMinor) !== BigInt(grossMinor)) invalid(`${label} net plus tax must equal gross`);
+	return {
+		netMinor,
+		taxMinor,
+		grossMinor
+	};
+}
+function unique(keys, label) {
+	if (new Set(keys).size !== keys.length) invalid(`${label} source keys must be unique`);
+}
+function validateReceivedPurchaseMoneyFacts(value) {
+	const input = object(value, "Received purchase facts");
+	const currency = text(input.currency, "Currency");
+	if (!/^[A-Z]{3}$/.test(currency) || !ISO_4217_MINOR_UNITS.has(currency) || ISO_4217_MINOR_UNITS.get(currency) === null) invalid("Currency must be a supported uppercase ISO 4217 code");
+	const totals = amounts(input, "Document");
+	let taxComponents = null;
+	if (input.taxComponents !== null) {
+		if (!Array.isArray(input.taxComponents)) invalid("Tax components must be an array or explicit null");
+		taxComponents = input.taxComponents.map((raw) => {
+			const component = object(raw, "Tax component");
+			const amountMinor = minor(component.amountMinor, "Component amount");
+			const recoverableMinor = component.recoverableMinor === null ? null : minor(component.recoverableMinor, "Recoverable amount");
+			if (recoverableMinor !== null && recoverableMinor > amountMinor) invalid("Recoverable tax cannot exceed component tax");
+			const classification = component.classification;
+			if (classification !== null && ![
+				"taxable",
+				"zero-rated",
+				"exempt",
+				"out-of-scope"
+			].includes(String(classification))) invalid("Unknown tax classification");
+			const taxableMinor = component.taxableMinor == null ? null : minor(component.taxableMinor, "Taxable basis");
+			const netMinor = component.netMinor == null ? null : minor(component.netMinor, "Component net basis");
+			if (netMinor !== null && netMinor > totals.netMinor) invalid("Component net basis exceeds document net");
+			if (classification !== null && classification !== "taxable" && amountMinor !== 0) invalid("A non-taxable classification cannot contain tax");
+			return {
+				sourceKey: text(component.sourceKey, "Component source key"),
+				label: text(component.label, "Component label"),
+				amountMinor,
+				classification,
+				taxCodeId: component.taxCodeId == null ? null : text(component.taxCodeId, "Tax code identity"),
+				taxComponentId: component.taxComponentId == null ? null : text(component.taxComponentId, "Tax component identity"),
+				taxableMinor,
+				...netMinor !== null ? { netMinor } : {},
+				recoverableMinor
+			};
+		});
+		unique(taxComponents.map((item) => item.sourceKey), "Tax component");
+		if (taxComponents.reduce((sum, item) => sum + BigInt(item.amountMinor), 0n) !== BigInt(totals.taxMinor)) invalid("Component tax sum must equal document tax");
+	}
+	const rawDetail = object(input.detail, "Source detail");
+	let detail;
+	if (rawDetail.kind === "header-only") {
+		if ("lines" in rawDetail) invalid("Header-only evidence cannot contain monetary lines");
+		detail = { kind: "header-only" };
+	} else if (rawDetail.kind === "lines") {
+		if (!Array.isArray(rawDetail.lines) || !rawDetail.lines.length) invalid("Complete source lines are required");
+		const lines = rawDetail.lines.map((raw) => {
+			const line = object(raw, "Source line");
+			const result = {
+				sourceKey: text(line.sourceKey, "Line source key"),
+				description: text(line.description, "Line description"),
+				...amounts(line, "Source line")
+			};
+			for (const key of ["quantityText", "unitRateText"]) {
+				if (line[key] === void 0) continue;
+				const decimal = text(line[key], key);
+				if (!/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(decimal)) invalid(`${key} must be nonnegative decimal source text`);
+				result[key] = decimal;
+			}
+			return result;
+		});
+		unique(lines.map((item) => item.sourceKey), "Line");
+		for (const key of [
+			"netMinor",
+			"taxMinor",
+			"grossMinor"
+		]) if (lines.reduce((sum, line) => sum + BigInt(line[key]), 0n) !== BigInt(totals[key])) invalid(`Source line ${key} sum must equal document amount`);
+		detail = {
+			kind: "lines",
+			lines
+		};
+	} else invalid("Unknown received source detail kind");
+	return {
+		currency,
+		...totals,
+		taxComponents,
+		detail
+	};
+}
+function quoteSource(value) {
+	if (value == null) return null;
+	const input = object(value, "Source quote");
+	if (input.relationship !== "copy" && input.relationship !== "negotiated") invalid("Unknown source quote relationship");
+	return {
+		contractId: text(input.contractId, "Source quote identity"),
+		relationship: input.relationship
+	};
+}
+function getReceivedPurchaseMoney(contract) {
+	if (contract.moneyAuthority === "calculated") {
+		if (contract.receivedPurchaseMoneyJson) invalid("Calculated money cannot contain received evidence");
+		return null;
+	}
+	if (contract.moneyAuthority !== "received") invalid("Unknown contract money authority");
+	let parsed;
+	try {
+		parsed = JSON.parse(contract.receivedPurchaseMoneyJson);
+	} catch {
+		invalid("Stored received money is invalid");
+	}
+	const input = object(parsed, "Received snapshot");
+	if (input.version !== 1) invalid("Unknown received money version");
+	return {
+		version: 1,
+		requestId: text(input.requestId, "Request identity"),
+		evidenceRef: text(input.evidenceRef, "Evidence reference"),
+		facts: validateReceivedPurchaseMoneyFacts(input.facts),
+		sourceQuote: quoteSource(input.sourceQuote)
+	};
+}
+async function recordReceivedPurchaseMoney(input) {
+	return recordReceivedContractMoney(input, "purchase");
+}
+async function recordReceivedContractMoney(input, direction) {
+	const tenantId = text(input.tenantId, "Tenant");
+	if (getTenantId() !== tenantId) invalid("Received contract money requires its active tenant context");
+	const contractId = text(input.contractId, "Contract");
+	const snapshot = {
+		version: 1,
+		requestId: text(input.requestId, "Request identity"),
+		evidenceRef: text(input.evidenceRef, "Evidence reference"),
+		facts: validateReceivedPurchaseMoneyFacts(input.facts),
+		sourceQuote: quoteSource(input.sourceQuote)
+	};
+	const serialized = JSON.stringify(snapshot);
+	return withTenantMoneyRuntime(input.db, tenantId, async ({ db }) => {
+		const contracts = await ContractCollection.create({ db });
+		await lockDocumentMoneyParents([{
+			id: contractId,
+			tenantId,
+			collection: contracts
+		}, ...snapshot.sourceQuote ? [{
+			id: snapshot.sourceQuote.contractId,
+			tenantId,
+			collection: contracts
+		}] : []]);
+		const contract = await contracts.get({ id: contractId }, { cache: false });
+		const validParty = direction === "purchase" ? (contract instanceof SupplierQuote || contract instanceof PurchaseOrder) && contract.vendorId : (contract instanceof Order || contract instanceof Agreement) && contract.customerId;
+		if (!contract || contract.tenantId !== tenantId || !validParty) invalid(direction === "purchase" ? "Received money requires a supplier quote or purchase order in the active tenant" : "Received money requires an Order or Agreement with a customer in the active tenant");
+		const stored = getReceivedPurchaseMoney(contract);
+		if (stored) {
+			if (JSON.stringify(stored) !== serialized) invalid("Received money request changed; create a separate contract revision");
+			return stored;
+		}
+		if (direction === "purchase" && (contract instanceof SupplierQuote || contract instanceof PurchaseOrder)) {
+			const vendor = await (await VendorCollection.create({ db })).get({ id: contract.vendorId }, { cache: false });
+			if (!vendor || vendor.tenantId !== tenantId) invalid("Supplier must belong to the active tenant");
+		} else if (contract instanceof Order || contract instanceof Agreement) {
+			const customer = await (await CustomerCollection.create({ db })).get({ id: contract.customerId }, { cache: false });
+			if (!customer || customer.tenantId !== tenantId) invalid("Customer must belong to the active tenant");
+		}
+		if (snapshot.sourceQuote) {
+			if (!(contract instanceof PurchaseOrder)) invalid("Only a purchase order can reference a source quote");
+			const source = await contracts.get({ id: snapshot.sourceQuote.contractId }, { cache: false });
+			if (!(source instanceof SupplierQuote) || source.tenantId !== tenantId || source.vendorId !== contract.vendorId || source.currency !== contract.currency || source.status !== ContractStatus.ACCEPTED || !source.moneySnapshotId) invalid("Source quote must be accepted with matching tenant, vendor and currency");
+			const sourceMoney = getReceivedPurchaseMoney(source);
+			if (!sourceMoney) invalid("Source quote must have received monetary evidence");
+			if (snapshot.sourceQuote.relationship === "copy" && JSON.stringify(sourceMoney.facts) !== JSON.stringify(snapshot.facts)) invalid("Copied quote monetary facts must match exactly");
+			if (snapshot.sourceQuote.relationship === "negotiated" && snapshot.evidenceRef === sourceMoney.evidenceRef) invalid("Negotiated award requires separate approved monetary evidence");
+		}
+		for (const component of snapshot.facts.taxComponents ?? []) {
+			if (component.taxCodeId) {
+				const code = await (await TaxCodeCollection.create({ db })).get({ id: component.taxCodeId }, { cache: false });
+				if (!code || code.tenantId !== tenantId) invalid("Tax report code must belong to the active tenant");
+				if (component.classification !== null && code.kind !== component.classification) invalid("Explicit tax classification must match its selected code");
+				if (component.taxComponentId && !code.components.some((entry) => entry.taxComponentId === component.taxComponentId)) invalid("Tax component must belong to its selected tax code");
+			}
+			if (component.taxComponentId) {
+				const tax = await (await TaxComponentCollection.create({ db })).get({ id: component.taxComponentId }, { cache: false });
+				if (!tax || tax.tenantId !== tenantId) invalid("Tax report component must belong to the active tenant");
+			}
+		}
+		if (contract.status !== ContractStatus.DRAFT || contract.moneySnapshotId) invalid("Received money requires an unfrozen draft");
+		if (contract.currency !== snapshot.facts.currency) invalid("Received money currency must match the contract");
+		if ((await (await ContractLineItemCollection.create({ db })).findByContract(contractId)).length) invalid("Received money cannot mix with calculated contract lines");
+		contract.moneyAuthority = "received";
+		contract.receivedPurchaseMoneyJson = serialized;
+		contract.subtotal = snapshot.facts.netMinor;
+		contract.discountTotal = 0;
+		contract.taxAmount = snapshot.facts.taxMinor;
+		contract.totalAmount = snapshot.facts.grossMinor;
+		await contract.saveDerived(DOCUMENT_MONEY_WRITE);
+		return snapshot;
+	});
+}
+var ReceivedPurchaseTaxClassificationRequired = class extends Error {
+	constructor(contractId) {
+		super(`Purchase order ${contractId} needs explicit tax classification, tax-code/component identity, taxable basis and recoverability in its received evidence before tax reporting. Record a reviewed replacement revision; do not infer tax rates.`);
+		this.contractId = contractId;
+		this.name = "ReceivedPurchaseTaxClassificationRequired";
+	}
+	contractId;
+	code = "RECEIVED_PURCHASE_TAX_CLASSIFICATION_REQUIRED";
+};
+function receivedPurchaseReportFacts(contract) {
+	const snapshot = getReceivedPurchaseMoney(contract);
+	if (!snapshot || !(contract instanceof PurchaseOrder)) return [];
+	const id = text(contract.id, "Purchase order identity");
+	const components = snapshot.facts.taxComponents;
+	if (!components?.length) throw new ReceivedPurchaseTaxClassificationRequired(id);
+	return components.map((component) => {
+		if (component.classification === null || !component.taxCodeId || component.taxableMinor == null || component.recoverableMinor === null || component.taxableMinor > snapshot.facts.netMinor && component.netMinor == null || component.classification === "taxable" && !component.taxComponentId) throw new ReceivedPurchaseTaxClassificationRequired(id);
+		return {
+			tenantId: text(contract.tenantId, "Tenant"),
+			documentType: "contract",
+			documentId: id,
+			documentNumber: contract.reference.trim() || id,
+			partyId: contract.vendorId,
+			documentKind: "contract",
+			issueDate: contract.issueDate.toISOString(),
+			status: contract.status,
+			direction: "purchase",
+			currency: snapshot.facts.currency,
+			taxCodeId: component.taxCodeId,
+			taxCodeKind: component.classification,
+			taxableMinor: component.taxableMinor,
+			...component.netMinor != null ? { netMinor: component.netMinor } : {},
+			taxMinor: component.amountMinor,
+			recoverableMinor: component.recoverableMinor,
+			taxComponentId: component.taxComponentId ?? null,
+			componentName: component.label,
+			liabilityAccountId: null,
+			commitmentId: id,
+			commitmentLineId: null
+		};
+	});
+}
+//#endregion
+//#region src/collections/DocumentTaxCollection.ts
+var DocumentTaxCollection_exports = /* @__PURE__ */ __exportAll({ DocumentTaxCollection: () => DocumentTaxCollection });
+var TAX_CODE_KINDS = /* @__PURE__ */ new Set([
+	"taxable",
+	"zero-rated",
+	"exempt",
+	"out-of-scope"
+]);
+function requiredText(value, label) {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`Invoice tax report ${label} must be a nonempty string.`);
+	return value;
+}
+function storedMinor(value, label) {
+	const parsed = typeof value === "bigint" ? Number(value) : typeof value === "number" ? value : typeof value === "string" && /^-?\d+$/.test(value) ? Number(value) : NaN;
+	if (!Number.isSafeInteger(parsed)) throw new RangeError(`Invoice tax report ${label} must be a safe integer minor-unit value.`);
+	return parsed;
+}
+function reportDate(value, label) {
+	const date = new Date(String(value));
+	if (Number.isNaN(date.getTime())) throw new Error(`Invoice tax report ${label} must be a valid date.`);
+	return date.toISOString();
+}
+function invoiceDocumentType(value) {
+	if (value === "invoice" || value === "credit_note") return value;
+	throw new Error("Invoice tax report document type must be invoice or credit_note.");
+}
+function invoiceKind(value) {
+	if (value === "invoice" || value === "credit_note") return value;
+	throw new Error("Invoice tax report kind must be invoice or credit_note.");
+}
+function contractDocumentType(value) {
+	if (value === "contract") return value;
+	throw new Error("Contract tax report document type must be contract.");
+}
+function taxCodeKind(value) {
+	return typeof value === "string" && TAX_CODE_KINDS.has(value) ? value : null;
+}
+function assertReportFactOptions(options) {
+	if (!options.tenantId?.trim()) throw new Error("Invoice tax report facts require a tenant.");
+	if (!(options.from instanceof Date) || Number.isNaN(options.from.getTime())) throw new Error("Invoice tax report facts require a valid start date.");
+	if (!(options.to instanceof Date) || Number.isNaN(options.to.getTime())) throw new Error("Invoice tax report facts require a valid end date.");
+	if (options.from > options.to) throw new Error("Invoice tax report facts require an ordered date range.");
+	if (options.currency !== void 0 && !options.currency.trim()) throw new Error("Invoice tax report currency must be nonempty when supplied.");
+}
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function identity(row) {
+	return `${row.taxCodeId === null ? "0:" : `1:${row.taxCodeId}`}\0${row.taxComponentId === null ? "0:" : `1:${row.taxComponentId}`}`;
+}
+var BUSINESS_FIELDS = [
+	"tenantId",
+	"documentType",
+	"documentId",
+	"currency",
+	"taxCodeId",
+	"taxCodeCode",
+	"kind",
+	"taxComponentId",
+	"taxComponentName",
+	"percent",
+	"liabilityAccountId",
+	"taxableMinor",
+	"netMinor",
+	"taxMinor",
+	"recoverableMinor"
+];
+function unchanged(row, input) {
+	return BUSINESS_FIELDS.every((field) => {
+		const persisted = row[field];
+		const proposed = input[field];
+		if (field === "percent" && persisted !== null && proposed !== null) return String(persisted) === String(proposed);
+		return (persisted ?? null) === (proposed ?? null);
+	});
+}
+var DocumentTaxCollection = class extends SmrtCollection {
+	static _itemClass = DocumentTax;
+	/**
+	* Read immutable commerce document-tax snapshots for one tenant.
+	*
+	* Invoice/credit rows join their shared storage by identity and tenant.
+	* Purchase Contract rows first use the Contract owner's bounded hydrated
+	* candidate API so custom PurchaseContract descendants retain their STI
+	* classification. The query then joins only those candidate ids by identity
+	* and tenant. Stored snapshots remain authoritative; this never recalculates
+	* money or resolves present-day tax configuration.
+	*/
+	async listReportFacts(options) {
+		assertReportFactOptions(options);
+		const [invoiceFacts, purchaseFacts] = await Promise.all([this.listInvoiceReportFacts(options), this.listPurchaseContractReportFacts(options)]);
+		return [...invoiceFacts, ...purchaseFacts].sort((left, right) => left.issueDate.localeCompare(right.issueDate) || left.documentId.localeCompare(right.documentId) || String(left.taxCodeId).localeCompare(String(right.taxCodeId)) || String(left.taxComponentId).localeCompare(String(right.taxComponentId)));
+	}
+	async listInvoiceReportFacts(options) {
+		const currencyClause = options.currency ? " AND d.currency = ?" : "";
+		return [...(await this.db.query(`SELECT d.tenant_id, d.document_type, d.document_id, d.currency, d.tax_code_id, d.kind,
+              d.tax_component_id, d.tax_component_name, d.liability_account_id,
+              d.taxable_minor, d.net_minor, d.tax_minor, d.recoverable_minor,
+              i.kind AS invoice_kind, i.invoice_number, i.customer_id, i.issue_date, i.status
+         FROM document_taxes d
+         JOIN invoices i
+           ON CAST(i.id AS TEXT) = CAST(d.document_id AS TEXT)
+          AND i.tenant_id = d.tenant_id
+        WHERE CAST(d.tenant_id AS TEXT) = ?
+          AND CAST(i.tenant_id AS TEXT) = ?
+          AND (
+            (d.document_type = 'invoice' AND i.kind = 'invoice')
+            OR (d.document_type = 'credit_note' AND i.kind = 'credit_note')
+          )
+          AND i.status NOT IN ('draft', 'cancelled')
+          AND i.issue_date >= ?
+          AND i.issue_date <= ?${currencyClause}
+        ORDER BY i.issue_date ASC, i.id ASC, d.tax_code_id ASC, d.tax_component_id ASC`, options.tenantId, options.tenantId, options.from.toISOString(), options.to.toISOString(), ...options.currency ? [options.currency] : [])).rows.map((row) => ({
+			tenantId: requiredText(row.tenant_id, "tenant id"),
+			documentType: invoiceDocumentType(row.document_type),
+			documentId: requiredText(row.document_id, "document id"),
+			documentNumber: requiredText(row.invoice_number, "invoice number"),
+			partyId: typeof row.customer_id === "string" && row.customer_id.trim() ? row.customer_id : null,
+			documentKind: invoiceKind(row.invoice_kind),
+			issueDate: reportDate(row.issue_date, "issue date"),
+			status: requiredText(row.status, "invoice status"),
+			direction: "sales",
+			currency: requiredText(row.currency, "currency"),
+			taxCodeId: row.tax_code_id == null ? null : String(row.tax_code_id),
+			taxCodeKind: taxCodeKind(row.kind),
+			taxableMinor: storedMinor(row.taxable_minor, "taxable minor"),
+			...row.net_minor != null ? { netMinor: storedMinor(row.net_minor, "net minor") } : {},
+			taxMinor: storedMinor(row.tax_minor, "tax minor"),
+			recoverableMinor: storedMinor(row.recoverable_minor, "recoverable minor"),
+			taxComponentId: row.tax_component_id == null ? null : String(row.tax_component_id),
+			componentName: row.tax_component_name == null ? null : String(row.tax_component_name),
+			liabilityAccountId: row.liability_account_id == null ? null : String(row.liability_account_id),
+			commitmentId: null,
+			commitmentLineId: null
+		})), ...(await historicalSalesReportInvoices(this.db, options)).flatMap(historicalSalesTaxReportFacts)];
+	}
+	async listPurchaseContractReportFacts(options) {
+		const candidates = (await withTenant({ tenantId: options.tenantId }, () => ContractCollection.create({ db: this.db }).then((collection) => collection.listSnapshotReportContracts({
+			tenantId: options.tenantId,
+			from: options.from,
+			to: options.to
+		})))).filter((contract) => classifyContractPurchase(contract) && (!options.currency || contract.currency === options.currency));
+		const receivedFacts = candidates.filter((contract) => contract.moneyAuthority === "received").flatMap(receivedPurchaseReportFacts);
+		const purchases = candidates.filter((contract) => contract.moneyAuthority !== "received");
+		const ids = purchases.flatMap((contract) => contract.id ? [contract.id] : []);
+		if (ids.length === 0) return receivedFacts;
+		const byId = new Map(purchases.flatMap((contract) => contract.id ? [[contract.id, contract]] : []));
+		const placeholders = ids.map(() => "?").join(", ");
+		const currencyClause = options.currency ? " AND d.currency = ?" : "";
+		return [...(await this.db.query(`SELECT d.tenant_id, d.document_type, d.document_id, d.currency, d.tax_code_id, d.kind,
+              d.tax_component_id, d.tax_component_name, d.liability_account_id,
+              d.taxable_minor, d.net_minor, d.tax_minor, d.recoverable_minor
+         FROM document_taxes d
+         JOIN contracts c
+           ON CAST(c.id AS TEXT) = CAST(d.document_id AS TEXT)
+          AND c.tenant_id = d.tenant_id
+        WHERE CAST(d.tenant_id AS TEXT) = ?
+          AND CAST(c.tenant_id AS TEXT) = ?
+          AND d.document_type = 'contract'
+          AND c.status NOT IN ('draft', 'cancelled')
+          AND CAST(d.document_id AS TEXT) IN (${placeholders})${currencyClause}
+        ORDER BY c.issue_date ASC, c.id ASC, d.tax_code_id ASC, d.tax_component_id ASC`, options.tenantId, options.tenantId, ...ids, ...options.currency ? [options.currency] : [])).rows.flatMap((row) => {
+			const documentId = requiredText(row.document_id, "contract id");
+			const contract = byId.get(documentId);
+			if (!contract) return [];
+			return [{
+				tenantId: requiredText(row.tenant_id, "tenant id"),
+				documentType: contractDocumentType(row.document_type),
+				documentId,
+				documentNumber: contract.reference.trim() || documentId,
+				partyId: "vendorId" in contract && typeof contract.vendorId === "string" && contract.vendorId.trim() ? contract.vendorId : null,
+				documentKind: "contract",
+				issueDate: reportDate(contract.issueDate, "contract issue date"),
+				status: requiredText(contract.status, "contract status"),
+				direction: "purchase",
+				currency: requiredText(row.currency, "currency"),
+				taxCodeId: row.tax_code_id == null ? null : String(row.tax_code_id),
+				taxCodeKind: taxCodeKind(row.kind),
+				taxableMinor: storedMinor(row.taxable_minor, "taxable minor"),
+				...row.net_minor != null ? { netMinor: storedMinor(row.net_minor, "net minor") } : {},
+				taxMinor: storedMinor(row.tax_minor, "tax minor"),
+				recoverableMinor: storedMinor(row.recoverable_minor, "recoverable minor"),
+				taxComponentId: row.tax_component_id == null ? null : String(row.tax_component_id),
+				componentName: row.tax_component_name == null ? null : String(row.tax_component_name),
+				liabilityAccountId: row.liability_account_id == null ? null : String(row.liability_account_id),
+				commitmentId: documentId,
+				commitmentLineId: null
+			}];
+		}), ...receivedFacts];
+	}
+	async findByDocument(tenantId, documentType, documentId) {
+		return this.list({
+			where: {
+				tenantId,
+				documentType,
+				documentId
+			},
+			orderBy: ["taxCodeId ASC", "taxComponentId ASC"]
+		});
+	}
+	/**
+	* Replace one draft document's derived rows on the caller's transaction.
+	* Unchanged rows are not saved, preserving their exact persisted bytes.
+	*
+	* @internal Aggregate persistence only.
+	*/
+	async replaceDerivedForDocument(capability, input) {
+		if (capability !== DOCUMENT_MONEY_WRITE) throw new MoneyValidationError("FROZEN_DOCUMENT", "DocumentTax write capability is required");
+		const desired = /* @__PURE__ */ new Map();
+		for (const row of input.rows) {
+			if (row.tenantId !== input.tenantId || row.documentType !== input.documentType || row.documentId !== input.documentId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "DocumentTax replacement rows must share tenant and document identity");
+			const key = identity(row);
+			if (desired.has(key)) throw new MoneyValidationError("INVALID_MONEY_INPUT", "DocumentTax replacement contains a duplicate code/component identity");
+			desired.set(key, row);
+		}
+		const existing = await this.findByDocument(input.tenantId, input.documentType, input.documentId);
+		const byIdentity = new Map(existing.map((row) => [identity(row), row]));
+		const result = [];
+		for (const [key, rowInput] of [...desired].sort(([left], [right]) => compareCodeUnits(left, right))) {
+			const current = byIdentity.get(key);
+			if (current) {
+				byIdentity.delete(key);
+				if (!unchanged(current, rowInput)) {
+					Object.assign(current, rowInput);
+					await current.saveDerived(capability);
+				}
+				result.push(current);
+				continue;
+			}
+			const created = await this.createUnsaved(rowInput);
+			await created.saveDerived(capability);
+			result.push(created);
+		}
+		for (const stale of [...byIdentity.values()].sort((left, right) => compareCodeUnits(String(left.id), String(right.id)))) await stale.deleteDerived(capability, { expectedUpdatedAt: stale.updated_at ?? void 0 });
+		return result;
+	}
+};
+//#endregion
+export { DEFAULT_PARTY_CONTACT_FIELD_NAMES as $, PurchaseContractCollection as A, PurchaseOrder as B, refreshIssuedCreditBalance as C, issueContractMilestoneInvoice as D, getContractBillingSchedule as E, Lease as F, isContractSnapshotReportEligible as G, SupplierQuote as H, LicenseSale as I, HistoricalSalesLine as J, Vendor as K, Order as L, Cart as M, Contract as N, ContractCollection as O, Estimate as P, Customer as Q, ProductionOrder as R, previewInvoiceMoney as S, approveContractBillingSchedule as T, WholesaleOrder as U, SalesContract as V, classifyContractPurchase as W, InvoiceLineItem as X, InvoiceLineItemCollection as Y, CustomerCollection as Z, historicalText as _, getReceivedSalesContractMoney as a, normalizePartyContacts as at, getInvoiceMoneyFacts as b, validateReceivedPurchaseMoneyFacts as c, validatePartyContactRows as ct, HistoricalSalesTaxClassificationRequired as d, PARTY_CONTACT_MAX_LENGTHS as et, listHistoricalSalesHeaderFacts as f, historicalCalendarDate as g, recordHistoricalSalesMoney as h, getReceivedPurchaseMoney as i, applyPartyContactIntent as it, Agreement as j, SalesContractCollection as k, VendorCollection as l, readHistoricalSalesLines as m, DocumentTaxCollection_exports as n, PartyContactPayloadError as nt, recordReceivedPurchaseMoney as o, readPartyContactRows as ot, getHistoricalSalesMoney as p, HistoricalSalesLineCollection as q, ReceivedPurchaseTaxClassificationRequired as r, PartyContactValidationError as rt, recordReceivedSalesContractMoney as s, savePartyContacts as st, DocumentTaxCollection as t, PartyContactPartyNotFoundError as tt, DocumentTax as u, validateHistoricalSalesMoneyFacts as v, allocateContractMilestones as w, lockAndReloadInvoice as x, document_money_exports as y, PurchaseContract as z };
+
+//# sourceMappingURL=DocumentTaxCollection-C6cI5U89.js.map