@happyvertical/smrt-commerce 0.58.0 → 0.59.1

package/dist/chunks/{retention-accounting-BAKsmbwJ.js → retention-accounting-CASwH8OH.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-BmKyJGZi.js";
+import { Y as InvoiceLineItemCollection, t as DocumentTaxCollection, x as lockAndReloadInvoice } from "./DocumentTaxCollection-MFfprLH-.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 deterministicId, o as minorToMajorUnits } from "./units-8ElbjVZK.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-DgnPec2a.js";
+import { i as claimAllocationParent, n as allocationTotal, r as assertAllocationParent, t as allocationOwner } from "./allocation-integrity-ri5cUYXB.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-BPEzXaKm.js";
-import { t as lockTenantMoneyRuntime } from "./tenant-money-barrier-j1m0r6pe.js";
+import { c as validateRetentionEvidence, o as calculateInvoicePayable, s as parseInvoiceRetention, t as InvoiceCollection } from "./InvoiceCollection-D_8NXuaw.js";
+import { t as lockTenantMoneyRuntime } from "./tenant-money-barrier-BbbInDGP.js";
 import { SmrtCollection, SmrtObject, crossPackageRef, field, foreignKey, isPostgresDatabase, smrt } from "@happyvertical/smrt-core";
 import { TenantScoped, getTenantId, queryGlobal, queryWithGlobals, tenantId } from "@happyvertical/smrt-tenancy";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -969,7 +969,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-BPEzXaKm.js").then((n) => n.n);
+			const { InvoiceCollection } = await import("./InvoiceCollection-D_8NXuaw.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 });
@@ -1076,7 +1076,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-BPEzXaKm.js").then((n) => n.n);
+		const { InvoiceCollection } = await import("./InvoiceCollection-D_8NXuaw.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");
@@ -1119,7 +1119,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-BPEzXaKm.js").then((n) => n.n);
+		const { InvoiceCollection } = await import("./InvoiceCollection-D_8NXuaw.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 () => {
@@ -1417,11 +1417,69 @@ function mapFrozenAccountingSnapshot(snapshot, mapping) {
 	};
 }
 //#endregion
+//#region src/quickbooks-pilot-evidence.ts
+function pilotDisagreement(message) {
+	throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", message);
+}
+function quickBooksPilotInvoiceId(tenantId, obligationId) {
+	return deterministicId([
+		"quickbooks-pilot-invoice",
+		tenantId,
+		obligationId
+	]);
+}
+function projectQuickBooksPilotEvidence(evidence) {
+	const { balanceMinor, totalMinor, voided, transactions } = evidence;
+	if (evidence.complete !== true || typeof voided !== "boolean" || !Number.isSafeInteger(balanceMinor) || balanceMinor < 0 || balanceMinor > totalMinor || !Array.isArray(transactions)) pilotDisagreement("QuickBooks invoice readback is incomplete or invalid");
+	const seen = /* @__PURE__ */ new Set();
+	const facts = [];
+	const sums = {
+		payment: 0,
+		credit: 0,
+		refund: 0
+	};
+	for (const entry of evidence.transactions) {
+		if (!entry || typeof entry !== "object") pilotDisagreement("QuickBooks linked transaction evidence is invalid");
+		const { id, kind, amountMinor } = entry;
+		if (![
+			"payment",
+			"credit",
+			"refund"
+		].includes(kind) || typeof id !== "string" || !id || id.trim() !== id || !Number.isSafeInteger(amountMinor) || amountMinor <= 0 || seen.has(JSON.stringify([kind, id]))) pilotDisagreement("QuickBooks linked transaction evidence is invalid or duplicated");
+		seen.add(JSON.stringify([kind, id]));
+		facts.push({
+			id,
+			kind,
+			amountMinor
+		});
+		sums[kind] += amountMinor;
+		if (!Number.isSafeInteger(sums[kind])) pilotDisagreement("QuickBooks linked transaction totals exceed safe minor units");
+	}
+	const paidMinor = sums.payment - sums.refund;
+	if (paidMinor < 0 || (voided ? balanceMinor !== 0 || paidMinor !== 0 || sums.credit !== 0 : BigInt(paidMinor) + BigInt(sums.credit) + BigInt(balanceMinor) !== BigInt(totalMinor))) pilotDisagreement("QuickBooks balance disagrees with linked transaction evidence");
+	let state = "unpaid";
+	if (voided) state = "voided";
+	else if (sums.refund > 0) state = "refunded";
+	else if (balanceMinor === 0 && sums.credit > 0) state = "credited";
+	else if (balanceMinor === 0) state = "paid";
+	else if (paidMinor > 0 || sums.credit > 0) state = "partial";
+	return {
+		balanceMinor,
+		paidMinor,
+		creditedMinor: sums.credit,
+		refundedMinor: sums.refund,
+		state,
+		transactions: facts,
+		observedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+//#endregion
 //#region src/invoice-accounting-sync.ts
 var invoice_accounting_sync_exports = /* @__PURE__ */ __exportAll({
 	loadFrozenInvoiceAccountingSnapshot: () => loadFrozenInvoiceAccountingSnapshot,
 	readFrozenAccountingSyncState: () => readFrozenAccountingSyncState,
 	reconcileFrozenInvoiceAccountingSync: () => reconcileFrozenInvoiceAccountingSync,
+	runQuickBooksPilot: () => runQuickBooksPilot,
 	syncFrozenInvoiceToAccounting: () => syncFrozenInvoiceToAccounting,
 	toFrozenInvoiceAccountingInput: () => toFrozenInvoiceAccountingInput
 });
@@ -1613,7 +1671,7 @@ function requestIdFor(snapshot, mapping) {
 		snapshot.moneySnapshotId
 	])).digest("hex").slice(0, 40)}`;
 }
-async function prepareSync(input) {
+async function prepareSync(input, pilot) {
 	if (input.provider.type !== "quickbooks") unsupported(`Frozen accounting sync does not support provider '${input.provider.type}'`);
 	return withDocumentMoneyTransaction(input.db, async (tx) => {
 		await lockTenantMoneyRuntime(tx, input.tenantId);
@@ -1622,6 +1680,8 @@ async function prepareSync(input) {
 		const snapshot = await loadSnapshot(tx, input.tenantId, invoice);
 		const sdkInput = toSdkInput(snapshot, input.mapping);
 		const prior = parseSyncState(invoice.accountingSyncStateJson);
+		checkPilotAcceptance(invoice, prior, pilot);
+		if (pilot) assertPilotInvoice(invoice);
 		if (prior?.status === "synced" && sameSyncScope(prior.identity, snapshot, input.mapping)) {
 			if (!prior.externalId || !prior.syncedAt) throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", "Completed accounting sync state is incomplete");
 			return {
@@ -1643,17 +1703,7 @@ async function prepareSync(input) {
 			unsupported(error instanceof Error ? error.message : String(error));
 		}
 		const { accountingInput, request } = prepareRequest(snapshot, input.mapping, sdkInput);
-		const identity = {
-			provider: "quickbooks",
-			documentKind: snapshot.document.kind,
-			realmId: request.realmId,
-			environment: request.environment,
-			invoiceId: snapshot.document.id,
-			moneySnapshotId: snapshot.moneySnapshotId,
-			requestId: request.requestId,
-			payloadHash: request.payloadHash,
-			creditedInvoiceExternalId: "creditedInvoiceExternalId" in request ? request.creditedInvoiceExternalId : void 0
-		};
+		const identity = frozenIdentity(snapshot, request);
 		if (prior && !sameIdentity(prior.identity, identity)) throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", "Invoice accounting identity changed across provider, realm, environment, or snapshot");
 		const attemptId = randomUUID();
 		invoice.accountingSyncStateJson = JSON.stringify({
@@ -1661,20 +1711,22 @@ async function prepareSync(input) {
 			status: "in_flight",
 			identity,
 			attemptId,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString()
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			pilot
 		});
 		await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
 		return {
 			kind: "push",
 			documentKind: snapshot.document.kind,
 			accountingInput,
+			invoice,
 			identity,
 			attemptId
 		};
 	});
 }
-async function recordFailure(input, prepared, error) {
-	const rejected = !!error && typeof error === "object" && error.code === "QBO_WRITE_ERROR" && error.outcome === "rejected";
+async function recordFailure(input, prepared, error, pushReturned) {
+	const rejected = !pushReturned && !!error && typeof error === "object" && error.code === "QBO_WRITE_ERROR" && error.outcome === "rejected";
 	await withDocumentMoneyTransaction(input.db, async (tx) => {
 		await lockTenantMoneyRuntime(tx, input.tenantId);
 		const { invoice } = await lockAndReloadInvoice(tx, input.invoiceId, input.tenantId);
@@ -1687,38 +1739,49 @@ async function recordFailure(input, prepared, error) {
 		await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
 	});
 }
-async function recordSuccess(input, prepared, result) {
+async function saveSyncedInvoice(invoice, state, externalId, syncedAt) {
+	invoice.externalId = externalId;
+	invoice.externalProvider = state.identity.provider;
+	invoice.syncedAt = syncedAt;
+	invoice.accountingSyncStateJson = JSON.stringify({
+		...state,
+		status: "synced",
+		externalId,
+		syncedAt: syncedAt.toISOString()
+	});
+	await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
+	return {
+		status: "synced",
+		externalId,
+		syncedAt,
+		moneySnapshotId: state.identity.moneySnapshotId
+	};
+}
+async function recordSuccess(input, prepared, result, pilotProjection) {
 	requiredText(result.externalId, "Accounting external ID");
 	if (!(result.syncedAt instanceof Date) || Number.isNaN(result.syncedAt.valueOf())) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Accounting provider returned an invalid sync timestamp");
 	return withDocumentMoneyTransaction(input.db, async (tx) => {
 		await lockTenantMoneyRuntime(tx, input.tenantId);
 		const { invoice } = await lockAndReloadInvoice(tx, input.invoiceId, input.tenantId);
 		const state = parseSyncState(invoice.accountingSyncStateJson);
-		if (state?.status !== "in_flight" || state.attemptId !== prepared.attemptId || !sameIdentity(state.identity, prepared.identity) || invoice.moneySnapshotId !== prepared.identity.moneySnapshotId) throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", "Accounting sync ownership or frozen snapshot changed after provider write");
-		const syncedAt = result.syncedAt.toISOString();
-		invoice.externalId = result.externalId;
-		invoice.externalProvider = prepared.identity.provider;
-		invoice.syncedAt = result.syncedAt;
-		invoice.accountingSyncStateJson = JSON.stringify({
+		if (state?.status !== "in_flight" || state.attemptId !== prepared.attemptId || !sameIdentity(state.identity, prepared.identity) || invoice.moneySnapshotId !== prepared.identity.moneySnapshotId || state.pilot && invoice.customerExternalId !== prepared.invoice.customerExternalId) throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", "Accounting sync ownership or frozen snapshot changed after provider write");
+		if (state.pilot) await assertUnusedPilotExternalId(tx, invoice, state.identity, result.externalId);
+		return saveSyncedInvoice(invoice, {
 			...state,
-			status: "synced",
-			externalId: result.externalId,
-			syncedAt
-		});
-		await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
-		return {
-			status: "synced",
-			externalId: result.externalId,
-			syncedAt: result.syncedAt,
-			moneySnapshotId: prepared.identity.moneySnapshotId
-		};
+			pilotProjection
+		}, result.externalId, result.syncedAt);
 	});
 }
 async function syncFrozenInvoiceToAccounting(input) {
+	return syncFrozenInvoice(input);
+}
+async function syncFrozenInvoice(input, pilot) {
 	assertPrincipalTenant(input.tenantId);
-	const prepared = await prepareSync(input);
+	const prepared = await prepareSync(input, pilot?.acceptance);
 	if (prepared.kind === "unchanged") return prepared.result;
 	let result;
+	let pushReturned = false;
+	let projection;
 	try {
 		if (prepared.documentKind === "invoice") {
 			if (!("invoiceNumber" in prepared.accountingInput)) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Prepared invoice has the wrong accounting document kind");
@@ -1727,11 +1790,13 @@ async function syncFrozenInvoiceToAccounting(input) {
 			if (!("creditMemoNumber" in prepared.accountingInput)) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Prepared credit note has the wrong accounting document kind");
 			result = await requireCreditMemoOperations(input.provider).push(prepared.accountingInput);
 		}
+		pushReturned = true;
+		projection = await pilot?.verify(prepared.invoice, result);
 	} catch (error) {
-		await recordFailure(input, prepared, error);
+		await recordFailure(input, prepared, error, pushReturned);
 		throw error;
 	}
-	return recordSuccess(input, prepared, result);
+	return recordSuccess(input, prepared, result, projection);
 }
 async function reconcileFrozenInvoiceAccountingSync(input) {
 	assertPrincipalTenant(input.tenantId);
@@ -1743,18 +1808,9 @@ async function reconcileFrozenInvoiceAccountingSync(input) {
 		const snapshot = await loadSnapshot(tx, input.tenantId, invoice);
 		const sdkInput = toSdkInput(snapshot, input.mapping);
 		const { request } = prepareRequest(snapshot, input.mapping, sdkInput);
-		const identity = {
-			provider: "quickbooks",
-			documentKind: snapshot.document.kind,
-			realmId: request.realmId,
-			environment: request.environment,
-			invoiceId: snapshot.document.id,
-			moneySnapshotId: snapshot.moneySnapshotId,
-			requestId: request.requestId,
-			payloadHash: request.payloadHash,
-			creditedInvoiceExternalId: "creditedInvoiceExternalId" in request ? request.creditedInvoiceExternalId : void 0
-		};
+		const identity = frozenIdentity(snapshot, request);
 		const state = parseSyncState(invoice.accountingSyncStateJson);
+		checkPilotAcceptance(invoice, state);
 		if (!state || state.status !== "unknown" && state.status !== "in_flight" || state.identity.requestId !== input.requestId || state.attemptId !== input.attemptId || !sameIdentity(state.identity, identity)) throw new MoneyValidationError("ACCOUNTING_SYNC_RECONCILIATION_REQUIRED", "Accounting reconciliation does not match the unresolved frozen request");
 		if (state.status === "in_flight" && input.confirmInterruptedOwnerStopped !== true) throw new MoneyValidationError("ACCOUNTING_SYNC_IN_PROGRESS", "Accounting reconciliation cannot release a live sync owner");
 		if (input.outcome.status === "absent") {
@@ -1771,23 +1827,7 @@ async function reconcileFrozenInvoiceAccountingSync(input) {
 		}
 		const externalId = requiredText(input.outcome.externalId, "Accounting external ID");
 		if (!(input.outcome.syncedAt instanceof Date) || Number.isNaN(input.outcome.syncedAt.valueOf())) throw new MoneyValidationError("INVALID_MONEY_INPUT", "Accounting reconciliation requires a valid sync timestamp");
-		const syncedAt = input.outcome.syncedAt.toISOString();
-		invoice.externalId = externalId;
-		invoice.externalProvider = identity.provider;
-		invoice.syncedAt = input.outcome.syncedAt;
-		invoice.accountingSyncStateJson = JSON.stringify({
-			...state,
-			status: "synced",
-			externalId,
-			syncedAt
-		});
-		await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
-		return {
-			status: "synced",
-			externalId,
-			syncedAt: input.outcome.syncedAt,
-			moneySnapshotId: identity.moneySnapshotId
-		};
+		return saveSyncedInvoice(invoice, state, externalId, input.outcome.syncedAt);
 	});
 }
 function readFrozenAccountingSyncState(invoice) {
@@ -1803,6 +1843,7 @@ function readFrozenAccountingSyncState(invoice) {
 		requestId: state.identity.requestId,
 		attemptId: state.attemptId,
 		startedAt: state.startedAt,
+		...state.pilotProjection ? { pilotProjection: state.pilotProjection } : {},
 		request: {
 			requestId: state.identity.requestId,
 			realmId: state.identity.realmId,
@@ -1812,6 +1853,130 @@ function readFrozenAccountingSyncState(invoice) {
 		}
 	};
 }
+function frozenIdentity(snapshot, request) {
+	return {
+		provider: "quickbooks",
+		documentKind: snapshot.document.kind,
+		realmId: request.realmId,
+		environment: request.environment,
+		invoiceId: snapshot.document.id,
+		moneySnapshotId: snapshot.moneySnapshotId,
+		requestId: request.requestId,
+		payloadHash: request.payloadHash,
+		creditedInvoiceExternalId: "creditedInvoiceExternalId" in request ? request.creditedInvoiceExternalId : void 0
+	};
+}
+function checkPilotAcceptance(invoice, state, acceptance) {
+	if (acceptance && acceptance.moneySnapshotId !== invoice.moneySnapshotId) pilotDisagreement("QuickBooks pilot acceptance does not match the frozen invoice");
+	if (state && (state.pilot?.obligationId !== acceptance?.obligationId || state.pilot?.quoteVersionId !== acceptance?.quoteVersionId || state.pilot?.moneySnapshotId !== acceptance?.moneySnapshotId)) pilotDisagreement("QuickBooks pilot acceptance differs from the existing reservation");
+}
+async function assertUnusedPilotExternalId(db, invoice, identity, externalId) {
+	const matches = await (await InvoiceCollection.create({ db })).list({ where: {
+		externalId,
+		tenantId: invoice.tenantId
+	} });
+	for (const other of matches) {
+		if (other.id === invoice.id) continue;
+		const binding = parseSyncState(other.accountingSyncStateJson);
+		if (!binding || binding.identity.realmId === identity.realmId && binding.identity.environment === identity.environment) pilotDisagreement("QuickBooks invoice is already bound to another local invoice");
+	}
+}
+function assertPilotInvoice(invoice) {
+	if (invoice.kind !== "invoice" || invoice.totalAmount <= 0 || !invoice.customerExternalId || invoice.ordinaryAccountingStateJson || invoice.retentionAccountingStateJson) unsupported("QuickBooks pilot requires an ordinary positive invoice and a mapped customer");
+}
+function checkPilotEvidence(evidence, scope, externalId, invoice) {
+	if (!evidence || evidence.tenantId !== scope.tenantId || evidence.realmId !== scope.realmId || evidence.environment !== scope.environment || evidence.externalId !== externalId || !invoice.customerExternalId || evidence.customerExternalId !== invoice.customerExternalId || evidence.currency !== invoice.currency || evidence.subtotalMinor !== invoice.subtotal || evidence.discountMinor !== invoice.discountTotal || evidence.taxMinor !== invoice.taxAmount || evidence.totalMinor !== invoice.totalAmount || evidence.dueDate !== (invoice.dueDate?.toISOString().slice(0, 10) ?? null)) pilotDisagreement("QuickBooks invoice identity or frozen money differs");
+	return projectQuickBooksPilotEvidence(evidence);
+}
+async function runQuickBooksPilot(input) {
+	assertPrincipalTenant(input.tenantId);
+	const { acceptance, fixture, mapping } = input;
+	if (![
+		"issue",
+		"poll",
+		"link",
+		"recover"
+	].includes(input.action)) unsupported("Unsupported QuickBooks pilot action");
+	if (fixture?.mode !== "fixture" || fixture.scope?.environment !== "sandbox" || mapping.environment !== "sandbox" || fixture.scope.tenantId !== input.tenantId || fixture.scope.realmId !== mapping.realmId) unsupported("QuickBooks pilot requires an explicitly scoped sandbox fixture");
+	requiredText(mapping.realmId, "QuickBooks realm");
+	requiredText(acceptance.quoteVersionId, "Accepted quote version");
+	requiredText(acceptance.moneySnapshotId, "Accepted money snapshot");
+	const obligationId = requiredText(acceptance.obligationId, "Accepted obligation");
+	if (input.invoiceId !== await quickBooksPilotInvoiceId(input.tenantId, obligationId)) pilotDisagreement("QuickBooks pilot requires the canonical obligation invoice");
+	const scope = { ...fixture.scope };
+	if (input.action === "issue") {
+		let projection;
+		await syncFrozenInvoice({
+			...input,
+			provider: {
+				type: "quickbooks",
+				invoices: { push: (invoice) => fixture.pushInvoice(invoice) }
+			}
+		}, {
+			acceptance,
+			async verify(invoice, result) {
+				if (result.action !== "created") pilotDisagreement("QuickBooks pilot did not return a new invoice");
+				const id = requiredText(result.externalId, "QuickBooks invoice ID");
+				projection = checkPilotEvidence(await fixture.readInvoice(id), scope, id, invoice);
+				return projection;
+			}
+		});
+		if (projection) return projection;
+	}
+	return withDocumentMoneyTransaction(input.db, async (tx) => {
+		await lockTenantMoneyRuntime(tx, input.tenantId);
+		const { invoice } = await lockAndReloadInvoice(tx, input.invoiceId, input.tenantId);
+		const state = parseSyncState(invoice.accountingSyncStateJson);
+		checkPilotAcceptance(invoice, state, acceptance);
+		assertPilotInvoice(invoice);
+		const snapshot = await loadSnapshot(tx, input.tenantId, invoice);
+		const sdkInput = toSdkInput({
+			...snapshot,
+			document: {
+				...snapshot.document,
+				externalId: void 0
+			}
+		}, mapping);
+		const { request } = prepareRequest(snapshot, mapping, sdkInput);
+		const identity = frozenIdentity(snapshot, request);
+		if (state && !sameIdentity(state.identity, identity)) pilotDisagreement("QuickBooks pilot binding or frozen request changed");
+		if (state?.status === "synced") {
+			const id = requiredText(state.externalId ?? "", "QuickBooks invoice ID");
+			if (invoice.externalId !== id || invoice.externalProvider !== "quickbooks") pilotDisagreement("QuickBooks pilot provider binding changed");
+			if (input.action === "link" && input.externalId !== id) pilotDisagreement("QuickBooks invoice already has a different binding");
+			const projection2 = checkPilotEvidence(await fixture.readInvoice(id), scope, id, invoice);
+			invoice.accountingSyncStateJson = JSON.stringify({
+				...state,
+				pilotProjection: projection2
+			});
+			await invoice.saveDerived(DOCUMENT_MONEY_WRITE);
+			return projection2;
+		}
+		let externalId;
+		let evidence;
+		if (input.action === "link" && (!state || state.status === "rejected") && !invoice.externalId) {
+			externalId = requiredText(input.externalId, "QuickBooks invoice ID");
+			evidence = await fixture.readInvoice(externalId);
+		} else if (input.action === "recover" && (state?.status === "unknown" || state?.status === "in_flight" && input.confirmInterruptedOwnerStopped === true)) {
+			const match = await fixture.findInvoiceForRequest?.(request);
+			if (!match || match.requestId !== identity.requestId || match.payloadHash !== identity.payloadHash) pilotDisagreement("QuickBooks create remains unresolved without verified request identity");
+			evidence = match.invoice;
+			externalId = requiredText(evidence.externalId, "QuickBooks invoice ID");
+		} else pilotDisagreement("QuickBooks pilot has no verified invoice binding for this action");
+		const projection = checkPilotEvidence(evidence, scope, externalId, invoice);
+		await assertUnusedPilotExternalId(tx, invoice, identity, externalId);
+		await saveSyncedInvoice(invoice, {
+			version: 1,
+			status: "synced",
+			identity,
+			attemptId: state?.attemptId ?? randomUUID(),
+			startedAt: state?.startedAt ?? projection.observedAt,
+			pilot: acceptance,
+			pilotProjection: projection
+		}, externalId, new Date(projection.observedAt));
+		return projection;
+	});
+}
 //#endregion
 //#region src/svelte/invoices/calculations.ts
 function numberDecimal(value, precision) {
@@ -2889,6 +3054,6 @@ async function reconcileRetainedCreditAccounting(input) {
 	}));
 }
 //#endregion
-export { PaymentAllocationCollection_exports as A, invoice_accounting_sync_exports as C, syncFrozenInvoiceToAccounting as D, reconcileFrozenInvoiceAccountingSync as E, Payment as F, hasConnectedPaymentAuthority as I, withConnectedPaymentAuthority as L, 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 };
+export { quickBooksPilotInvoiceId as A, invoice_accounting_sync_exports as C, runQuickBooksPilot as D, reconcileFrozenInvoiceAccountingSync as E, PaymentCollection as F, PaymentCollection_exports as I, Payment as L, PaymentAllocationCollection_exports as M, PaymentAllocation as N, syncFrozenInvoiceToAccounting as O, historicalCreditRefundCommittedTotal as P, hasConnectedPaymentAuthority as R, 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, PaymentAllocationCollection as j, toFrozenInvoiceAccountingInput 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, withConnectedPaymentAuthority as z };
 
-//# sourceMappingURL=retention-accounting-BAKsmbwJ.js.map
+//# sourceMappingURL=retention-accounting-CASwH8OH.js.map