@fire-spark/core 0.4.1 → 0.6.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { DIGITAL_COLLECT_AT, PARTIAL_APPROVAL_ERROR, activeIntent, amountTolerance, createAttemptReference, createPaymentError, currentIntent, defaultReversalFor, discountRedeems, groupPaymentRedeems, isDeliveryFee, isPaymentError, isPaymentRedeem, isRealPaymentMethod, isRealPaymentMethod as isRealPaymentMethod$1, isTenderSettled, isTipFee, liveTenders, memoryPaymentStorage, missingDeviceFields, money, moneyNumber, moneyZero, orderPaymentRedeems, orderPaymentRedeems as orderPaymentRedeems$1, paymentRedeemsCoverTotal, resolvePaymentPolicy, resolveProviderEnvironment, scopedPaymentStorage, taxBreakdown, toChargeAmount, withTerminalLock } from "@fire-spark/payments";
+import { DIGITAL_COLLECT_AT, PARTIAL_APPROVAL_ERROR, REDEMPTION_METHOD, activeIntent, createAttemptReference, createPaymentError, currentIntent, defaultReversalFor, groupRedeems, hasRedeemPayment, isDeliveryFee, isPaymentError, isRealPaymentMethod, isRealPaymentMethod as isRealPaymentMethod$1, isTenderSettled, isTipFee, liveTenders, memoryPaymentStorage, missingDeviceFields, money, moneyMin, moneyNumber, moneyZero, orderRedeems, orderRedeems as orderRedeems$1, redeemsCoverTotal, resolvePaymentPolicy, resolveProviderEnvironment, scopedPaymentStorage, taxBreakdown, toChargeAmount, withTerminalLock } from "@fire-spark/payments";
 import advancedFormat from "dayjs/plugin/advancedFormat.js";
 import isBetween from "dayjs/plugin/isBetween.js";
 import isSameOrAfter from "dayjs/plugin/isSameOrAfter.js";
@@ -3089,6 +3089,23 @@ const genOrderId = (storeId) => {
 	return genId().literal("ord").separator().literal(storeId, "nostore").separator().hash().build();
 };
 //#endregion
+//#region src/order/OrderPaymentRequiredError.ts
+/**
+* `placeOrder` has no real tender (no `payment`, no `setTenders`, no
+* `intent_id`) and the redeems do not cover the total. Same code as the
+* API's 422, so callers map both the same way.
+*/
+var OrderPaymentRequiredError = class extends Error {
+	code = "PAYMENT_REQUIRED";
+	constructor() {
+		super("Place needs a payment method: the redeems do not cover the total");
+		this.name = "OrderPaymentRequiredError";
+	}
+};
+const isOrderPaymentRequiredError = (error) => {
+	return error instanceof OrderPaymentRequiredError;
+};
+//#endregion
 //#region src/order/retry.ts
 const defaultSleep$1 = (ms) => {
 	return new Promise((resolve) => {
@@ -3118,17 +3135,31 @@ var OrderSyncPendingError = class extends Error {
 		this.name = "OrderSyncPendingError";
 	}
 };
+/**
+* The server rejected an order write (POST/PATCH) and the draft was rolled
+* back to the last synced order. Keeps the API `status`, `code` and
+* `details`, so code checks on `StorefrontHttpError` still match.
+*/
+var OrderSyncRejectedError = class extends StorefrontHttpError {
+	constructor(error) {
+		const { message, status, code, details } = error;
+		super(message, status, code, details);
+		this.name = "OrderSyncRejectedError";
+	}
+};
 const createFlushController = (runtime) => {
 	let timer = null;
 	let inFlight = false;
 	let dirtyDuringFlight = false;
 	let current = null;
 	let pending = false;
+	let rejected = null;
 	const cancel = () => {
 		if (timer) clearTimeout(timer);
 		timer = null;
 		dirtyDuringFlight = false;
 		pending = false;
+		rejected = null;
 	};
 	const patchBody = (order) => {
 		const b1 = {
@@ -3211,11 +3242,20 @@ const createFlushController = (runtime) => {
 			await flushNow();
 		}
 	};
+	const throwRejected = () => {
+		if (!rejected) return;
+		const error = rejected;
+		rejected = null;
+		throw error;
+	};
 	const settle = async () => {
 		await drain();
-		if (!pending || runtime.isDeleted()) return;
+		if (runtime.isDeleted()) return;
+		throwRejected();
+		if (!pending) return;
 		await flushNow();
 		await drain();
+		throwRejected();
 		if (pending) throw new OrderSyncPendingError();
 	};
 	const resume = async () => {
@@ -3239,6 +3279,7 @@ const createFlushController = (runtime) => {
 				return services.orders.patch(...p1);
 			}, { sleep: runtime.sleep });
 			pending = false;
+			rejected = null;
 			runtime.setPersisted(true);
 			runtime.setSynced(updated);
 			const reusedOpen = !wasPersisted && updated.id !== payload.id;
@@ -3273,6 +3314,7 @@ const createFlushController = (runtime) => {
 				return;
 			}
 			pending = false;
+			rejected = new OrderSyncRejectedError(error);
 			runtime.setDraft(batchBase);
 			runtime.setSynced(batchBase);
 			runtime.setPersisted(wasPersisted);
@@ -3306,7 +3348,8 @@ const createFlushController = (runtime) => {
 		settle,
 		resume,
 		getInFlight: () => inFlight,
-		getPending: () => pending
+		getPending: () => pending,
+		getRejected: () => rejected
 	};
 };
 //#endregion
@@ -3454,6 +3497,13 @@ const emptyLines = () => {
 //#region src/order/tenders.ts
 /** Catalog provider of `REDEMPTION` payments (§3.3). */
 const DEFAULT_REDEMPTION_PROVIDER = "firespark";
+const isFixedFee = (line) => isTipFee(line) || isDeliveryFee(line);
+const positive = (value) => value.gt(0) ? value : moneyZero();
+/** What a redeem may cover on a root line: pre-tax value or with taxes. */
+const coverableOf = (line, beforeTaxes) => {
+	const total = money(line.group_total);
+	return positive(beforeTaxes ? total.minus(line.group_tax_total) : total);
+};
 /**
 * Digital tender the SDK charges (`DEVICE`, §7.3). `KIOSK`, `COUNTER`,
 * `DOOR` and `OTHER` are in person: the POS, an operator or the courier
@@ -3462,42 +3512,53 @@ const DEFAULT_REDEMPTION_PROVIDER = "firespark";
 const isDeviceCharged = (tender) => {
 	return DIGITAL_COLLECT_AT.includes(tender.collect_at);
 };
-/** Most a REDEMPTION can cover: order total − tip − delivery (D18). */
-const redemptionCap = (order) => {
-	const primaryOnly = order.lines.filter((line) => line.parent_uid == null).reduce((sum, line) => {
-		if (!(isTipFee(line) || isDeliveryFee(line))) return sum;
-		return sum.plus(line.group_total);
-	}, moneyZero());
-	const cap = money(order.totals.total).minus(primaryOnly);
-	if (cap.lt(0)) return 0;
-	return moneyNumber(cap);
-};
 /**
-* Room left for order-level payment redeems: the D18 cap minus what the
-* payment redeems kept on lines already cover.
+* Most the redeems can cover (D18): order total − tip − delivery. With
+* `beforeTaxes`, the taxes of the other roots are excluded too, so they
+* stay for the customer's method.
 */
-const orderRedeemCap = (order) => {
-	const used = orderPaymentRedeems({ lines: order.lines }).reduce((sum, item) => {
-		return sum.plus(item.amount ?? 0);
+const redemptionCap = (order, beforeTaxes = false) => {
+	const excluded = order.lines.filter((line) => line.parent_uid == null).reduce((sum, line) => {
+		if (isFixedFee(line)) return sum.plus(line.group_total);
+		if (!beforeTaxes) return sum;
+		return sum.plus(line.group_tax_total);
 	}, moneyZero());
-	const left = money(redemptionCap(order)).minus(used);
-	if (left.lt(0)) return 0;
-	return moneyNumber(left);
+	return moneyNumber(positive(money(order.totals.total).minus(excluded)));
+};
+const fitRedeems = (order) => {
+	const gross = money(redemptionCap(order));
+	const net = money(redemptionCap(order, true));
+	let used = moneyZero();
+	const fit = (item, line, lineUsed) => {
+		if (!hasRedeemPayment(item) || !(item.amount > 0)) return moneyZero();
+		const beforeTaxes = item.before_taxes ?? true;
+		let room = (beforeTaxes ? net : gross).minus(used);
+		if (line) {
+			const left = coverableOf(line, beforeTaxes).minus(lineUsed);
+			room = moneyMin(room, left);
+		}
+		const fits = moneyMin(money(item.amount), positive(room));
+		used = used.plus(fits);
+		return fits;
+	};
+	return {
+		lines: order.lines.map((line) => {
+			if (line.parent_uid != null) return (line.redeem ?? []).map(moneyZero);
+			let lineUsed = moneyZero();
+			return (line.redeem ?? []).map((item) => {
+				const fits = fit(item, line, lineUsed);
+				lineUsed = lineUsed.plus(fits);
+				return fits;
+			});
+		}),
+		redeem: (order.redeem ?? []).map((item) => fit(item))
+	};
 };
-/**
-* Trims payment redeems in application order so their sum fits the cap.
-* Discount redeems are left untouched. The last trimmed amount is whatever
-* room remains, so the kept amounts sum to at most `cap`.
-*/
-const clampPaymentRedeems = (redeem, cap, _currency) => {
-	let left = money(cap);
-	return redeem.flatMap((item) => {
-		if (!isPaymentRedeem(item)) return [item];
-		const amount = money(item.amount ?? 0);
-		const fits = amount.lt(left) ? amount : left;
-		left = left.minus(fits);
+const keepFitted = (items, fitted) => {
+	return items.flatMap((item, index) => {
+		const fits = fitted[index] ?? moneyZero();
 		if (fits.lte(0)) return [];
-		if (fits.eq(amount)) return [item];
+		if (fits.eq(item.amount)) return [item];
 		return [{
 			...item,
 			amount: moneyNumber(fits)
@@ -3505,11 +3566,37 @@ const clampPaymentRedeems = (redeem, cap, _currency) => {
 	});
 };
 /**
-* One REDEMPTION tender per `payment_id` of the payment redeems (D15,
-* D19); its `details.rewards[]` lists every grouped redeem.
+* Trims every redeem to what `fitRedeems` lets it cover; redeems with no
+* room left are dropped. Line and order money is never changed: the
+* REDEMPTION tender pays the kept `amount`.
+*/
+const capRedeems = (order) => {
+	const fitted = fitRedeems(order);
+	const lines = order.lines.map((line, index) => {
+		if (!line.redeem?.length) return line;
+		const redeem = keepFitted(line.redeem, fitted.lines[index] ?? []);
+		return {
+			...line,
+			redeem
+		};
+	});
+	const redeem = keepFitted(order.redeem ?? [], fitted.redeem);
+	return {
+		...order,
+		lines,
+		redeem
+	};
+};
+/** Every redeem of the order after `capRedeems`, ready for tenders. */
+const cappedRedeems = (order) => {
+	return orderRedeems(capRedeems(order));
+};
+/**
+* One REDEMPTION tender per `payment_id` (D15, D19); its
+* `details.rewards[]` lists every grouped redeem.
 */
 const redemptionTenderInputs = (redeem, providers = /* @__PURE__ */ new Map()) => {
-	return groupPaymentRedeems(redeem).map(({ payment_id, details }) => {
+	return groupRedeems(redeem).map(({ payment_id, details }) => {
 		const fallback = DEFAULT_REDEMPTION_PROVIDER;
 		const t1 = {
 			method: "REDEMPTION",
@@ -3915,8 +4002,7 @@ const partialOf = (result) => {
 const isPartialApproval = (result, tender, ctx) => {
 	if (result.status !== "PAID") return false;
 	if (ctx.amount.currency !== tender.amount.currency) return false;
-	const tolerance = amountTolerance(tender.amount.currency);
-	return result.amount + tolerance < tender.amount.total;
+	return money(result.amount).lt(tender.amount.total);
 };
 const toFailure = (error) => {
 	const message = error instanceof Error ? error.message : "Terminal failed";
@@ -4660,109 +4746,38 @@ const collectRecommendations = (config) => {
 	return products;
 };
 //#endregion
-//#region src/order/totals.ts
-/** Sum root line group totals into order totals (Big.js). */
-const recomputeTotals = (lines, currency = "USD") => {
-	let subtotal = new Big(0);
-	let discountTotal = new Big(0);
-	let taxTotal = new Big(0);
-	let total = new Big(0);
-	for (const line of lines) {
-		if (line.parent_uid != null) continue;
-		subtotal = subtotal.plus(line.group_subtotal);
-		discountTotal = discountTotal.plus(line.group_discount);
-		taxTotal = taxTotal.plus(line.group_tax_total);
-		total = total.plus(line.group_total);
-	}
-	let taxRate = 0;
-	let discountRate = 0;
-	if (subtotal.gt(0)) {
-		taxRate = taxTotal.div(subtotal).toNumber();
-		discountRate = discountTotal.div(subtotal).toNumber();
-	}
-	const discount_total = discountTotal.toNumber();
-	const tax_total = taxTotal.toNumber();
-	const b1 = {
-		currency,
-		subtotal: subtotal.toNumber()
-	};
-	const b2 = {
-		discount_rate: discountRate,
-		discount_total
-	};
-	const b3 = {
-		tax_rate: taxRate,
-		tax_total,
-		total: total.toNumber()
-	};
-	return {
-		...b1,
-		...b2,
-		...b3
-	};
-};
-const emptyTotals = (currency = "USD") => {
-	const b1 = {
-		currency,
-		subtotal: 0,
-		discount_rate: 0,
-		discount_total: 0
-	};
-	const b2 = {
-		tax_rate: 0,
-		tax_total: 0,
-		total: 0
-	};
-	return {
-		...b1,
-		...b2
-	};
-};
-//#endregion
 //#region src/order/redemptions.ts
-const ORDER_KEY = "ORDER";
-const buildPaymentRedeem = (input) => {
-	const { reward_id, quantity, payment_id, amount } = input;
-	if (amount === void 0 || !(amount > 0)) throw new Error("Redeem with payment_id requires amount > 0");
-	const redeem = {
-		reward_id,
-		quantity,
-		payment_id,
-		amount
-	};
-	if (input.expires_at !== void 0) redeem.expires_at = input.expires_at;
-	return redeem;
-};
 /** Same rules as `vOrders.redeem()`; throws on invalid input. */
 const buildRedeem = (input) => {
-	const { reward_id, quantity, discount_rate, discount_amount } = input;
+	const { reward_id, quantity, payment_id, amount } = input;
 	const { before_taxes, expires_at } = input;
-	if (!reward_id.trim()) throw new Error("Redeem requires reward_id");
+	if (typeof reward_id !== "string" || !reward_id.trim()) throw new Error("Redeem requires reward_id");
 	if (!Number.isInteger(quantity) || quantity < 1) throw new Error("Redeem quantity must be an integer ≥ 1");
+	if (typeof payment_id !== "string" || !payment_id.trim()) throw new Error("Redeem requires payment_id");
+	if (typeof amount !== "number" || !(amount > 0)) throw new Error("Redeem requires amount > 0");
 	if (expires_at !== void 0 && Number.isNaN(Date.parse(expires_at))) throw new Error("Redeem expires_at must be an ISO datetime");
-	if (input.payment_id) return buildPaymentRedeem(input);
-	if (discount_rate === void 0 && discount_amount === void 0) throw new Error("Redeem requires discount_rate or discount_amount");
-	const rate = discount_rate ?? 0;
-	if (!(rate >= 0 && rate <= 1)) throw new Error("Redeem discount_rate must be between 0 and 1");
-	if (discount_amount !== void 0 && !(discount_amount > 0)) throw new Error("Redeem discount_amount must be > 0");
 	const redeem = {
 		reward_id,
-		quantity
+		quantity,
+		payment_id,
+		amount
 	};
-	if (discount_rate !== void 0) redeem.discount_rate = discount_rate;
-	if (discount_amount !== void 0) redeem.discount_amount = discount_amount;
 	if (before_taxes !== void 0) redeem.before_taxes = before_taxes;
 	if (expires_at !== void 0) redeem.expires_at = expires_at;
 	return redeem;
 };
-/** Payment redeems hold totals, so the kept units keep their share. */
+/**
+* `amount` covers every unit, so the kept units keep what the removed ones
+* did not take: `amount − amount × taken / quantity`, never rounded.
+*/
 const keepUnits = (item, rest) => {
-	if (!isPaymentRedeem(item) || rest === item.quantity) return {
+	if (rest === item.quantity) return {
 		...item,
 		quantity: rest
 	};
-	const ratio = new Big(rest).div(item.quantity);
-	const amount = new Big(item.amount ?? 0).times(ratio).round(6).toNumber();
+	const taken = item.quantity - rest;
+	const share = new Big(item.amount).times(taken).div(item.quantity);
+	const amount = new Big(item.amount).minus(share).toNumber();
 	return {
 		...item,
 		quantity: rest,
@@ -4770,8 +4785,8 @@ const keepUnits = (item, rest) => {
 	};
 };
 /**
-* Takes `quantity` units of `reward_id` off the latest entries first, so the
-* earlier redeems keep their step position. Entries that reach 0 are removed.
+* Takes `quantity` units of `reward_id` off the latest entries first.
+* Entries that reach 0 are removed.
 */
 const subtractRedeem = (items, reward_id, quantity) => {
 	if (!Number.isInteger(quantity) || quantity < 1) throw new Error("Redeem quantity must be an integer ≥ 1");
@@ -4790,143 +4805,43 @@ const subtractRedeem = (items, reward_id, quantity) => {
 	}
 	return kept;
 };
-const redemptionTargetKey = (target) => {
-	if (target.target === "ORDER") return ORDER_KEY;
-	return `LINE:${target.target_id ?? ""}`;
-};
 /**
-* Only root lines own redeems; child-line redeems are never applied.
-* Payment redeems are skipped on lines and on the order alike.
+* Money the redeems cover (Σ `amount`): the discount the customer sees.
+* It is paid by REDEMPTION tenders, so it is never subtracted from line
+* or order totals.
 */
-const redeemPools = (lines, redeem) => {
-	const pools = /* @__PURE__ */ new Map();
-	for (const line of lines) {
-		const items = discountRedeems(line.redeem ?? []);
-		if (line.parent_uid != null || items.length === 0) continue;
-		const target = {
-			target: "LINE",
-			target_id: line.uid
-		};
-		const pool = items.map((item) => ({
-			...target,
-			redeem: item
-		}));
-		pools.set(redemptionTargetKey(target), pool);
-	}
-	const order = { target: "ORDER" };
-	const pool = discountRedeems(redeem).map((item) => ({
-		...order,
-		redeem: item
-	}));
-	pools.set(ORDER_KEY, pool);
-	return pools;
+const redeemedTotal = (redeem = []) => {
+	return (redeem ?? []).reduce((sum, item) => {
+		if (!hasRedeemPayment(item)) return sum;
+		return sum.plus(item.amount ?? 0);
+	}, new Big(0)).toNumber();
+};
+/** Redeemed money of every redeem of the order (order + root lines). */
+const orderRedeemedTotal = (order) => {
+	return redeemedTotal(orderRedeems$1(order));
 };
 /**
-* Pairs the k-th step of a target with the k-th redeem of that target, in
-* step order. Steps without a matching redeem are dropped; redeems without a
-* step are appended (lines first, then order).
+* What the customer pays with another method:
+* `totals.total − Σ redeem amounts` (order + root lines), never below 0.
 */
-const sequenceRedeems = (lines, redeem, steps) => {
-	const pools = redeemPools(lines, redeem);
-	const cursors = /* @__PURE__ */ new Map();
-	const sequence = [];
-	for (const step of steps) {
-		const key = redemptionTargetKey(step);
-		const at = cursors.get(key) ?? 0;
-		const next = pools.get(key)?.[at];
-		if (!next || next.redeem.reward_id !== step.reward_id) continue;
-		cursors.set(key, at + 1);
-		sequence.push(next);
-	}
-	for (const [key, pool] of pools) sequence.push(...pool.slice(cursors.get(key) ?? 0));
-	return sequence;
-};
-const minBig = (a, b) => {
-	return a.lt(b) ? a : b;
-};
-const rateOf = (discount, base) => {
-	if (base.lte(0)) return 0;
-	return minBig(discount.div(base), new Big(1)).toNumber();
-};
-const snapshot = (roots, quantity) => {
-	let subtotal = new Big(0);
-	let total = new Big(0);
-	let discount = new Big(0);
-	for (const root of roots) {
-		subtotal = subtotal.plus(root.subtotal);
-		total = total.plus(root.total);
-		discount = discount.plus(root.discount);
-	}
-	const b1 = {
-		value: total.toNumber(),
-		quantity
-	};
-	const b2 = { discount_amount: discount.toNumber() };
-	const b3 = { discount_rate: rateOf(discount, subtotal) };
-	return {
-		...b1,
-		...b2,
-		...b3
-	};
-};
-const netOf = (root) => {
-	const net = root.total.minus(root.tax);
-	return net.gt(0) ? net : new Big(0);
-};
-/** What a redeem can still discount on a root: pre-tax or with taxes. */
-const baseOf = (root, beforeTaxes) => {
-	return beforeTaxes ? netOf(root) : root.total;
-};
-/** Before taxes, taxes shrink with the pre-tax value they were charged on. */
-const discountRoot = (root, amount, beforeTaxes) => {
-	if (amount.lte(0)) return;
-	root.discount = root.discount.plus(amount);
-	if (!beforeTaxes) {
-		root.total = root.total.minus(amount);
-		return;
-	}
-	const net = netOf(root);
-	const nextNet = net.minus(amount);
-	root.tax = root.tax.times(nextNet).div(net);
-	root.total = nextNet.plus(root.tax);
-};
-/** Splits an order discount across roots by what each can still discount. */
-const discountOrder = (roots, amount, beforeTaxes) => {
-	const bases = roots.map((root) => baseOf(root, beforeTaxes));
-	const sum = bases.reduce((acc, base) => acc.plus(base), new Big(0));
-	if (sum.lte(0) || amount.lte(0)) return;
-	let last = -1;
-	bases.forEach((base, index) => {
-		if (base.gt(0)) last = index;
-	});
-	let rest = amount;
-	roots.forEach((root, index) => {
-		const base = bases[index];
-		if (base.lte(0)) return;
-		const share = amount.times(base).div(sum);
-		const part = minBig(index === last ? rest : share, base);
-		rest = rest.minus(part);
-		discountRoot(root, part, beforeTaxes);
-	});
+const orderPayableTotal = (order) => {
+	const rest = new Big(order.totals.total).minus(orderRedeemedTotal(order));
+	return rest.gt(0) ? rest.toNumber() : 0;
 };
 /**
-* Rate compounds once per reward unit over the remaining value; amount is
-* per unit. With both, the rate discount is capped at `amount × quantity`.
+* What the customer pays for a root line with another method:
+* `group_total − Σ line.redeem[].amount`, never below 0.
 */
-const redeemDiscount = (redeem, remaining) => {
-	const { quantity, discount_rate, discount_amount } = redeem;
-	let cap = null;
-	if (discount_amount !== void 0) cap = new Big(discount_amount).times(quantity);
-	if (discount_rate === void 0) return cap ?? new Big(0);
-	const kept = new Big(1).minus(discount_rate).pow(quantity);
-	const byRate = remaining.times(new Big(1).minus(kept));
-	return cap ? minBig(byRate, cap) : byRate;
+const linePayableTotal = (line) => {
+	const rest = new Big(line.group_total).minus(redeemedTotal(line.redeem));
+	return rest.gt(0) ? rest.toNumber() : 0;
 };
 /**
-* Root group money rebuilt from the line itself plus its children, i.e. the
-* menu price before any redemption. Child lines are never discounted.
+* Root group money rebuilt from the line itself plus its children. Legacy
+* orders carried their redeems in the root's group money; rebuilding drops
+* it so line money stays full.
 */
-const stripRedemptionLines = (lines) => {
+const rebuildRootGroups = (lines) => {
 	const children = /* @__PURE__ */ new Map();
 	for (const line of lines) {
 		if (line.parent_uid == null) continue;
@@ -4975,111 +4890,162 @@ const stripRedemptionLines = (lines) => {
 		};
 	});
 };
-const withRootMoney = (line, money) => {
-	const qty = new Big(line.quantity);
-	const discount = new Big(line.group_discount).plus(money.discount);
-	const u1 = { unit_group_discount: discount.div(qty).toNumber() };
-	const u2 = { unit_group_tax_total: money.tax.div(qty).toNumber() };
-	const u3 = { unit_group_total: money.total.div(qty).toNumber() };
-	const g1 = { group_discount: discount.toNumber() };
-	const g2 = { group_tax_total: money.tax.toNumber() };
-	const g3 = { group_total: money.total.toNumber() };
+const stateOf = (target) => {
+	const rest = target.total.minus(target.covered);
+	const left = rest.gt(0) ? rest : moneyZero();
+	let rate = moneyZero();
+	if (target.total.gt(0)) rate = moneyMin(target.covered.div(target.total), money(1));
+	const s1 = {
+		value: moneyNumber(left),
+		quantity: target.quantity
+	};
+	const s2 = { discount_amount: moneyNumber(target.covered) };
 	return {
-		...line,
-		...u1,
-		...u2,
-		...u3,
-		...g1,
-		...g2,
-		...g3
+		...s1,
+		...s2,
+		discount_rate: rate.toNumber()
 	};
 };
 /**
-* Replays every redeem in persisted step order over the root lines' group
-* money. Line redeems discount their root; order redeems are prorated over
-* every root. A discount never exceeds what is left on its target.
+* One step per redeem with a `payment_id`, in the order `fitRedeems`
+* applies them: root-line redeems in line order, then order redeems.
+* `discount_amount` is the capped `amount`, so the steps of a `payment_id`
+* add up to its REDEMPTION tender and the line steps to the discount shown
+* on the line. Lines, taxes and totals keep their full value; `value` is
+* what the customer's method still pays.
 */
-const replayRedemptions = (lines, redeem, steps) => {
-	const base = stripRedemptionLines(lines);
-	const sequence = sequenceRedeems(base, redeem, steps);
-	const moneyByUid = /* @__PURE__ */ new Map();
-	for (const line of base) {
-		if (line.parent_uid != null) continue;
-		const b1 = { quantity: line.quantity };
-		const b2 = { subtotal: new Big(line.group_subtotal) };
-		const b3 = { tax: new Big(line.group_tax_total) };
-		const b4 = {
-			total: new Big(line.group_total),
-			discount: new Big(0)
-		};
-		moneyByUid.set(line.uid, {
-			...b1,
-			...b2,
-			...b3,
-			...b4
-		});
-	}
-	const roots = [...moneyByUid.values()];
-	const redemption_steps = sequence.map((item) => {
-		const id = item.target_id;
-		const root = id ? moneyByUid.get(id) : void 0;
-		const beforeTaxes = item.redeem.before_taxes ?? true;
-		const before = snapshot(roots, 1);
-		const targetBefore = root ? snapshot([root], root.quantity) : void 0;
-		let left = new Big(0);
-		if (root) left = baseOf(root, beforeTaxes);
-		else for (const r of roots) left = left.plus(baseOf(r, beforeTaxes));
-		const raw = redeemDiscount(item.redeem, left);
-		const discount = minBig(raw, left);
-		if (root) discountRoot(root, discount, beforeTaxes);
-		else discountOrder(roots, discount, beforeTaxes);
-		const action = discount.gt(0) ? "UPDATE" : "READ";
-		const { reward_id, quantity } = item.redeem;
-		const b1 = {
-			reward_id,
-			reward_quantity: quantity,
-			target: item.target
+const redemptionSteps = (order) => {
+	const fitted = fitRedeems(order);
+	const whole = {
+		total: money(order.totals.total),
+		quantity: 1,
+		covered: moneyZero()
+	};
+	const steps = [];
+	const apply = (item, fits, line) => {
+		const before = stateOf(whole);
+		const targetBefore = line ? stateOf(line) : void 0;
+		whole.covered = whole.covered.plus(fits);
+		if (line) line.covered = line.covered.plus(fits);
+		const action = fits.gt(0) ? "UPDATE" : "READ";
+		const s1 = {
+			reward_id: item.reward_id,
+			reward_quantity: item.quantity
 		};
-		const b2 = id ? { target_id: id } : {};
-		const b3 = {
-			action,
-			discount_amount: discount.toNumber()
+		const s2 = { payment_id: item.payment_id };
+		const s3 = {
+			before_taxes: item.before_taxes ?? true,
+			action
 		};
-		const b4 = {
+		const s4 = { discount_amount: moneyNumber(fits) };
+		const s5 = {
 			before,
-			after: snapshot(roots, 1)
-		};
-		let b5 = {};
-		if (root) b5 = {
-			target_before: targetBefore,
-			target_after: snapshot([root], root.quantity)
+			after: stateOf(whole)
 		};
 		return {
-			...b1,
-			...b2,
-			...b3,
-			...b4,
-			...b5
+			...s1,
+			...s2,
+			...s3,
+			...s4,
+			...s5,
+			targetBefore
 		};
+	};
+	order.lines.forEach((line, index) => {
+		if (line.parent_uid != null) return;
+		const covered = moneyZero();
+		const target = {
+			total: money(line.group_total),
+			quantity: line.quantity,
+			covered
+		};
+		(line.redeem ?? []).forEach((item, at) => {
+			if (!hasRedeemPayment(item)) return;
+			const fits = fitted.lines[index]?.[at] ?? moneyZero();
+			const { targetBefore, ...step } = apply(item, fits, target);
+			const l1 = {
+				target: "LINE",
+				target_id: line.uid
+			};
+			const l2 = {
+				target_before: targetBefore,
+				target_after: stateOf(target)
+			};
+			steps.push({
+				...step,
+				...l1,
+				...l2
+			});
+		});
+	});
+	(order.redeem ?? []).forEach((item, at) => {
+		if (!hasRedeemPayment(item)) return;
+		const fits = fitted.redeem[at] ?? moneyZero();
+		const { targetBefore: _, ...step } = apply(item, fits);
+		steps.push({
+			...step,
+			target: "ORDER"
+		});
 	});
+	return steps;
+};
+//#endregion
+//#region src/order/totals.ts
+/** Sum root line group totals into order totals (Big.js). */
+const recomputeTotals = (lines, currency = "USD") => {
+	let subtotal = new Big(0);
+	let discountTotal = new Big(0);
+	let taxTotal = new Big(0);
+	let total = new Big(0);
+	for (const line of lines) {
+		if (line.parent_uid != null) continue;
+		subtotal = subtotal.plus(line.group_subtotal);
+		discountTotal = discountTotal.plus(line.group_discount);
+		taxTotal = taxTotal.plus(line.group_tax_total);
+		total = total.plus(line.group_total);
+	}
+	let taxRate = 0;
+	let discountRate = 0;
+	if (subtotal.gt(0)) {
+		taxRate = taxTotal.div(subtotal).toNumber();
+		discountRate = discountTotal.div(subtotal).toNumber();
+	}
+	const discount_total = discountTotal.toNumber();
+	const tax_total = taxTotal.toNumber();
+	const b1 = {
+		currency,
+		subtotal: subtotal.toNumber()
+	};
+	const b2 = {
+		discount_rate: discountRate,
+		discount_total
+	};
+	const b3 = {
+		tax_rate: taxRate,
+		tax_total,
+		total: total.toNumber()
+	};
 	return {
-		lines: base.map((line) => {
-			const money = moneyByUid.get(line.uid);
-			if (!money || money.discount.eq(0)) return line;
-			return withRootMoney(line, money);
-		}),
-		redemption_steps
+		...b1,
+		...b2,
+		...b3
 	};
 };
-/** Discounted lines, steps and totals, keeping step order. */
-const recomputeRedemptions = (input) => {
-	const { redeem, currency } = input;
-	const steps = input.redemption_steps;
-	const { lines, redemption_steps } = replayRedemptions(input.lines, redeem, steps);
+const emptyTotals = (currency = "USD") => {
+	const b1 = {
+		currency,
+		subtotal: 0,
+		discount_rate: 0,
+		discount_total: 0
+	};
+	const b2 = {
+		tax_rate: 0,
+		tax_total: 0,
+		total: 0
+	};
 	return {
-		lines,
-		redemption_steps,
-		totals: recomputeTotals(lines, currency)
+		...b1,
+		...b2
 	};
 };
 //#endregion
@@ -5087,9 +5053,9 @@ const recomputeRedemptions = (input) => {
 const cloneOrder = (order) => {
 	return structuredClone(order);
 };
-const redeemSignature$1 = (items) => {
+const redeemSignature = (items) => {
 	return items.map((item) => {
-		return `${`${item.reward_id}:${item.quantity}:${item.payment_id ?? ""}`}:${`${item.amount ?? ""}`}:${`${item.discount_rate ?? ""}:${item.discount_amount ?? ""}`}`;
+		return `${`${item.reward_id}:${item.quantity}:${item.payment_id ?? ""}`}:${`${item.amount}:${item.before_taxes ?? ""}`}`;
 	}).join("|");
 };
 const buildHttpOptions = (options) => {
@@ -5150,14 +5116,14 @@ const buildInsertFromSource = (options, source) => {
 	if (options.scope?.brand_id !== void 0) brand_id = optionalBrandId(options.scope.brand_id);
 	let customer = source.customer;
 	if (options.customer) customer = buildCustomerSnapshot(options.customer);
-	const sourceLines = structuredClone(source.lines);
 	const is_anonymous = options.isAnonymous ?? source.is_anonymous;
 	const redeem = structuredClone(source.redeem ?? []);
-	const { lines, redemption_steps, totals } = recomputeRedemptions({
-		lines: sourceLines,
-		redeem,
-		redemption_steps: source.redemption_steps ?? [],
-		currency: source.totals.currency
+	const lines = rebuildRootGroups(structuredClone(source.lines));
+	const totals = recomputeTotals(lines, source.totals.currency);
+	const redemption_steps = redemptionSteps({
+		lines,
+		totals,
+		redeem
 	});
 	const b1 = {
 		id: orderId,
@@ -5503,20 +5469,20 @@ var Order = class Order {
 		});
 	}
 	/**
-	* Appends a redeem to `line_uid` (root line) or to the order. Steps keep
-	* the order in which redeems were applied. With `payment_id` (voucher,
-	* balance…) it is not a discount: `amount` is the total of the whole
-	* entry (every unit, not per unit) and `quantity` is informational.
-	* Every redeem with the same `payment_id` is paid by one REDEMPTION
-	* tender whose `details.rewards[]` lists them; their summed amount is
-	* capped at total − tip − delivery (D15, D18, D19).
+	* Applies a redeem (points, voucher, free product…) to `line_uid` (root
+	* product line) or to the order. `payment_id` and `amount` are required:
+	* `amount` is what the redeem covers for the whole entry and is shown as
+	* the line / order discount, while line and order totals keep their full
+	* value. The REDEMPTION tender of `payment_id` pays `amount`; the
+	* customer's method pays the rest (the taxes when `before_taxes`, the
+	* default, keeps them out of the redeem). Redeems with the same
+	* `payment_id` share one tender (D15, D18, D19).
 	*/
 	applyRedeem(input) {
 		if (this.deleted) return;
 		const { line_uid, provider, ...rest } = input;
 		const redeem = buildRedeem(rest);
-		if (isPaymentRedeem(redeem) && line_uid !== void 0) throw new Error("Payment redeems apply to the whole order");
-		if (redeem.payment_id && provider) this.redemptionProviders.set(redeem.payment_id, provider);
+		if (provider) this.redemptionProviders.set(redeem.payment_id, provider);
 		if (line_uid === void 0) {
 			this.commitLines({ redeem: [...this.appliedRedeem(), redeem] });
 			return;
@@ -5535,8 +5501,8 @@ var Order = class Order {
 	/**
 	* Removes `quantity` units of `reward_id` from `line_uid` or the order,
 	* latest applied first. Removing more units than applied clears them all
-	* (and the REDEMPTION tender of a payment redeem). A payment redeem that
-	* keeps some units keeps the same share of its `amount`.
+	* (and their REDEMPTION tender). A redeem that keeps some units keeps
+	* their share of its `amount`.
 	*/
 	removeRedeem(input) {
 		if (this.deleted) return;
@@ -5692,10 +5658,10 @@ var Order = class Order {
 			lines: draft.lines,
 			redeem: draft.redeem ?? []
 		};
-		const steps = draft.redemption_steps ?? [];
+		const redemption_steps = redemptionSteps(draft);
 		const b5 = {
 			totals: draft.totals,
-			redemption_steps: steps
+			redemption_steps
 		};
 		const body = {
 			...b1,
@@ -5707,15 +5673,16 @@ var Order = class Order {
 		await services.orders.validate(body, this.http);
 	}
 	/**
-	* Tenders of the next intent: real ones plus one per payment redeem
-	* `payment_id`, on the order or on a line. When the payment redeems
-	* cover the total, only REDEMPTION tenders.
+	* Tenders of the next intent: one REDEMPTION per redeem `payment_id`
+	* (order and lines, capped) plus the customer's method for the rest,
+	* e.g. the taxes. When the redeems cover the whole total, only
+	* REDEMPTION tenders.
 	*/
 	getTenders(payment) {
-		const redeem = orderPaymentRedeems$1(this.draft);
+		const redeem = cappedRedeems(this.draft);
 		const providers = this.redemptionProviders;
 		const redemption = redemptionTenderInputs(redeem, providers);
-		if (paymentRedeemsCoverTotal(redeem, this.draft.totals)) return redemption;
+		if (redeemsCoverTotal(redeem, this.draft.totals)) return redemption;
 		const simple = payment ? simpleTenderInput(payment) : null;
 		return [...simple ? [simple] : this.realTenders ?? [], ...redemption];
 	}
@@ -5738,6 +5705,13 @@ var Order = class Order {
 		this.applyServerOrder(next);
 		return this.getOrder();
 	}
+	assertPayable(payment) {
+		if (redeemsCoverTotal(cappedRedeems(this.draft), this.draft.totals)) return;
+		const method = payment?.type;
+		if (method && isRealPaymentMethod(method)) return;
+		if (this.realTenders?.length) return;
+		throw new OrderPaymentRequiredError();
+	}
 	async syncPaymentIntent(tenders) {
 		await this.persist();
 		await this.flush.settle();
@@ -5754,7 +5728,7 @@ var Order = class Order {
 	}
 	/** Keeps the applied redeems while the server holds the same capped ones. */
 	replaceDraft(next) {
-		if (redeemSignature$1(this.draft.redeem ?? []) !== redeemSignature$1(next.redeem ?? [])) this.requestedRedeem = null;
+		if (redeemSignature(this.draft.redeem ?? []) !== redeemSignature(next.redeem ?? [])) this.requestedRedeem = null;
 		this.draft = next;
 	}
 	appliedRedeem() {
@@ -5764,10 +5738,14 @@ var Order = class Order {
 	* Places the order with a DRAFT intent: `intent_id` as is, else the
 	* tenders of `getTenders(input.payment)` saved first (simple flow: one
 	* real tender plus REDEMPTION). The intent is `LOCKED` afterwards (D25).
+	* A rejected order sync is rethrown and nothing is placed; with no real
+	* tender and redeems short of the total it throws
+	* `OrderPaymentRequiredError` instead of placing.
 	*/
 	async placeOrder(input = {}) {
 		await this.persist();
 		await this.flush.settle();
+		if (!input.intent_id) this.assertPayable(input.payment);
 		await this.validateOrder();
 		let body = input;
 		if (!input.intent_id) {
@@ -5882,29 +5860,28 @@ var Order = class Order {
 	runPaymentTerminal(payment, key) {
 		return this.payments.runTerminal(payment, key);
 	}
-	/** Applies lines/redeem, replaying redemption steps and totals. */
+	/**
+	* Applies lines/redeem, recomputes totals (redeems never change them),
+	* trims every redeem to its `before_taxes` cap and rebuilds the steps.
+	*/
 	commitLines(patch) {
-		const patched = patch.lines ?? this.draft.lines;
+		const patched = rebuildRootGroups(patch.lines ?? this.draft.lines);
 		const applied = patch.redeem ?? this.appliedRedeem();
-		const steps = this.draft.redemption_steps ?? [];
-		const currency = this.draft.totals.currency;
-		const { lines, redemption_steps, totals } = recomputeRedemptions({
+		const totals = recomputeTotals(patched, this.draft.totals.currency);
+		const capped = capRedeems({
 			lines: patched,
-			redeem: applied,
-			redemption_steps: steps,
-			currency
+			totals,
+			redeem: applied
 		});
-		const redeem = clampPaymentRedeems(applied, orderRedeemCap({
-			lines,
-			totals
-		}), currency);
+		const { lines, redeem } = capped;
+		const redemption_steps = redemptionSteps(capped);
 		this.requestedRedeem = applied;
 		this.draft = {
 			...this.draft,
 			lines,
 			redeem,
-			redemption_steps,
-			totals
+			totals,
+			redemption_steps
 		};
 		this.scheduleAfterMutate();
 	}
@@ -6456,56 +6433,70 @@ const expiredIssues = (redeem, now) => {
 	});
 	return issues;
 };
-const redeemSignature = (items) => {
-	return items.map((item) => `${item.reward_id}:${item.quantity}`).join(",");
-};
-const stepSignature = (steps) => {
-	return steps.map((step) => `${step.reward_id}:${step.reward_quantity}`).join(",");
+/** `NOT_FOUND`, `INACTIVE` or `NOT_REDEMPTION`; null when usable. */
+const paymentProblem = (payment_id, payments) => {
+	const row = payments.find((item) => item.id === payment_id);
+	if (!row) return "NOT_FOUND";
+	if (row.status != null && row.status !== "ACTIVE") return "INACTIVE";
+	if (row.method.method !== REDEMPTION_METHOD) return "NOT_REDEMPTION";
+	return null;
 };
 /**
-* Every target's discount redeems must have one step each, in the same
-* order. Payment redeems are a REDEMPTION tender, never a step (D16).
+* Every redeem needs `payment_id` and `amount > 0`; with `payments`, the
+* payment must exist, be active and be a REDEMPTION method. `amount` must
+* already be trimmed to its `before_taxes` cap (`fitted`).
 */
-const checkRedemptionTargets = (lines, redeem, steps, issues, lineIssues) => {
-	const byTarget = /* @__PURE__ */ new Map();
-	for (const step of steps) {
-		const key = redemptionTargetKey(step);
-		byTarget.set(key, [...byTarget.get(key) ?? [], step]);
-	}
-	const check = (key, items) => {
-		const targetSteps = byTarget.get(key) ?? [];
-		byTarget.delete(key);
-		const expected = redeemSignature(discountRedeems(items));
-		const actual = stepSignature(targetSteps);
-		if (expected === actual) return null;
-		return {
-			code: "REDEMPTION_STEPS_MISMATCH",
-			field: "redemption_steps",
-			expected,
-			actual
-		};
-	};
-	const orderIssue = check(redemptionTargetKey({ target: "ORDER" }), redeem);
-	if (orderIssue) issues.push(orderIssue);
-	for (const line of lines) {
-		const lineIssue = check(redemptionTargetKey({
-			target: "LINE",
-			target_id: line.uid
-		}), line.redeem ?? []);
-		if (lineIssue) pushLineIssue(lineIssues, line.uid, lineIssue);
-	}
-	for (const orphan of byTarget.values()) {
-		const b1 = { code: "REDEMPTION_STEPS_MISMATCH" };
-		const b2 = {
-			field: "redemption_steps.target_id",
-			expected: ""
+const redeemIssues = (items, fitted, payments) => {
+	const issues = [];
+	items.forEach((item, index) => {
+		const prefix = `redeem.${index}`;
+		const payment_id = item.payment_id;
+		if (typeof payment_id !== "string" || !payment_id) {
+			issues.push({
+				code: "REDEEM_PAYMENT_REQUIRED",
+				field: `${prefix}.payment_id`
+			});
+			return;
+		}
+		if (!(typeof item.amount === "number" && item.amount > 0)) {
+			issues.push({
+				code: "REDEEM_PAYMENT_REQUIRED",
+				field: `${prefix}.amount`
+			});
+			return;
+		}
+		const problem = payments ? paymentProblem(payment_id, payments) : null;
+		if (problem) {
+			const b1 = {
+				code: "REDEEM_PAYMENT_METHOD_NOT_CONFIGURED",
+				field: `${prefix}.payment_id`
+			};
+			issues.push({
+				...b1,
+				expected: REDEMPTION_METHOD,
+				actual: problem
+			});
+			return;
+		}
+		const expected = fitted[index];
+		if (expected && expected.eq(item.amount)) return;
+		const b1 = {
+			code: "REDEEM_AMOUNT_MISMATCH",
+			field: `${prefix}.amount`
 		};
+		const b2 = { expected: bigStr(expected?.toNumber() ?? 0) };
 		issues.push({
 			...b1,
 			...b2,
-			actual: stepSignature(orphan)
+			actual: bigStr(item.amount)
 		});
-	}
+	});
+	return issues;
+};
+const stepSignature = (steps) => {
+	return steps.map((step) => {
+		return `${`${step.reward_id}:${step.reward_quantity}:${step.payment_id}`}:${step.target}:${step.target_id ?? ""}`;
+	}).join(",");
 };
 const STATE_FIELDS = [
 	"value",
@@ -6523,37 +6514,39 @@ const flattenState = (prefix, state, out) => {
 	for (const field of STATE_FIELDS) out[`${prefix}.${field}`] = state ? bigStr(state[field]) : "";
 };
 const flattenStep = (step) => {
-	const b1 = { reward_id: step.reward_id };
-	const b2 = { reward_quantity: String(step.reward_quantity) };
-	const b3 = {
-		target: step.target,
-		target_id: step.target_id ?? ""
+	const b1 = {
+		action: step.action,
+		before_taxes: String(step.before_taxes)
 	};
-	const b4 = { action: step.action };
-	const b5 = { discount_amount: bigStr(step.discount_amount) };
+	const b2 = { discount_amount: bigStr(step.discount_amount) };
 	const out = {
 		...b1,
-		...b2,
-		...b3,
-		...b4,
-		...b5
+		...b2
 	};
 	for (const key of STATE_KEYS) flattenState(key, step[key], out);
 	return out;
 };
-/** Replayed steps must equal the submitted ones field by field. */
-const compareRedemptionSteps = (submitted, expected, issues) => {
-	if (submitted.length !== expected.length) {
-		const b1 = { code: "REDEMPTION_MISMATCH" };
-		const b2 = { field: "redemption_steps" };
-		const b3 = { expected: String(expected.length) };
+/**
+* `REDEMPTION_STEPS_MISMATCH`: the steps do not list the redeems (reward,
+* units, payment, target) in application order. `REDEMPTION_MISMATCH`:
+* same redeems, but a step's money or state differs from the server's.
+*/
+const stepIssues = (submitted, expected) => {
+	const issues = [];
+	const wantedSignature = stepSignature(expected);
+	const actualSignature = stepSignature(submitted);
+	if (wantedSignature !== actualSignature) {
+		const b1 = { code: "REDEMPTION_STEPS_MISMATCH" };
+		const b2 = {
+			field: "redemption_steps",
+			expected: wantedSignature
+		};
 		issues.push({
 			...b1,
 			...b2,
-			...b3,
-			actual: String(submitted.length)
+			actual: actualSignature
 		});
-		return;
+		return issues;
 	}
 	submitted.forEach((step, index) => {
 		const actual = flattenStep(step);
@@ -6573,22 +6566,36 @@ const compareRedemptionSteps = (submitted, expected, issues) => {
 			});
 		}
 	});
+	return issues;
 };
 const validateRedemptions = (input, issues, lineIssues) => {
 	const redeem = input.redeem ?? [];
-	const steps = input.redemptionSteps ?? [];
 	const now = input.now ?? Date.now();
+	const p1 = {
+		lines: input.lines,
+		totals: input.totals,
+		redeem
+	};
+	const fitted = fitRedeems(p1);
 	issues.push(...expiredIssues(redeem, now));
-	for (const line of input.lines) {
-		const expired = expiredIssues(line.redeem ?? [], now);
+	issues.push(...redeemIssues(redeem, fitted.redeem, input.payments));
+	input.lines.forEach((line, index) => {
+		const items = line.redeem ?? [];
+		const expired = expiredIssues(items, now);
 		for (const issue of expired) pushLineIssue(lineIssues, line.uid, issue);
-	}
-	checkRedemptionTargets(input.lines, redeem, steps, issues, lineIssues);
-	const replayed = replayRedemptions(input.lines, redeem, steps);
-	compareRedemptionSteps(steps, replayed.redemption_steps, issues);
-	return replayed.lines;
+		if (line.parent_uid != null) return;
+		const p2 = [
+			items,
+			fitted.lines[index] ?? [],
+			input.payments
+		];
+		for (const issue of redeemIssues(...p2)) pushLineIssue(lineIssues, line.uid, issue);
+	});
+	if (input.redemptionSteps === void 0) return;
+	const expected = redemptionSteps(p1);
+	issues.push(...stepIssues(input.redemptionSteps, expected));
 };
-const REDEEMED_GROUP_FIELDS = [
+const ROOT_GROUP_FIELDS = [
 	["group_discount", "DISCOUNT_MISMATCH"],
 	["unit_group_discount", "DISCOUNT_MISMATCH"],
 	["group_tax_total", "TAX_MISMATCH"],
@@ -6596,14 +6603,17 @@ const REDEEMED_GROUP_FIELDS = [
 	["group_total", "PRICE_MISMATCH"],
 	["unit_group_total", "PRICE_MISMATCH"]
 ];
-/** Root group money must carry exactly the replayed redemption discounts. */
-const compareRedeemedRoots = (submitted, expected, out) => {
+/**
+* Root group money is the line plus its children: a redeem never lowers
+* it (its REDEMPTION tender pays it), so a wiped line is rejected.
+*/
+const compareRootGroups = (submitted, expected, out) => {
 	const byUid = new Map(expected.map((line) => [line.uid, line]));
 	for (const line of submitted) {
 		if (line.parent_uid != null) continue;
 		const wanted = byUid.get(line.uid);
 		if (!wanted) continue;
-		for (const [field, code] of REDEEMED_GROUP_FIELDS) {
+		for (const [field, code] of ROOT_GROUP_FIELDS) {
 			if (bigEq(line[field], wanted[field])) continue;
 			const b1 = {
 				code,
@@ -6628,7 +6638,7 @@ const validateOrderAgainstMenu = (input) => {
 		lines: {}
 	};
 	if (!input.menuActive) issues.push({ code: "MENU_CLOSED" });
-	const menuLines = stripRedemptionLines(input.lines);
+	const menuLines = rebuildRootGroups(input.lines);
 	const roots = menuLines.filter((line) => line.parent_uid == null);
 	if (roots.length === 0) {
 		issues.push({ code: "EMPTY_ORDER" });
@@ -6648,9 +6658,9 @@ const validateOrderAgainstMenu = (input) => {
 	}
 	checkRootProductQuantities(roots, lookup, lineIssues);
 	if (input.expectedFeeLines) compareExpectedFeeLines(input.lines, input.expectedFeeLines, lineIssues);
-	const redeemed = validateRedemptions(input, issues, lineIssues);
-	compareRedeemedRoots(input.lines, redeemed, lineIssues);
-	const expectedTotals = recomputeTotals(redeemed, input.totals.currency);
+	validateRedemptions(input, issues, lineIssues);
+	compareRootGroups(input.lines, menuLines, lineIssues);
+	const expectedTotals = recomputeTotals(menuLines, input.totals.currency);
 	for (const field of TOTALS_FIELDS) {
 		if (bigEq(input.totals[field], expectedTotals[field])) continue;
 		issues.push({
@@ -8646,4 +8656,4 @@ const cardPreviewGroups = (value) => {
 	return groups;
 };
 //#endregion
-export { CARD_BRANDS, DEFAULT_RECOMMENDATION_TYPES, Order, OrderSyncPendingError, OrderValidationError, RecurringDateCron, RulesEngine, StorefrontHttpError, addLines, auth, buildCustomerSnapshot, cardBrandSpec, cardDigits, cardNumberGaps, cardNumberMaxLength, cardPreviewGroups, caretAfterDigits, clampPaymentRedeems, collectOrderLineDiffs, computeStartingPrice, countCartProducts, coveredAmount, createSession, currentNodes, cvcMaxLength, defaultConditionError, detectCardBrand, flattenMenuCategories, flushLogs, formatCardNumber, formatCvc, formatExpiry, fromOrderLines, genId, genOrderId, getLogContext, getScheduleWindow, indexMenu, isCardNumberComplete, isCardNumberDefinitelyInvalid, isCheckoutFieldFilled, isCvcComplete, isDeviceCharged, isDeviceNotLinked, isExpiryComplete, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isPosDeviceNotLinked, isPosUnauthorized, isRealPaymentMethod, isStorefrontNotFound, isVariantBase, listMenusStream, localizePosError, log, logError, luhnCheck, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, normalizeCardholderName, orderPaymentRedeems, parseExpiry, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, redemptionCap, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, selectablePayments, serializeError, services, setLineQuantity, storefrontJson, stripRedemptionLines, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, verifyWebhookSignature, visitedStates };
+export { CARD_BRANDS, DEFAULT_RECOMMENDATION_TYPES, Order, OrderPaymentRequiredError, OrderSyncPendingError, OrderSyncRejectedError, OrderValidationError, RecurringDateCron, RulesEngine, StorefrontHttpError, addLines, auth, buildCustomerSnapshot, capRedeems, cappedRedeems, cardBrandSpec, cardDigits, cardNumberGaps, cardNumberMaxLength, cardPreviewGroups, caretAfterDigits, collectOrderLineDiffs, computeStartingPrice, countCartProducts, coveredAmount, createSession, currentNodes, cvcMaxLength, defaultConditionError, detectCardBrand, fitRedeems, flattenMenuCategories, flushLogs, formatCardNumber, formatCvc, formatExpiry, fromOrderLines, genId, genOrderId, getLogContext, getScheduleWindow, indexMenu, isCardNumberComplete, isCardNumberDefinitelyInvalid, isCheckoutFieldFilled, isCvcComplete, isDeviceCharged, isDeviceNotLinked, isExpiryComplete, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderPaymentRequiredError, isOrderValidationError, isPosDeviceNotLinked, isPosUnauthorized, isRealPaymentMethod, isStorefrontNotFound, isVariantBase, linePayableTotal, listMenusStream, localizePosError, log, logError, luhnCheck, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, normalizeCardholderName, orderPayableTotal, orderRedeemedTotal, orderRedeems, parseExpiry, paymentMatchesClientConditions, rebuildRootGroups, recomputeTotals, redeemedTotal, redemptionCap, redemptionSteps, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, selectablePayments, serializeError, services, setLineQuantity, storefrontJson, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, verifyWebhookSignature, visitedStates };