@happyvertical/smrt-commerce 0.56.0 → 0.56.1

package/dist/chunks/DocumentTaxCollection-BEpoqXAQ.js

@@ -0,0 +1,1639 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { i as CustomerType, n as ContractType, p as VendorStatus, r as CustomerStatus, t as ContractStatus } from "./types-LDETvQ1C.js";
+import { MoneyValidationError, assertIntegerMinorUnits } from "../money.js";
+import { a as DOCUMENT_MONEY_READ_REBIND, o as DOCUMENT_MONEY_WRITE } from "./TaxSettingsCollection-BBTZDH1S.js";
+import { i as withTenantMoneyCollectionRead } from "./tenant-money-barrier-DjRXgMnX.js";
+import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, smrt } from "@happyvertical/smrt-core";
+import { TenantScoped, getTenantId, queryGlobal, queryWithGlobals, tenantId, withTenant } from "@happyvertical/smrt-tenancy";
+//#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(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(row.id) || globalThis.crypto.randomUUID(),
+			name: text(row.name),
+			label: text(row.label),
+			email: text(row.email),
+			phone: text(row.phone),
+			address: text(row.address)
+		});
+	}
+	return contacts;
+}
+function readPartyContactRows(form, fieldNames = {}) {
+	const names = {
+		...DEFAULT_PARTY_CONTACT_FIELD_NAMES,
+		...fieldNames
+	};
+	const column = (name) => form.getAll(name).map(text);
+	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(row.id).trim() };
+		let rowErrors;
+		for (const field of FIELDS) {
+			const value = text(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(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$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 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$3(Customer, "__smrtPackage__", "@happyvertical/smrt-commerce");
+__decorateClass$3([tenantId({ nullable: true })], Customer.prototype, "tenantId", 2);
+__decorateClass$3([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$3([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$3([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$3([field({ description: "Turn this on if you do not charge this customer sales tax." })], Customer.prototype, "taxExempt", 2);
+__decorateClass$3([field({
+	sensitive: true,
+	description: "The tax or VAT number of the customer, kept on file for tax-exempt sales."
+})], Customer.prototype, "taxId", 2);
+__decorateClass$3([foreignKey("TaxCode", { description: "The tax code normally used when selling to this customer." })], Customer.prototype, "defaultTaxCodeId", 2);
+__decorateClass$3([field({ description: "Where you usually send goods to this customer, so you do not retype it on every order." })], Customer.prototype, "defaultShippingAddress", 2);
+__decorateClass$3([field({ description: "Where you send invoices to this customer." })], Customer.prototype, "defaultBillingAddress", 2);
+__decorateClass$3([field({ description: "Whether you are still dealing with this customer: active, inactive or suspended." })], Customer.prototype, "status", 2);
+__decorateClass$3([field({ description: "The kind of customer: a direct shopper, a wholesale buyer or a retail customer." })], Customer.prototype, "customerType", 2);
+__decorateClass$3([field({
+	description: "Anything worth remembering about this customer.",
+	ui: { widget: "textarea" }
+})], Customer.prototype, "notes", 2);
+__decorateClass$3([field({ description: "The people you deal with at this customer, with their role and how to reach them." })], Customer.prototype, "contacts", 2);
+Customer = __decorateClass$3([TenantScoped({ mode: "optional" }), smrt({
+	api: { include: [
+		"list",
+		"get",
+		"create",
+		"update"
+	] },
+	mcp: { include: ["list", "get"] },
+	cli: { skipApiCheck: true }
+})], Customer);
+//#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.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;
+	/** Informational sum of resolved line discounts, in integer minor units. */
+	discountTotal = 0;
+	taxAmount = 0;
+	totalAmount = 0;
+	currency = "USD";
+	/** 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.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("../index.js").then((n) => n.t);
+		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 (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("../index.js").then((n) => n.t);
+		return await saveContract(this);
+	}
+	/** @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({
+	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: "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 a purchase order is placed with." })], 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 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) 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/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;
+	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.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],
+			["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: "Tax-exclusive base in integer minor units." })], DocumentTax.prototype, "taxableMinor", 2);
+__decorateClass([field({ description: "Tax total in integer minor units." })], DocumentTax.prototype, "taxMinor", 2);
+__decorateClass([field({ description: "Recoverable purchase tax in integer minor units." })], 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/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",
+	"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.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"),
+			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
+		}));
+	}
+	async listPurchaseContractReportFacts(options) {
+		const purchases = (await withTenant({ tenantId: options.tenantId }, () => ContractCollection.create({ db: this.db }).then((collection) => collection.listSnapshotReportContracts({
+			tenantId: options.tenantId,
+			from: options.from,
+			to: options.to
+		})))).filter(classifyContractPurchase);
+		const ids = purchases.flatMap((contract) => contract.id ? [contract.id] : []);
+		if (ids.length === 0) return [];
+		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.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"),
+				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
+			}];
+		});
+	}
+	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 { savePartyContacts as A, PARTY_CONTACT_MAX_LENGTHS as C, applyPartyContactIntent as D, PartyContactValidationError as E, normalizePartyContacts as O, DEFAULT_PARTY_CONTACT_FIELD_NAMES as S, PartyContactPayloadError as T, SalesContract as _, SalesContractCollection as a, Vendor as b, Cart as c, Lease as d, LicenseSale as f, PurchaseOrder as g, PurchaseContract as h, ContractCollection as i, validatePartyContactRows as j, readPartyContactRows as k, Contract as l, ProductionOrder as m, DocumentTaxCollection_exports as n, PurchaseContractCollection as o, Order as p, DocumentTax as r, Agreement as s, DocumentTaxCollection as t, Estimate as u, WholesaleOrder as v, PartyContactPartyNotFoundError as w, Customer as x, classifyContractPurchase as y };
+
+//# sourceMappingURL=DocumentTaxCollection-BEpoqXAQ.js.map