@happyvertical/smrt-commerce 0.57.4 → 0.57.6

package/dist/chunks/{retention-accounting-Brdj9x-V.js → retention-accounting-c7kY7gFU.js}

@@ -1,16 +1,16 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { Y as InvoiceLineItemCollection, t as DocumentTaxCollection, x as lockAndReloadInvoice } from "./DocumentTaxCollection-C42x0YLW.js";
+import { Y as InvoiceLineItemCollection, t as DocumentTaxCollection, x as lockAndReloadInvoice } from "./DocumentTaxCollection-C6cI5U89.js";
 import { d as PaymentStatus, s as InvoiceStatus, u as PaymentMethod } from "./types-Bbm0Xflc.js";
 import { o as minorToMajorUnits } from "./units-8ElbjVZK.js";
-import { n as withRetentionAccountingAuthority, t as hasRetentionAccountingAuthority } from "./retention-accounting-internal-CBQRvd74.js";
-import { i as claimAllocationParent, n as allocationTotal, r as assertAllocationParent, t as allocationOwner } from "./allocation-integrity-DJ7-LY1j.js";
+import { i as withOrdinaryAccountingAuthority, n as withRetentionAccountingAuthority, r as hasOrdinaryAccountingAuthority, t as hasRetentionAccountingAuthority } from "./retention-accounting-internal-DNxLLVvK.js";
+import { i as claimAllocationParent, n as allocationTotal, r as assertAllocationParent, t as allocationOwner } from "./allocation-integrity-CH-i-hsY.js";
 import { n as customerFundsState, t as assertCustomerFundsWrite } from "./customer-funds-internal-BQzoJXK5.js";
 import { MoneyValidationError, assertIntegerMinorUnits, calculateMoneyDocument } from "../money.js";
 import { t as HistoricalCustomerFundsAllocationCollection } from "./HistoricalCustomerFundsCollections-B5x8gTW3.js";
 import { n as calculateAvailableRefund } from "./credit-allocation-yspz0Lab.js";
 import { _ as withDocumentMoneyTransaction, m as isMoneyTransaction, p as DOCUMENT_MONEY_WRITE } from "./detect-DAE-_NAk.js";
-import { c as validateRetentionEvidence, o as calculateInvoicePayable, s as parseInvoiceRetention, t as InvoiceCollection } from "./InvoiceCollection-BIcge9Wl.js";
-import { t as lockTenantMoneyRuntime } from "./tenant-money-barrier-DoF6lR8h.js";
+import { c as validateRetentionEvidence, o as calculateInvoicePayable, s as parseInvoiceRetention, t as InvoiceCollection } from "./InvoiceCollection-BolwughC.js";
+import { t as lockTenantMoneyRuntime } from "./tenant-money-barrier-DEVLrpaB.js";
 import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, isPostgresDatabase, smrt } from "@happyvertical/smrt-core";
 import { TenantScoped, getTenantId, queryGlobal, queryWithGlobals, tenantId } from "@happyvertical/smrt-tenancy";
 import { createHash, randomUUID } from "node:crypto";
@@ -50,6 +50,7 @@ var Payment = class extends SmrtObject {
 	kind = "payment";
 	customerFundsJson = "";
 	retentionAccountingBindingJson = "";
+	ordinaryAccountingBindingJson = "";
 	tenantId = null;
 	contractId = null;
 	customerId = null;
@@ -212,6 +213,8 @@ var Payment = class extends SmrtObject {
 			]);
 			const priorRow = await this.loadPersistedRow();
 			if (this.customerFundsJson || priorRow?.customer_funds_json) assertCustomerFundsWrite(this);
+			const ordinaryBinding = this.ordinaryAccountingBindingJson || String(priorRow?.ordinary_accounting_binding_json ?? "");
+			if (ordinaryBinding && !hasOrdinaryAccountingAuthority(this.tenantId, JSON.parse(ordinaryBinding).invoiceId)) throw new Error("Provider-recorded refund is immutable; use an explicit reversal workflow");
 			const retainedBinding = this.retentionAccountingBindingJson || String(priorRow?.retention_accounting_binding_json ?? "");
 			if (retainedBinding && !hasRetentionAccountingAuthority(this.tenantId, JSON.parse(retainedBinding).invoiceId)) throw new Error("Provider-recorded refund is immutable; use an explicit reversal workflow");
 			const prior = priorRow && priorRow.status != null ? priorRow.status : loadedPaymentStatus.get(this);
@@ -231,7 +234,7 @@ var Payment = class extends SmrtObject {
 	/** Managed receipts and refunds retain immutable cash provenance. */
 	async delete(options = {}) {
 		const persisted = await this.loadPersistedRow();
-		if (this.retentionAccountingBindingJson || persisted?.retention_accounting_binding_json) throw new Error("Provider-recorded refund history cannot be deleted");
+		if (this.retentionAccountingBindingJson || persisted?.retention_accounting_binding_json || this.ordinaryAccountingBindingJson || persisted?.ordinary_accounting_binding_json) throw new Error("Provider-recorded refund history cannot be deleted");
 		if (this.customerFundsJson || persisted?.customer_funds_json) throw new Error("Customer funds cash history cannot be deleted");
 		return super.delete(options);
 	}
@@ -509,6 +512,7 @@ var Payment = class extends SmrtObject {
 __publicField$1(Payment, "__smrtPackage__", "@happyvertical/smrt-commerce");
 __decorateClass$1([field({ type: "text" })], Payment.prototype, "customerFundsJson", 2);
 __decorateClass$1([field({ sensitive: true })], Payment.prototype, "retentionAccountingBindingJson", 2);
+__decorateClass$1([field({ sensitive: true })], Payment.prototype, "ordinaryAccountingBindingJson", 2);
 __decorateClass$1([tenantId({ nullable: true })], Payment.prototype, "tenantId", 2);
 __decorateClass$1([field({ description: "The order or agreement this payment is for, if any." }), foreignKey("SalesContract", { validateSubtype: true })], Payment.prototype, "contractId", 2);
 __decorateClass$1([field({ description: "The customer who paid." }), foreignKey("Customer")], Payment.prototype, "customerId", 2);
@@ -809,7 +813,7 @@ var PaymentAllocation = class extends SmrtObject {
 		if (!this.paymentId || !this.invoiceId) throw new Error("PaymentAllocation requires payment and invoice");
 		return this.withTransaction(async () => {
 			const { PaymentCollection } = await Promise.resolve().then(() => PaymentCollection_exports);
-			const { InvoiceCollection } = await import("./InvoiceCollection-BIcge9Wl.js").then((n) => n.n);
+			const { InvoiceCollection } = await import("./InvoiceCollection-BolwughC.js").then((n) => n.n);
 			const { PaymentAllocationCollection } = await Promise.resolve().then(() => PaymentAllocationCollection_exports);
 			const payments = await PaymentCollection.create({ db: this.db });
 			const invoices = await InvoiceCollection.create({ db: this.db });
@@ -818,7 +822,7 @@ var PaymentAllocation = class extends SmrtObject {
 			if (prior && (prior.paymentId !== this.paymentId || prior.invoiceId !== this.invoiceId || prior.tenantId !== allocationOwner(this.tenantId))) throw new Error("PaymentAllocation parent identity is immutable");
 			const payment = await payments.get({ id: this.paymentId }, { cache: false });
 			if (!payment) throw new Error("PaymentAllocation referenced Payment does not exist");
-			if (payment.retentionAccountingBindingJson) throw new Error("Provider-recorded refund allocation is immutable");
+			if (payment.retentionAccountingBindingJson || payment.ordinaryAccountingBindingJson) throw new Error("Provider-recorded refund allocation is immutable");
 			if (customerFundsState(payment.customerFundsJson)) assertCustomerFundsWrite(this);
 			if (!payment.updated_at) throw new Error("Allocation parent has no persisted revision");
 			await payment.claimRevision(payment.updated_at);
@@ -882,7 +886,7 @@ var PaymentAllocation = class extends SmrtObject {
 				if (!payment.updated_at) throw new Error("Allocation parent has no persisted revision");
 				await payment.claimRevision(payment.updated_at);
 			}
-			if (payment?.retentionAccountingBindingJson) throw new Error("Provider-recorded refund allocation cannot be deleted");
+			if (payment?.retentionAccountingBindingJson || payment?.ordinaryAccountingBindingJson) throw new Error("Provider-recorded refund allocation cannot be deleted");
 			if (payment?.customerFundsJson) assertCustomerFundsWrite(this);
 			return super.delete(options);
 		});
@@ -916,7 +920,7 @@ var PaymentAllocationCollection = class PaymentAllocationCollection extends Smrt
 	async allocatePayment(input) {
 		if (!input.allocations.length || new Set(input.allocations.map((item) => item.id)).size !== input.allocations.length) throw new Error("Allocation batch requires distinct stable allocation ids");
 		const { PaymentCollection } = await Promise.resolve().then(() => PaymentCollection_exports);
-		const { InvoiceCollection } = await import("./InvoiceCollection-BIcge9Wl.js").then((n) => n.n);
+		const { InvoiceCollection } = await import("./InvoiceCollection-BolwughC.js").then((n) => n.n);
 		const { InvoiceStatus } = await import("./types-Bbm0Xflc.js").then((n) => n.m);
 		const payment = await (await PaymentCollection.create({ db: this.db })).get({ id: input.paymentId }, { cache: false });
 		if (!payment) throw new Error("Payment does not exist");
@@ -959,7 +963,7 @@ var PaymentAllocationCollection = class PaymentAllocationCollection extends Smrt
 		const allocation = await this.get({ id }, { cache: false });
 		if (!allocation) return;
 		const { PaymentCollection } = await Promise.resolve().then(() => PaymentCollection_exports);
-		const { InvoiceCollection } = await import("./InvoiceCollection-BIcge9Wl.js").then((n) => n.n);
+		const { InvoiceCollection } = await import("./InvoiceCollection-BolwughC.js").then((n) => n.n);
 		const payment = await (await PaymentCollection.create({ db: this.db })).get({ id: allocation.paymentId }, { cache: false });
 		if (!payment) throw new Error("Allocation payment does not exist");
 		await payment.withTransaction(async () => {
@@ -1347,6 +1351,7 @@ async function loadSnapshot(db, tenantId, invoice) {
 		const source = await (await InvoiceCollection.create({ db })).get({ id: invoice.creditedInvoiceId }, { cache: false });
 		if (!source || source.tenantId !== tenantId || !source.externalId) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Frozen credit note requires the source invoice external ID");
 		if (source.retentionAccountingStateJson && !hasRetentionAccountingAuthority(source.tenantId, source.id)) unsupported("Provider-retained credit requires the retained-first accounting adjustment command");
+		if (source.ordinaryAccountingStateJson && !hasOrdinaryAccountingAuthority(source.tenantId, source.id)) unsupported("Provider ordinary credit requires its owning accounting adjustment command");
 		const sourceState = parseSyncState(source.accountingSyncStateJson);
 		if (sourceState?.status !== "synced" || sourceState.externalId !== source.externalId) throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", "Frozen credit note requires a reconciled source invoice accounting identity");
 		creditedInvoiceExternalId = source.externalId;
@@ -1457,6 +1462,7 @@ async function prepareSync(input) {
 	return withDocumentMoneyTransaction(input.db, async (tx) => {
 		await lockTenantMoneyRuntime(tx, input.tenantId);
 		const { invoice } = await lockAndReloadInvoice(tx, input.invoiceId, input.tenantId);
+		if (invoice.ordinaryAccountingStateJson && !hasOrdinaryAccountingAuthority(invoice.tenantId, invoice.id)) unsupported("Provider ordinary invoice requires its owning accounting command");
 		const snapshot = await loadSnapshot(tx, input.tenantId, invoice);
 		const sdkInput = toSdkInput(snapshot, input.mapping);
 		const prior = parseSyncState(invoice.accountingSyncStateJson);
@@ -1729,6 +1735,481 @@ function calculateInvoiceMinorLine(input) {
 	};
 }
 //#endregion
+//#region src/accounting-steps-internal.ts
+function reject$2(message) {
+	throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", message);
+}
+function text$2(value, label) {
+	if (typeof value !== "string" || !value || value.trim() !== value) reject$2(`${label} is required`);
+}
+async function executeAccountingStep(engine, key, make) {
+	const prepared = await engine.locked(async (invoice, state) => {
+		if (!state) reject$2("Retention provider contract is missing");
+		const expected = make(invoice, state), prior = state.steps.find((s) => s.key === key);
+		if (prior && prior.request.payloadHash !== expected.payloadHash) reject$2("Retention operation identity reused with changed facts");
+		if (prior?.status === "confirmed") {
+			if (!prior.result) reject$2("Confirmed retention step has no readback");
+			return { complete: prior.result };
+		}
+		if (prior && prior.status !== "rejected") reject$2("Retention operation has an unresolved remote owner");
+		if (state.steps.some((s) => s.key !== key && s.status !== "confirmed")) reject$2("Another retention operation requires reconciliation");
+		const step2 = {
+			key,
+			status: "in_flight",
+			attemptId: randomUUID(),
+			request: expected,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			priorAttempts: prior ? [...prior.priorAttempts ?? [], {
+				attemptId: prior.attemptId,
+				status: prior.status,
+				startedAt: prior.startedAt,
+				reconciliation: prior.reconciliation
+			}] : []
+		};
+		if (prior) state.steps[state.steps.indexOf(prior)] = step2;
+		else state.steps.push(step2);
+		await engine.save(invoice, state);
+		return { step: step2 };
+	});
+	if ("complete" in prepared && prepared.complete) return prepared.complete;
+	if (!prepared.step) reject$2("Prepared retention step is missing");
+	const step = prepared.step;
+	let result;
+	try {
+		result = await engine.provider.execute(step.request);
+	} catch (error) {
+		await engine.locked(async (invoice, state) => {
+			const current = state?.steps.find((s) => s.key === key);
+			if (!state || current?.attemptId !== step.attemptId || current.status !== "in_flight") reject$2("Retention step ownership changed after remote failure");
+			current.status = error?.outcome === "rejected" ? "rejected" : "unknown";
+			await engine.save(invoice, state);
+		});
+		throw error;
+	}
+	return engine.locked(async (invoice, state) => {
+		const current = state?.steps.find((s) => s.key === key);
+		if (!state || current?.attemptId !== step.attemptId || current.status !== "in_flight" || result.payloadHash !== step.request.payloadHash) reject$2("Retention step ownership or readback changed after write");
+		current.status = "confirmed";
+		current.result = structuredClone(result);
+		await engine.save(invoice, state);
+		return result;
+	});
+}
+async function reconcileAccountingStep(engine, input) {
+	const step = await engine.locked(async (_invoice, state) => {
+		const found = state?.steps.find((s) => s.key === input.stepKey);
+		if (!found || found.request.requestId !== input.requestId || found.attemptId !== input.attemptId || !["in_flight", "unknown"].includes(found.status)) reject$2("Observed retention reconciliation owner differs");
+		if (found.status === "in_flight" && !input.confirmInterruptedOwnerStopped) reject$2("Interrupted retention owner must be proven stopped");
+		return structuredClone(found);
+	});
+	const result = input.outcome.status === "found" ? await engine.provider.read(step.request, input.outcome.externalId) : null;
+	if (input.outcome.status === "absent") text$2(input.outcome.evidenceRef, "Authoritative provider absence evidence");
+	return engine.locked(async (invoice, state) => {
+		const current = state?.steps.find((s) => s.key === input.stepKey);
+		if (!state || current?.attemptId !== step.attemptId || current.status !== step.status) reject$2("Retention reconciliation owner changed");
+		current.reconciliation = {
+			outcome: input.outcome.status,
+			recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			interruptedOwnerStopped: input.confirmInterruptedOwnerStopped === true,
+			...input.outcome.status === "found" ? { externalId: input.outcome.externalId } : { evidenceRef: input.outcome.evidenceRef }
+		};
+		if (result) {
+			if (result.payloadHash !== step.request.payloadHash) reject$2("Retention reconciliation readback differs");
+			current.result = result;
+			current.status = "confirmed";
+		} else current.status = "rejected";
+		await engine.save(invoice, state);
+		return state;
+	});
+}
+//#endregion
+//#region src/ordinary-accounting.ts
+var hash$1 = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+function reject$1(message) {
+	throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", message);
+}
+function text$1(value, label) {
+	if (typeof value !== "string" || !value || value.trim() !== value) reject$1(`${label} is required`);
+}
+function date$1(value, label) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || !Number.isFinite(Date.parse(value)) || new Date(value).toISOString().slice(0, 10) !== value) reject$1(`${label} is invalid`);
+}
+function principal$1(input) {
+	if (!input.tenantId || getTenantId() !== input.tenantId) reject$1("Ordinary accounting requires its active tenant");
+	if (isMoneyTransaction(input.db)) reject$1("Provider writes cannot run inside a caller-owned money transaction");
+	if (input.provider.type !== "quickbooks" || !input.provider.receivableTransfers) reject$1("Provider lacks reviewed receivable operations");
+}
+function syncedIdentity(invoice, mapping) {
+	const sync = readFrozenAccountingSyncState(invoice);
+	if (!sync || sync.status !== "synced" || sync.documentKind !== "invoice" || sync.provider !== "quickbooks" || sync.moneySnapshotId !== invoice.moneySnapshotId || sync.realmId !== mapping.realmId || sync.environment !== mapping.environment || invoice.externalProvider !== "quickbooks" || !invoice.externalId) reject$1("Ordinary accounting requires its reconciled frozen invoice export identity");
+}
+function readOrdinaryInvoiceAccountingState(invoice) {
+	if (!invoice.ordinaryAccountingStateJson) return null;
+	let state;
+	try {
+		state = JSON.parse(invoice.ordinaryAccountingStateJson);
+	} catch {
+		return reject$1("Malformed ordinary accounting state");
+	}
+	if (!state || !state.mapping || state.version !== 1 || state.kind !== "ordinary" || state.mapping.kind !== "ordinary" || state.invoiceId !== invoice.id || state.moneySnapshotId !== invoice.moneySnapshotId || state.externalInvoiceId !== null && state.externalInvoiceId !== invoice.externalId || state.currency !== invoice.currency || state.grossMinor !== invoice.totalAmount || state.mapping.customerRef !== invoice.customerExternalId || !Array.isArray(state.steps) || !Array.isArray(state.credits) || !Array.isArray(state.refunds) || invoice.retentionStateJson || invoice.retentionAccountingStateJson || invoice.moneyAuthority !== "calculated") reject$1("Ordinary provider source identity changed");
+	if (state.externalInvoiceId !== null) syncedIdentity(invoice, state.mapping);
+	return state;
+}
+async function locked$1(input, operation) {
+	return withDocumentMoneyTransaction(input.db, async (tx) => {
+		await lockTenantMoneyRuntime(tx, input.tenantId);
+		const { invoice } = await lockAndReloadInvoice(tx, input.invoiceId, input.tenantId);
+		return operation(invoice, readOrdinaryInvoiceAccountingState(invoice));
+	});
+}
+async function save$1(invoice, state) {
+	invoice.ordinaryAccountingStateJson = JSON.stringify(state);
+	await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
+}
+function refreshStatus$1(state) {
+	state.status = state.steps.every((s) => s.status === "confirmed") && state.credits.every((c) => c.committed) && state.refunds.every((r) => r.committed) ? "ready" : "pending";
+}
+function requireReady$1(state) {
+	if (!state || state.status !== "ready" || state.steps.some((s) => s.status !== "confirmed")) reject$1("Ordinary provider operations require reconciliation");
+	return state;
+}
+function requestId$1(state, key) {
+	return `smrt_ord_${hash$1([
+		state.invoiceId,
+		state.moneySnapshotId,
+		state.mapping.realmId,
+		state.mapping.environment,
+		key
+	]).slice(0, 40)}`;
+}
+function executeStep$1(input, key, make) {
+	return executeAccountingStep({
+		locked: (operation) => locked$1(input, operation),
+		save: save$1,
+		provider: input.provider.receivableTransfers
+	}, key, make);
+}
+function validateOrdinarySource(invoice, input) {
+	if (invoice.kind !== "invoice" || !invoice.moneySnapshotId || invoice.retentionStateJson || invoice.retentionAccountingStateJson || invoice.moneyAuthority !== "calculated" || [
+		InvoiceStatus.DRAFT,
+		InvoiceStatus.CANCELLED,
+		InvoiceStatus.WRITTEN_OFF
+	].includes(invoice.status) || invoice.collectionMethod || invoice.providerTaxAmount || invoice.currency !== input.mapping.currency || invoice.customerExternalId !== input.mapping.customerRef || input.invoiceMapping.realmId !== input.mapping.realmId || input.invoiceMapping.environment !== input.mapping.environment) reject$1("Ordinary accounting requires its issued, nonretained canonical frozen source");
+}
+async function syncOrdinaryInvoiceToAccounting(input) {
+	principal$1(input);
+	text$1(input.requestId, "Ordinary request");
+	text$1(input.evidenceRef, "Ordinary evidence");
+	if (input.mapping.kind !== "ordinary") reject$1("Ordinary mapping is required");
+	await locked$1(input, async (invoice) => {
+		validateOrdinarySource(invoice, input);
+		await toFrozenInvoiceAccountingInput({
+			db: invoice.db,
+			tenantId: input.tenantId,
+			invoiceId: input.invoiceId,
+			mapping: input.invoiceMapping
+		});
+	});
+	await input.provider.receivableTransfers.verifyMapping(input.mapping);
+	await locked$1(input, async (invoice, state) => {
+		validateOrdinarySource(invoice, input);
+		const prior = readFrozenAccountingSyncState(invoice);
+		if (prior) {
+			const request = prepareQuickBooksInvoiceRequest({
+				...await toFrozenInvoiceAccountingInput({
+					db: invoice.db,
+					tenantId: input.tenantId,
+					invoiceId: input.invoiceId,
+					mapping: input.invoiceMapping
+				}),
+				externalId: void 0
+			}, {
+				requestId: prior.requestId,
+				realmId: input.invoiceMapping.realmId,
+				environment: input.invoiceMapping.environment
+			});
+			if (prior.provider !== "quickbooks" || prior.documentKind !== "invoice" || prior.moneySnapshotId !== invoice.moneySnapshotId || prior.realmId !== request.realmId || prior.environment !== request.environment || prior.request.payloadHash !== request.payloadHash) reject$1("Ordinary invoice mapping differs from its frozen export request");
+		}
+		if (state) {
+			if (hash$1([
+				state.requestId,
+				state.evidenceRef,
+				state.mapping,
+				state.invoiceMapping
+			]) !== hash$1([
+				input.requestId,
+				input.evidenceRef,
+				input.mapping,
+				input.invoiceMapping
+			])) reject$1("Ordinary accounting initialization changed");
+			return;
+		}
+		await save$1(invoice, {
+			version: 1,
+			kind: "ordinary",
+			invoiceId: input.invoiceId,
+			moneySnapshotId: invoice.moneySnapshotId,
+			externalInvoiceId: null,
+			invoiceMapping: structuredClone(input.invoiceMapping),
+			requestId: input.requestId,
+			evidenceRef: input.evidenceRef,
+			currency: invoice.currency,
+			grossMinor: invoice.totalAmount,
+			mapping: structuredClone(input.mapping),
+			status: "pending",
+			steps: [],
+			credits: [],
+			refunds: []
+		});
+	});
+	const result = await withOrdinaryAccountingAuthority(input.tenantId, input.invoiceId, () => syncFrozenInvoiceToAccounting({
+		...input,
+		mapping: input.invoiceMapping
+	}));
+	return locked$1(input, async (invoice, state) => {
+		if (!state) reject$1("Ordinary provider reservation disappeared");
+		syncedIdentity(invoice, state.mapping);
+		state.externalInvoiceId = result.externalId;
+		refreshStatus$1(state);
+		await save$1(invoice, state);
+		return state;
+	});
+}
+async function reconcileOrdinaryBaseInvoice(input) {
+	principal$1(input);
+	await locked$1(input, async (_invoice, state) => {
+		if (!state || hash$1(state.invoiceMapping) !== hash$1(input.mapping)) reject$1("Ordinary base mapping differs");
+	});
+	return reconcileFrozenInvoiceAccountingSync(input);
+}
+async function reconcileOrdinaryAccountingStep(input) {
+	principal$1(input);
+	return reconcileAccountingStep({
+		locked: (operation) => locked$1(input, operation),
+		save: save$1,
+		provider: input.provider.receivableTransfers
+	}, input);
+}
+async function syncOrdinaryCreditToAccounting(input) {
+	principal$1(input);
+	text$1(input.requestId, "Credit adjustment request");
+	text$1(input.evidenceRef, "Credit adjustment evidence");
+	date$1(input.effectiveOn, "Credit adjustment date");
+	const reserved = await locked$1(input, async (invoice, state) => {
+		if (!state) reject$1("Ordinary provider contract is missing");
+		const credit = await (await InvoiceCollection.create({ db: invoice.db })).get({ id: input.creditInvoiceId }, { cache: false });
+		if (!credit || credit.tenantId !== input.tenantId || credit.customerId !== invoice.customerId || credit.creditedInvoiceId !== invoice.id || credit.kind !== "credit_note" || !credit.moneySnapshotId || [InvoiceStatus.DRAFT, InvoiceStatus.CANCELLED].includes(credit.status) || credit.currency !== state.currency || credit.customerExternalId !== state.mapping.customerRef) reject$1("Credit adjustment requires its issued same-customer source credit");
+		if (input.creditMapping.realmId !== state.mapping.realmId || input.creditMapping.environment !== state.mapping.environment) reject$1("Credit adjustment provider scope differs");
+		const prior = state.credits.find((c) => c.creditId === input.creditInvoiceId || c.requestId === input.requestId);
+		if (prior) {
+			if (prior.creditId !== input.creditInvoiceId || prior.requestId !== input.requestId || prior.moneySnapshotId !== credit.moneySnapshotId || prior.grossMinor !== credit.totalAmount || prior.evidenceRef !== input.evidenceRef || prior.effectiveOn !== input.effectiveOn || hash$1(prior.mapping) !== hash$1(input.creditMapping)) reject$1("Credit adjustment identity reused with changed facts");
+			return structuredClone(prior);
+		}
+		requireReady$1(state);
+		if (state.credits.reduce((sum, c) => sum + c.grossMinor, 0) + credit.totalAmount > invoice.creditedAmount) reject$1("Provider credit exceeds issued source credit capacity");
+		const next = {
+			creditId: input.creditInvoiceId,
+			moneySnapshotId: credit.moneySnapshotId,
+			requestId: input.requestId,
+			evidenceRef: input.evidenceRef,
+			effectiveOn: input.effectiveOn,
+			grossMinor: credit.totalAmount,
+			appliedMinor: credit.creditedAmount,
+			mapping: structuredClone(input.creditMapping),
+			committed: false
+		};
+		state.credits.push(next);
+		state.status = "pending";
+		await save$1(invoice, state);
+		return next;
+	});
+	const creditResult = await withOrdinaryAccountingAuthority(input.tenantId, input.invoiceId, () => syncFrozenInvoiceToAccounting({
+		db: input.db,
+		tenantId: input.tenantId,
+		invoiceId: input.creditInvoiceId,
+		provider: input.provider,
+		mapping: input.creditMapping
+	}));
+	const prefix = `credit:${input.requestId}`;
+	const creditSource = (state) => ({
+		type: "CreditMemo",
+		id: creditResult.externalId,
+		customerRef: state.mapping.customerRef,
+		evidenceRef: reserved.moneySnapshotId
+	});
+	if (reserved.appliedMinor > 0) await executeStep$1(input, `${prefix}:due-application`, (invoice, state) => prepareQuickBooksReceivableRequest({
+		kind: "application",
+		mapping: state.mapping,
+		source: creditSource(state),
+		requestId: requestId$1(state, `${prefix}:due-application`),
+		effectiveOn: reserved.effectiveOn,
+		evidenceRef: reserved.evidenceRef,
+		amountMinor: reserved.appliedMinor,
+		debit: {
+			type: "Invoice",
+			id: invoice.externalId
+		},
+		credit: {
+			type: "CreditMemo",
+			id: creditResult.externalId
+		}
+	}));
+	return locked$1(input, async (invoice, state) => {
+		if (!state) reject$1("Ordinary provider state is missing");
+		const credit = state.credits.find((c) => c.creditId === input.creditInvoiceId);
+		if (!credit) reject$1("Credit reservation disappeared");
+		credit.committed = true;
+		refreshStatus$1(state);
+		await save$1(invoice, state);
+		return state;
+	});
+}
+async function syncOrdinaryRefundToAccounting(input) {
+	principal$1(input);
+	text$1(input.requestId, "Refund recording request");
+	text$1(input.evidenceRef, "Refund settlement evidence");
+	date$1(input.effectiveOn, "Refund effective date");
+	const reservation = await locked$1(input, async (invoice, state) => {
+		if (!state) reject$1("Ordinary provider contract is missing");
+		const credit = state.credits.find((c) => c.creditId === input.creditInvoiceId && c.committed);
+		if (!credit) reject$1("Refund requires its reconciled provider credit");
+		const payment = await (await PaymentCollection.create({ db: invoice.db })).get({ id: input.paymentId }, { cache: false });
+		const creditInvoice = await (await InvoiceCollection.create({ db: invoice.db })).get({ id: input.creditInvoiceId }, { cache: false });
+		if (!payment || !creditInvoice || payment.tenantId !== input.tenantId || creditInvoice.tenantId !== input.tenantId || creditInvoice.customerId !== invoice.customerId || creditInvoice.currency !== state.currency || creditInvoice.creditedInvoiceId !== invoice.id || payment.customerId !== invoice.customerId || payment.currency !== state.currency || payment.kind !== "refund" || payment.status !== "completed" || !payment.journalId || !payment.paidAt || new Date(payment.paidAt).toISOString().slice(0, 10) !== input.effectiveOn || !creditInvoice.externalId || creditInvoice.moneySnapshotId !== credit.moneySnapshotId) reject$1("Provider refund requires its completed same-customer local cash journal and source credit");
+		const allocations = await (await PaymentAllocationCollection.create({ db: invoice.db })).findByPayment(input.paymentId);
+		if (allocations.length !== 1 || allocations[0].invoiceId !== input.creditInvoiceId || allocations[0].amount !== payment.amount) reject$1("Refund recording requires one exact full source-credit allocation");
+		const fingerprint = hash$1([
+			payment.id,
+			payment.customerId,
+			payment.currency,
+			payment.amount,
+			payment.journalId,
+			new Date(payment.paidAt).toISOString(),
+			allocations[0].id,
+			allocations[0].amount,
+			credit.moneySnapshotId
+		]);
+		const next = {
+			paymentId: input.paymentId,
+			creditId: input.creditInvoiceId,
+			requestId: input.requestId,
+			evidenceRef: input.evidenceRef,
+			effectiveOn: input.effectiveOn,
+			amountMinor: payment.amount,
+			paymentFingerprint: fingerprint,
+			committed: false
+		};
+		const prior = state.refunds.find((r) => r.paymentId === input.paymentId || r.requestId === input.requestId);
+		if (prior) {
+			if (hash$1({
+				...prior,
+				committed: false
+			}) !== hash$1(next)) reject$1("Refund recording identity reused with changed facts");
+			return {
+				...prior,
+				externalCreditId: creditInvoice.externalId
+			};
+		}
+		requireReady$1(state);
+		if (!state.mapping.cashAccountRef) reject$1("Refund provider bank account must be explicitly reviewed");
+		if (state.refunds.filter((r) => r.creditId === input.creditInvoiceId).reduce((sum, r) => sum + r.amountMinor, 0) + payment.amount > credit.grossMinor - credit.appliedMinor) reject$1("Refund exceeds unapplied provider credit capacity");
+		if (payment.ordinaryAccountingBindingJson || payment.retentionAccountingBindingJson) reject$1("Refund is already bound to a provider operation");
+		payment.ordinaryAccountingBindingJson = JSON.stringify({
+			invoiceId: input.invoiceId,
+			tenantId: input.tenantId,
+			requestId: input.requestId,
+			paymentFingerprint: fingerprint
+		});
+		await withOrdinaryAccountingAuthority(input.tenantId, input.invoiceId, () => payment.save());
+		state.refunds.push(next);
+		state.status = "pending";
+		await save$1(invoice, state);
+		return {
+			...next,
+			externalCreditId: creditInvoice.externalId
+		};
+	});
+	const prefix = `refund:${input.requestId}`;
+	const creditSource = (state) => ({
+		type: "CreditMemo",
+		id: reservation.externalCreditId,
+		customerRef: state.mapping.customerRef,
+		evidenceRef: reservation.paymentFingerprint
+	});
+	const journal = await executeStep$1(input, prefix, (_invoice, state) => prepareQuickBooksReceivableRequest({
+		kind: "cash-refund",
+		mapping: state.mapping,
+		source: creditSource(state),
+		requestId: requestId$1(state, prefix),
+		effectiveOn: reservation.effectiveOn,
+		evidenceRef: reservation.evidenceRef,
+		amountMinor: reservation.amountMinor
+	}));
+	await executeStep$1(input, `${prefix}:application`, (_invoice, state) => prepareQuickBooksReceivableRequest({
+		kind: "application",
+		mapping: state.mapping,
+		source: creditSource(state),
+		requestId: requestId$1(state, `${prefix}:application`),
+		effectiveOn: reservation.effectiveOn,
+		evidenceRef: reservation.evidenceRef,
+		amountMinor: reservation.amountMinor,
+		debit: {
+			type: "JournalEntry",
+			id: journal.externalId
+		},
+		credit: {
+			type: "CreditMemo",
+			id: reservation.externalCreditId
+		}
+	}));
+	return locked$1(input, async (invoice, state) => {
+		if (!state) reject$1("Ordinary provider state disappeared");
+		const refund = state.refunds.find((r) => r.requestId === input.requestId);
+		if (!refund) reject$1("Refund reservation disappeared");
+		refund.committed = true;
+		refreshStatus$1(state);
+		await save$1(invoice, state);
+		return state;
+	});
+}
+async function reconcileOrdinaryCreditAccounting(input) {
+	principal$1(input);
+	const mapping = await locked$1(input, async (_invoice, state) => {
+		const reserved = state?.credits.find((credit) => credit.creditId === input.creditInvoiceId);
+		if (!reserved) reject$1("Ordinary credit has no approved provider reservation");
+		return structuredClone(reserved.mapping);
+	});
+	return withOrdinaryAccountingAuthority(input.tenantId, input.invoiceId, () => reconcileFrozenInvoiceAccountingSync({
+		...input,
+		invoiceId: input.creditInvoiceId,
+		mapping
+	}));
+}
+async function reviewOrdinaryCredit(input, read) {
+	if (getTenantId() !== input.tenantId) reject$1("Ordinary review requires its active tenant");
+	return withDocumentMoneyTransaction(input.db, async (tx) => {
+		await lockTenantMoneyRuntime(tx, input.tenantId);
+		const { invoice } = await lockAndReloadInvoice(tx, input.invoiceId, input.tenantId);
+		if (!readOrdinaryInvoiceAccountingState(invoice)) reject$1("Ordinary provider contract is missing");
+		const credit = await (await InvoiceCollection.create({ db: tx })).get({ id: input.creditInvoiceId }, { cache: false });
+		if (!credit || credit.tenantId !== input.tenantId || credit.creditedInvoiceId !== invoice.id || credit.kind !== "credit_note" || credit.customerId !== invoice.customerId || credit.currency !== invoice.currency || credit.moneyAuthority !== "calculated") reject$1("Ordinary credit review requires exact source lineage");
+		return withOrdinaryAccountingAuthority(input.tenantId, input.invoiceId, () => read({
+			db: tx,
+			tenantId: input.tenantId,
+			invoiceId: input.creditInvoiceId
+		}));
+	});
+}
+function loadOrdinaryCreditAccountingSnapshot(input) {
+	return reviewOrdinaryCredit(input, loadFrozenInvoiceAccountingSnapshot);
+}
+function toOrdinaryCreditAccountingInput(input) {
+	return reviewOrdinaryCredit(input, async (scope) => await toFrozenInvoiceAccountingInput({
+		...scope,
+		mapping: input.mapping
+	}));
+}
+//#endregion
 //#region src/retention-accounting.ts
 var hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 function reject(message) {
@@ -1841,57 +2322,11 @@ function source(invoice, state) {
 	};
 }
 async function executeStep(input, key, make) {
-	const prepared = await locked(input, async (invoice, state) => {
-		if (!state) reject("Retention provider contract is missing");
-		const expected = make(invoice, state), prior = state.steps.find((s) => s.key === key);
-		if (prior && prior.request.payloadHash !== expected.payloadHash) reject("Retention operation identity reused with changed facts");
-		if (prior?.status === "confirmed") {
-			if (!prior.result) reject("Confirmed retention step has no readback");
-			return { complete: prior.result };
-		}
-		if (prior && prior.status !== "rejected") reject("Retention operation has an unresolved remote owner");
-		if (state.steps.some((s) => s.key !== key && s.status !== "confirmed")) reject("Another retention operation requires reconciliation");
-		const step2 = {
-			key,
-			status: "in_flight",
-			attemptId: randomUUID(),
-			request: expected,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			priorAttempts: prior ? [...prior.priorAttempts ?? [], {
-				attemptId: prior.attemptId,
-				status: prior.status,
-				startedAt: prior.startedAt,
-				reconciliation: prior.reconciliation
-			}] : []
-		};
-		if (prior) state.steps[state.steps.indexOf(prior)] = step2;
-		else state.steps.push(step2);
-		await save(invoice, state);
-		return { step: step2 };
-	});
-	if ("complete" in prepared && prepared.complete) return prepared.complete;
-	if (!prepared.step) reject("Prepared retention step is missing");
-	const step = prepared.step;
-	let result;
-	try {
-		result = await input.provider.receivableTransfers.execute(step.request);
-	} catch (error) {
-		await locked(input, async (invoice, state) => {
-			const current = state?.steps.find((s) => s.key === key);
-			if (!state || current?.attemptId !== step.attemptId || current.status !== "in_flight") reject("Retention step ownership changed after remote failure");
-			current.status = error?.outcome === "rejected" ? "rejected" : "unknown";
-			await save(invoice, state);
-		});
-		throw error;
-	}
-	return locked(input, async (invoice, state) => {
-		const current = state?.steps.find((s) => s.key === key);
-		if (!state || current?.attemptId !== step.attemptId || current.status !== "in_flight" || result.payloadHash !== step.request.payloadHash) reject("Retention step ownership or readback changed after write");
-		current.status = "confirmed";
-		current.result = structuredClone(result);
-		await save(invoice, state);
-		return result;
-	});
+	return executeAccountingStep({
+		locked: (operation) => locked(input, operation),
+		save,
+		provider: input.provider.receivableTransfers
+	}, key, make);
 }
 async function syncRetainedInvoiceToAccounting(input) {
 	principal(input);
@@ -2057,31 +2492,11 @@ async function releaseRetainedInvoiceToAccounting(input) {
 }
 async function reconcileRetainedAccountingStep(input) {
 	principal(input);
-	const step = await locked(input, async (_invoice, state) => {
-		const found = state?.steps.find((s) => s.key === input.stepKey);
-		if (!found || found.request.requestId !== input.requestId || found.attemptId !== input.attemptId || !["in_flight", "unknown"].includes(found.status)) reject("Observed retention reconciliation owner differs");
-		if (found.status === "in_flight" && !input.confirmInterruptedOwnerStopped) reject("Interrupted retention owner must be proven stopped");
-		return structuredClone(found);
-	});
-	const result = input.outcome.status === "found" ? await input.provider.receivableTransfers.read(step.request, input.outcome.externalId) : null;
-	if (input.outcome.status === "absent") text(input.outcome.evidenceRef, "Authoritative provider absence evidence");
-	return locked(input, async (invoice, state) => {
-		const current = state?.steps.find((s) => s.key === input.stepKey);
-		if (!state || current?.attemptId !== step.attemptId || current.status !== step.status) reject("Retention reconciliation owner changed");
-		current.reconciliation = {
-			outcome: input.outcome.status,
-			recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			interruptedOwnerStopped: input.confirmInterruptedOwnerStopped === true,
-			...input.outcome.status === "found" ? { externalId: input.outcome.externalId } : { evidenceRef: input.outcome.evidenceRef }
-		};
-		if (result) {
-			if (result.payloadHash !== step.request.payloadHash) reject("Retention reconciliation readback differs");
-			current.result = result;
-			current.status = "confirmed";
-		} else current.status = "rejected";
-		await save(invoice, state);
-		return state;
-	});
+	return reconcileAccountingStep({
+		locked: (operation) => locked(input, operation),
+		save,
+		provider: input.provider.receivableTransfers
+	}, input);
 }
 async function reconcileRetainedBaseInvoice(input) {
 	principal(input);
@@ -2318,6 +2733,6 @@ async function reconcileRetainedCreditAccounting(input) {
 	}));
 }
 //#endregion
-export { historicalCreditRefundCommittedTotal as C, Payment as E, PaymentAllocation as S, PaymentCollection_exports as T, reconcileFrozenInvoiceAccountingSync as _, reconcileRetainedBaseInvoice as a, PaymentAllocationCollection as b, syncRetainedCreditToAccounting as c, toRetainedCreditAccountingInput as d, toRetainedInvoiceAccountingInput as f, readFrozenAccountingSyncState as g, loadFrozenInvoiceAccountingSnapshot as h, reconcileRetainedAccountingStep as i, syncRetainedInvoiceToAccounting as l, invoice_accounting_sync_exports as m, loadRetainedInvoiceAccountingSnapshot as n, reconcileRetainedCreditAccounting as o, calculateInvoiceMinorLine as p, readRetainedInvoiceAccountingState as r, releaseRetainedInvoiceToAccounting as s, loadRetainedCreditAccountingSnapshot as t, syncRetainedRefundToAccounting as u, syncFrozenInvoiceToAccounting as v, PaymentCollection as w, PaymentAllocationCollection_exports as x, toFrozenInvoiceAccountingInput as y };
+export { PaymentAllocationCollection_exports as A, invoice_accounting_sync_exports as C, syncFrozenInvoiceToAccounting as D, reconcileFrozenInvoiceAccountingSync as E, Payment as F, historicalCreditRefundCommittedTotal as M, PaymentCollection as N, toFrozenInvoiceAccountingInput as O, PaymentCollection_exports as P, calculateInvoiceMinorLine as S, readFrozenAccountingSyncState as T, reconcileOrdinaryCreditAccounting as _, reconcileRetainedBaseInvoice as a, syncOrdinaryRefundToAccounting as b, syncRetainedCreditToAccounting as c, toRetainedCreditAccountingInput as d, toRetainedInvoiceAccountingInput as f, reconcileOrdinaryBaseInvoice as g, reconcileOrdinaryAccountingStep as h, reconcileRetainedAccountingStep as i, PaymentAllocation as j, PaymentAllocationCollection as k, syncRetainedInvoiceToAccounting as l, readOrdinaryInvoiceAccountingState as m, loadRetainedInvoiceAccountingSnapshot as n, reconcileRetainedCreditAccounting as o, loadOrdinaryCreditAccountingSnapshot as p, readRetainedInvoiceAccountingState as r, releaseRetainedInvoiceToAccounting as s, loadRetainedCreditAccountingSnapshot as t, syncRetainedRefundToAccounting as u, syncOrdinaryCreditToAccounting as v, loadFrozenInvoiceAccountingSnapshot as w, toOrdinaryCreditAccountingInput as x, syncOrdinaryInvoiceToAccounting as y };
 
-//# sourceMappingURL=retention-accounting-Brdj9x-V.js.map
+//# sourceMappingURL=retention-accounting-c7kY7gFU.js.map