@fire-spark/core 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { DIGITAL_COLLECT_AT, PARTIAL_APPROVAL_ERROR, activeIntent, amountTolerance, createAttemptReference, createPaymentError, currencyDecimals, currentIntent, defaultReversalFor, discountRedeems, groupPaymentRedeems, isDeliveryFee, isPaymentError, isPaymentRedeem, isRealPaymentMethod, isRealPaymentMethod as isRealPaymentMethod$1, isTenderSettled, isTipFee, liveTenders, memoryPaymentStorage, missingDeviceFields, orderPaymentRedeems, orderPaymentRedeems as orderPaymentRedeems$1, paymentRedeemsCoverTotal, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, 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,49 +3512,91 @@ 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) => {
-		return isTipFee(line) || isDeliveryFee(line) ? sum + line.group_total : sum;
-	}, 0);
-	const decimals = currencyDecimals(order.totals.currency);
-	return Math.max(roundTo(order.totals.total - primaryOnly, decimals), 0);
-};
 /**
-* 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) => sum + (item.amount ?? 0), 0);
-	const decimals = currencyDecimals(order.totals.currency);
-	return Math.max(roundTo(redemptionCap(order) - used, decimals), 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());
+	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.
-*/
-const clampPaymentRedeems = (redeem, cap, currency) => {
-	const decimals = currencyDecimals(currency);
-	let left = cap;
-	return redeem.flatMap((item) => {
-		if (!isPaymentRedeem(item)) return [item];
-		const amount = item.amount ?? 0;
-		const fits = Math.max(roundTo(Math.min(amount, left), decimals), 0);
-		left = roundTo(left - fits, decimals);
-		if (fits <= 0) return [];
-		if (fits + amountTolerance(currency) >= amount) return [item];
+const keepFitted = (items, fitted) => {
+	return items.flatMap((item, index) => {
+		const fits = fitted[index] ?? moneyZero();
+		if (fits.lte(0)) return [];
+		if (fits.eq(item.amount)) return [item];
 		return [{
 			...item,
-			amount: fits
+			amount: moneyNumber(fits)
 		}];
 	});
 };
 /**
-* 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",
@@ -3884,14 +3976,15 @@ const chargedTenders = (intents) => {
 };
 /** Settled tenders plus PENDING `confirm_after_inject`, order currency. */
 const coveredAmount = (intents) => {
-	return chargedTenders(intents).reduce((sum, tender) => {
-		return sum + tender.amount.total;
-	}, 0);
+	return moneyNumber(chargedTenders(intents).reduce((sum, tender) => {
+		return sum.plus(tender.amount.total);
+	}, moneyZero()));
 };
 const remainingAmount = (order) => {
-	const decimals = currencyDecimals(order.totals.currency);
-	const left = order.totals.total - coveredAmount(order.payment_intents);
-	return Math.max(roundTo(left, decimals), 0);
+	const covered = money(coveredAmount(order.payment_intents));
+	const left = money(order.totals.total).minus(covered);
+	if (left.lt(0)) return 0;
+	return moneyNumber(left);
 };
 const isPlaced = (order) => order.status !== "OPEN";
 /** Orchestrator failures carry the charge-currency amount, not the order's. */
@@ -3909,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";
@@ -4021,12 +4113,9 @@ var PaymentSession = class {
 		const conversion = await this.chargeAmount(payment, amount, server);
 		const config = record(payment.config);
 		const methodConfig = record(payment.method.config);
-		const share = order.totals.total > 0 ? amount / order.totals.total : 1;
-		const decimals = currencyDecimals(order.totals.currency);
-		const taxes = taxBreakdown(order.lines, {
-			share,
-			decimals
-		});
+		const total = order.totals.total;
+		const share = moneyNumber(total > 0 ? money(amount).div(total) : money(1));
+		const taxes = taxBreakdown(order.lines, { share });
 		const info = order.customer.customer_info;
 		const customer = {
 			document: info.document_number ?? null,
@@ -4657,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,
@@ -4767,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");
@@ -4787,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;
@@ -4972,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
@@ -5084,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) => {
@@ -5147,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,
@@ -5500,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;
@@ -5532,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;
@@ -5689,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,
@@ -5704,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];
 	}
@@ -5735,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();
@@ -5751,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() {
@@ -5761,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) {
@@ -5879,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();
 	}
@@ -6453,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: ""
-		};
-		issues.push({
-			...b1,
+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",
@@ -6520,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);
@@ -6570,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"],
@@ -6593,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,
@@ -6625,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" });
@@ -6645,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({
@@ -6959,391 +6972,8 @@ const verifyWebhookSignature = async (input) => {
 	return safeEqual(received, await hmacHex(secret, body));
 };
 //#endregion
-//#region src/rules/assert.ts
-const assert = (value, message) => {
-	if (value) return;
-	throw new Error(message);
-};
-//#endregion
-//#region src/rules/common.ts
-const primitiveError = (primitive) => {
-	return `Condition primitive must be ${primitive}`;
-};
-const typeError = (type) => {
-	return `Condition type must be ${type}`;
-};
-const defaultConditionError = "Condition was not met";
-const getLineByProductId = (lines, productId) => {
-	if (!productId) return void 0;
-	return lines?.find((line) => line.id === productId);
-};
-const countCartProducts = (lines, includeModifiers) => {
-	if (!lines?.length) return 0;
-	return lines.filter((line) => {
-		if (line.type === "FEE") return false;
-		if (includeModifiers) return true;
-		if (!(line.parent_uid == null)) return false;
-		return line.type === "PRODUCT" || line.type == null;
-	}).reduce((sum, line) => sum + line.quantity, 0);
-};
-const getLineTagValues = (lines, tag) => {
-	if (!tag) return [];
-	const values = [];
-	for (const line of lines ?? []) {
-		const value = line.tags?.[tag];
-		if (typeof value === "undefined") continue;
-		values.push(value);
-	}
-	return values;
-};
-//#endregion
-//#region src/rules/booleanMatcher.ts
-const matchBooleanOperator = (condition, matcher) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "boolean", primitiveError("boolean"));
-	if (typeof matcher === "undefined") return false;
-	assert(typeof value === "boolean", "Invalid boolean value");
-	switch (operator) {
-		case "is": return matcher === value;
-		case "is not": return matcher !== value;
-		default: throw new Error(`Operator ${operator} not supported in boolean matcher`);
-	}
-};
-const isAnonymousCustomer = (condition, isAnonymous) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Customer is anonymous";
-	assert(primitive === "boolean", primitiveError("boolean"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchBooleanOperator(condition, isAnonymous ?? false);
-};
-const orderIncludesProductWithTag$3 = (condition, matcher) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Order includes product with tag";
-	assert(primitive === "boolean", primitiveError("boolean"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchBooleanOperator(condition, matcher);
-};
-const isAnonymousOrder = (condition, isAnonymous) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Is anonymous order";
-	assert(primitive === "boolean", primitiveError("boolean"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchBooleanOperator(condition, isAnonymous ?? false);
-};
-const paymentIsMixed = (condition, isMixed) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Payment is mixed";
-	assert(primitive === "boolean", primitiveError("boolean"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchBooleanOperator(condition, isMixed ?? false);
-};
-const paymentCaptured = (condition, captured) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Payment captured";
-	assert(primitive === "boolean", primitiveError("boolean"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchBooleanOperator(condition, captured ?? false);
-};
-//#endregion
-//#region src/rules/currencyMatcher.ts
-const matchCurrencyOperator = (condition, matcher) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "currency", primitiveError("currency"));
-	if (typeof matcher === "undefined") return false;
-	assert(typeof value === "number", "Invalid currency value");
-	switch (operator) {
-		case "equal to": return matcher === value;
-		case "not equal to": return matcher !== value;
-		case "greater than": return matcher > value;
-		case "greater than or equal to": return matcher >= value;
-		case "less than": return matcher < value;
-		case "less than or equal to": return matcher <= value;
-		default: throw new Error(`Operator ${operator} not supported in currency matcher`);
-	}
-};
-const orderIncludesProductWithTag$2 = (condition, matcher) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Order includes product with tag";
-	assert(primitive === "currency", primitiveError("currency"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchCurrencyOperator(condition, matcher);
-};
-const orderTotal = (condition, total) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Order total";
-	assert(primitive === "currency", primitiveError("currency"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchCurrencyOperator(condition, total);
-};
-//#endregion
-//#region src/rules/customMatcher.ts
-const MULTI_OPERATORS = [
-	"is any of",
-	"is none of",
-	"is all of"
-];
-const isMultiOperator = (operator) => {
-	return MULTI_OPERATORS.includes(operator);
-};
-const splitCsv = (value) => {
-	return value.split(",").map((part) => part.trim()).filter(Boolean);
-};
-const matchCustomEquality = (condition, matcher) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "custom", primitiveError("custom"));
-	if (typeof matcher === "undefined") return false;
-	assert(typeof value === "string", "Invalid custom value");
-	switch (operator) {
-		case "is": return matcher === value;
-		case "is not": return matcher !== value;
-		default: throw new Error(`Operator ${operator} not supported in custom matcher`);
-	}
-};
-const matchCustomMulti = (condition, matcher) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "custom", primitiveError("custom"));
-	if (typeof matcher === "undefined") return false;
-	assert(typeof value === "string", "Invalid custom value");
-	const allowed = splitCsv(value);
-	if (allowed.length === 0) return false;
-	const candidates = typeof matcher === "object" ? matcher : [matcher];
-	if (candidates.length === 0) return false;
-	if (operator === "is any of") return allowed.some((id) => candidates.includes(id));
-	if (operator === "is none of") return !allowed.some((id) => candidates.includes(id));
-	if (operator === "is all of") return allowed.every((id) => candidates.includes(id));
-	throw new Error(`Operator ${operator} not supported in custom matcher`);
-};
-/**
-* The operator picks the arity: `Payment` is single-select in order rules and
-* multi-select in fulfillment workflows. `matcher` may be a set (one id per
-* tender): `is` matches when some id matches, `is not` when none does.
-*/
-const matchCustom = (condition, matcher) => {
-	if (isMultiOperator(condition.operator)) return matchCustomMulti(condition, matcher);
-	if (typeof matcher === "undefined" || typeof matcher === "string") return matchCustomEquality(condition, matcher);
-	if (matcher.length === 0) return false;
-	const matches = (id) => matchCustomEquality(condition, id);
-	if (condition.operator === "is not") return matcher.every(matches);
-	return matcher.some(matches);
-};
-const assertCustom = (condition, order) => {
-	const { type } = condition;
-	switch (type) {
-		case "Fulfillment":
-		case "Fulfillments": return matchCustom(condition, order.fulfillment_id);
-		case "Store":
-		case "Stores": return matchCustom(condition, order.store_id);
-		case "Channel":
-		case "Channels": return matchCustom(condition, order.channel_id);
-		case "Brand":
-		case "Brands": return matchCustom(condition, order.brand_id);
-		default: throw new Error(`Condition ${type} not supported in custom matcher`);
-	}
-};
-//#endregion
-//#region src/rules/enumMatcher.ts
-const matchEnumOperator = (condition, matcher) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "enum", primitiveError("enum"));
-	if (typeof matcher === "undefined") return false;
-	switch (operator) {
-		case "is":
-			assert(typeof value === "string", "Expected a single enum value");
-			return matcher === value;
-		case "is not":
-			assert(typeof value === "string", "Expected a single enum value");
-			return matcher !== value;
-		case "is any of":
-			assert(Array.isArray(value), "Expected a list of enum values");
-			return value.includes(matcher);
-		case "is none of":
-			assert(Array.isArray(value), "Expected a list of enum values");
-			return !value.includes(matcher);
-		default: throw new Error(`Operator ${operator} not supported in enum matcher`);
-	}
-};
-const NEGATIVE_ENUM_OPERATORS = ["is not", "is none of"];
-/**
-* Enum condition over a set (one value per tender): positive operators
-* match when some value matches, negative ones when none matches.
-*/
-const matchEnumSet = (condition, matcher) => {
-	if (typeof matcher === "undefined" || typeof matcher === "string") return matchEnumOperator(condition, matcher);
-	if (matcher.length === 0) return false;
-	const matches = (value) => matchEnumOperator(condition, value);
-	if (NEGATIVE_ENUM_OPERATORS.includes(condition.operator)) return matcher.every(matches);
-	return matcher.some(matches);
-};
-const paymentCollectAt = (condition, collectAt) => {
-	const matcherType = "Payment collect at";
-	assert(condition.primitive === "enum", primitiveError("enum"));
-	assert(condition.type === matcherType, typeError(matcherType));
-	return matchEnumSet(condition, collectAt);
-};
-const paymentMethod = (condition, method) => {
-	const matcherType = "Payment method";
-	assert(condition.primitive === "enum", primitiveError("enum"));
-	assert(condition.type === matcherType, typeError(matcherType));
-	return matchEnumSet(condition, method);
-};
-const paymentStatus = (condition, status) => {
-	const matcherType = "Payment status";
-	assert(condition.primitive === "enum", primitiveError("enum"));
-	assert(condition.type === matcherType, typeError(matcherType));
-	return matchEnumOperator(condition, status);
-};
-const CONDITION_INTERPRETATION_DEFAULT = "server";
-const isInterpretationCompatible = (interpretation, runtime, fallback) => {
-	if (!runtime) return true;
-	const value = interpretation ?? fallback;
-	if (value === "both") return true;
-	return value === runtime;
-};
-//#endregion
-//#region src/rules/numberMatcher.ts
-const matchNumberOperator = (condition, matcher) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "number", primitiveError("number"));
-	if (typeof matcher === "undefined") return false;
-	assert(typeof value === "number", "Invalid number value");
-	switch (operator) {
-		case "equal to": return matcher === value;
-		case "not equal to": return matcher !== value;
-		case "greater than": return matcher > value;
-		case "greater than or equal to": return matcher >= value;
-		case "less than": return matcher < value;
-		case "less than or equal to": return matcher <= value;
-		default: throw new Error(`Operator ${operator} not supported in number matcher`);
-	}
-};
-const orderIncludesProduct = (condition, quantity) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Order includes product";
-	assert(primitive === "number", primitiveError("number"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchNumberOperator(condition, quantity ?? 0);
-};
-const cartProductCount = (condition, count) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Cart product count";
-	assert(primitive === "number", primitiveError("number"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchNumberOperator(condition, count);
-};
-const orderIncludesProductWithTag$1 = (condition, matcher) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Order includes product with tag";
-	assert(primitive === "number", primitiveError("number"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchNumberOperator(condition, matcher);
-};
-//#endregion
-//#region src/rules/stringCondition.utils.ts
-const getCaseInsensitive = (condition) => {
-	return condition.caseInsensitive ?? false;
-};
-const normalizeStringForMatch = (value, caseInsensitive) => {
-	if (caseInsensitive) return value.toLowerCase();
-	return value;
-};
-const normalizePairForMatch = (matcher, expected, caseInsensitive) => {
-	return {
-		matcher: normalizeStringForMatch(matcher, caseInsensitive),
-		expected: normalizeStringForMatch(expected, caseInsensitive)
-	};
-};
-//#endregion
-//#region src/rules/stringMatcher.ts
-const matchStringOperator = (condition, matcher) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "string", primitiveError("string"));
-	if (typeof matcher === "undefined") return false;
-	const caseInsensitive = getCaseInsensitive(condition);
-	const pair = normalizePairForMatch(matcher, String(value), caseInsensitive);
-	const normalizedMatcher = pair.matcher;
-	const normalizedExpected = pair.expected;
-	switch (operator) {
-		case "equal to": return normalizedMatcher === normalizedExpected;
-		case "not equal to": return normalizedMatcher !== normalizedExpected;
-		case "starts with": return normalizedMatcher.startsWith(normalizedExpected);
-		case "ends with": return normalizedMatcher.endsWith(normalizedExpected);
-		case "contains": return normalizedMatcher.includes(normalizedExpected);
-		default: throw new Error(`Operator ${operator} not supported in string matcher`);
-	}
-};
-const orderIncludesProductWithTag = (condition, matcher) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Order includes product with tag";
-	assert(primitive === "string", primitiveError("string"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchStringOperator(condition, matcher);
-};
-//#endregion
-//#region src/rules/monitoringMatcher.ts
-const windowOf = (condition) => {
-	if (!("window_minutes" in condition)) return void 0;
-	return condition.window_minutes;
-};
-const accumulatedEvents = (condition, count) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Accumulated events";
-	assert(primitive === "number", primitiveError("number"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	if (typeof count === "undefined") return false;
-	return matchNumberOperator(condition, count);
-};
-const apiErrorRate = (condition, rate) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "API error rate";
-	assert(primitive === "number", primitiveError("number"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	if (typeof rate === "undefined") return false;
-	return matchNumberOperator(condition, rate);
-};
-const httpStatus = (condition, status) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "HTTP status";
-	assert(primitive === "number", primitiveError("number"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	if (typeof status === "undefined") return false;
-	return matchNumberOperator(condition, status);
-};
-const requestPath = (condition, path) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Request path";
-	assert(primitive === "string", primitiveError("string"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchStringOperator(condition, path);
-};
-const failureMessage = (condition, message) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Failure message";
-	assert(primitive === "string", primitiveError("string"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchStringOperator(condition, message);
-};
-const windowMinutes = (condition) => {
-	return windowOf(condition);
-};
-//#endregion
-//#region src/rules/recurringDateCron.ts
-var import_dayjs_min = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../../node_modules/.pnpm/dayjs@1.11.9/node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	(function(t, e) {
 		"object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
 	})(exports, (function() {
@@ -7638,7 +7268,412 @@ var import_dayjs_min = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((
 			return w(1e3 * t);
 		}, w.en = D[g], w.Ls = D, w.p = {}, w;
 	}));
-})))(), 1);
+}));
+//#endregion
+//#region src/rules/assert.ts
+const assert = (value, message) => {
+	if (value) return;
+	throw new Error(message);
+};
+//#endregion
+//#region src/rules/common.ts
+const primitiveError = (primitive) => {
+	return `Condition primitive must be ${primitive}`;
+};
+const typeError = (type) => {
+	return `Condition type must be ${type}`;
+};
+const defaultConditionError = "Condition was not met";
+const getLineByProductId = (lines, productId) => {
+	if (!productId) return void 0;
+	return lines?.find((line) => line.id === productId);
+};
+const countCartProducts = (lines, includeModifiers) => {
+	if (!lines?.length) return 0;
+	return lines.filter((line) => {
+		if (line.type === "FEE") return false;
+		if (includeModifiers) return true;
+		if (!(line.parent_uid == null)) return false;
+		return line.type === "PRODUCT" || line.type == null;
+	}).reduce((sum, line) => sum + line.quantity, 0);
+};
+const getLineTagValues = (lines, tag) => {
+	if (!tag) return [];
+	const values = [];
+	for (const line of lines ?? []) {
+		const value = line.tags?.[tag];
+		if (typeof value === "undefined") continue;
+		values.push(value);
+	}
+	return values;
+};
+//#endregion
+//#region src/rules/absoluteDateMatcher.ts
+var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
+const matchAbsoluteDateOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "absolute date", primitiveError("absolute date"));
+	if (typeof matcher === "undefined") return false;
+	const matcherDate = (0, import_dayjs_min.default)(matcher);
+	const expectedDate = (0, import_dayjs_min.default)(value);
+	switch (operator) {
+		case "is": return matcherDate.isSame(expectedDate, "day");
+		case "is not": return !matcherDate.isSame(expectedDate, "day");
+		case "is before": return matcherDate.isBefore(expectedDate, "day");
+		case "is after": return matcherDate.isAfter(expectedDate, "day");
+		default: {
+			const msg = `Operator ${operator} not supported in absolute date matcher`;
+			throw new Error(msg);
+		}
+	}
+};
+//#endregion
+//#region src/rules/booleanMatcher.ts
+const matchBooleanOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "boolean", primitiveError("boolean"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "boolean", "Invalid boolean value");
+	switch (operator) {
+		case "is": return matcher === value;
+		case "is not": return matcher !== value;
+		default: throw new Error(`Operator ${operator} not supported in boolean matcher`);
+	}
+};
+const isAnonymousCustomer = (condition, isAnonymous) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Customer is anonymous";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, isAnonymous ?? false);
+};
+const orderIncludesProductWithTag$3 = (condition, matcher) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product with tag";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, matcher);
+};
+const isAnonymousOrder = (condition, isAnonymous) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Is anonymous order";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, isAnonymous ?? false);
+};
+const paymentIsMixed = (condition, isMixed) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Payment is mixed";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, isMixed ?? false);
+};
+const paymentCaptured = (condition, captured) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Payment captured";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, captured ?? false);
+};
+//#endregion
+//#region src/rules/currencyMatcher.ts
+const matchCurrencyOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "currency", primitiveError("currency"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "number", "Invalid currency value");
+	switch (operator) {
+		case "equal to": return matcher === value;
+		case "not equal to": return matcher !== value;
+		case "greater than": return matcher > value;
+		case "greater than or equal to": return matcher >= value;
+		case "less than": return matcher < value;
+		case "less than or equal to": return matcher <= value;
+		default: throw new Error(`Operator ${operator} not supported in currency matcher`);
+	}
+};
+const orderIncludesProductWithTag$2 = (condition, matcher) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product with tag";
+	assert(primitive === "currency", primitiveError("currency"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchCurrencyOperator(condition, matcher);
+};
+const orderTotal = (condition, total) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order total";
+	assert(primitive === "currency", primitiveError("currency"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchCurrencyOperator(condition, total);
+};
+//#endregion
+//#region src/rules/customMatcher.ts
+const MULTI_OPERATORS = [
+	"is any of",
+	"is none of",
+	"is all of"
+];
+const isMultiOperator = (operator) => {
+	return MULTI_OPERATORS.includes(operator);
+};
+const splitCsv = (value) => {
+	return value.split(",").map((part) => part.trim()).filter(Boolean);
+};
+const matchCustomEquality = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "custom", primitiveError("custom"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "string", "Invalid custom value");
+	switch (operator) {
+		case "is": return matcher === value;
+		case "is not": return matcher !== value;
+		default: throw new Error(`Operator ${operator} not supported in custom matcher`);
+	}
+};
+const matchCustomMulti = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "custom", primitiveError("custom"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "string", "Invalid custom value");
+	const allowed = splitCsv(value);
+	if (allowed.length === 0) return false;
+	const candidates = typeof matcher === "object" ? matcher : [matcher];
+	if (candidates.length === 0) return false;
+	if (operator === "is any of") return allowed.some((id) => candidates.includes(id));
+	if (operator === "is none of") return !allowed.some((id) => candidates.includes(id));
+	if (operator === "is all of") return allowed.every((id) => candidates.includes(id));
+	throw new Error(`Operator ${operator} not supported in custom matcher`);
+};
+/**
+* The operator picks the arity: `Payment` is single-select in order rules and
+* multi-select in fulfillment workflows. `matcher` may be a set (one id per
+* tender): `is` matches when some id matches, `is not` when none does.
+*/
+const matchCustom = (condition, matcher) => {
+	if (isMultiOperator(condition.operator)) return matchCustomMulti(condition, matcher);
+	if (typeof matcher === "undefined" || typeof matcher === "string") return matchCustomEquality(condition, matcher);
+	if (matcher.length === 0) return false;
+	const matches = (id) => matchCustomEquality(condition, id);
+	if (condition.operator === "is not") return matcher.every(matches);
+	return matcher.some(matches);
+};
+const assertCustom = (condition, order) => {
+	const { type } = condition;
+	switch (type) {
+		case "Fulfillment":
+		case "Fulfillments": return matchCustom(condition, order.fulfillment_id);
+		case "Store":
+		case "Stores": return matchCustom(condition, order.store_id);
+		case "Channel":
+		case "Channels": return matchCustom(condition, order.channel_id);
+		case "Brand":
+		case "Brands": return matchCustom(condition, order.brand_id);
+		default: throw new Error(`Condition ${type} not supported in custom matcher`);
+	}
+};
+//#endregion
+//#region src/rules/enumMatcher.ts
+const matchEnumOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "enum", primitiveError("enum"));
+	if (typeof matcher === "undefined") return false;
+	switch (operator) {
+		case "is":
+			assert(typeof value === "string", "Expected a single enum value");
+			return matcher === value;
+		case "is not":
+			assert(typeof value === "string", "Expected a single enum value");
+			return matcher !== value;
+		case "is any of":
+			assert(Array.isArray(value), "Expected a list of enum values");
+			return value.includes(matcher);
+		case "is none of":
+			assert(Array.isArray(value), "Expected a list of enum values");
+			return !value.includes(matcher);
+		default: throw new Error(`Operator ${operator} not supported in enum matcher`);
+	}
+};
+const NEGATIVE_ENUM_OPERATORS = ["is not", "is none of"];
+/**
+* Enum condition over a set (one value per tender): positive operators
+* match when some value matches, negative ones when none matches.
+*/
+const matchEnumSet = (condition, matcher) => {
+	if (typeof matcher === "undefined" || typeof matcher === "string") return matchEnumOperator(condition, matcher);
+	if (matcher.length === 0) return false;
+	const matches = (value) => matchEnumOperator(condition, value);
+	if (NEGATIVE_ENUM_OPERATORS.includes(condition.operator)) return matcher.every(matches);
+	return matcher.some(matches);
+};
+const paymentCollectAt = (condition, collectAt) => {
+	const matcherType = "Payment collect at";
+	assert(condition.primitive === "enum", primitiveError("enum"));
+	assert(condition.type === matcherType, typeError(matcherType));
+	return matchEnumSet(condition, collectAt);
+};
+const paymentMethod = (condition, method) => {
+	const matcherType = "Payment method";
+	assert(condition.primitive === "enum", primitiveError("enum"));
+	assert(condition.type === matcherType, typeError(matcherType));
+	return matchEnumSet(condition, method);
+};
+const paymentStatus = (condition, status) => {
+	const matcherType = "Payment status";
+	assert(condition.primitive === "enum", primitiveError("enum"));
+	assert(condition.type === matcherType, typeError(matcherType));
+	return matchEnumOperator(condition, status);
+};
+const CONDITION_INTERPRETATION_DEFAULT = "server";
+const isInterpretationCompatible = (interpretation, runtime, fallback) => {
+	if (!runtime) return true;
+	const value = interpretation ?? fallback;
+	if (value === "both") return true;
+	return value === runtime;
+};
+//#endregion
+//#region src/rules/numberMatcher.ts
+const matchNumberOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "number", primitiveError("number"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "number", "Invalid number value");
+	switch (operator) {
+		case "equal to": return matcher === value;
+		case "not equal to": return matcher !== value;
+		case "greater than": return matcher > value;
+		case "greater than or equal to": return matcher >= value;
+		case "less than": return matcher < value;
+		case "less than or equal to": return matcher <= value;
+		default: throw new Error(`Operator ${operator} not supported in number matcher`);
+	}
+};
+const orderIncludesProduct = (condition, quantity) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchNumberOperator(condition, quantity ?? 0);
+};
+const cartProductCount = (condition, count) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Cart product count";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchNumberOperator(condition, count);
+};
+const orderIncludesProductWithTag$1 = (condition, matcher) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product with tag";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchNumberOperator(condition, matcher);
+};
+//#endregion
+//#region src/rules/stringCondition.utils.ts
+const getCaseInsensitive = (condition) => {
+	return condition.caseInsensitive ?? false;
+};
+const normalizeStringForMatch = (value, caseInsensitive) => {
+	if (caseInsensitive) return value.toLowerCase();
+	return value;
+};
+const normalizePairForMatch = (matcher, expected, caseInsensitive) => {
+	return {
+		matcher: normalizeStringForMatch(matcher, caseInsensitive),
+		expected: normalizeStringForMatch(expected, caseInsensitive)
+	};
+};
+//#endregion
+//#region src/rules/stringMatcher.ts
+const matchStringOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "string", primitiveError("string"));
+	if (typeof matcher === "undefined") return false;
+	const caseInsensitive = getCaseInsensitive(condition);
+	const pair = normalizePairForMatch(matcher, String(value), caseInsensitive);
+	const normalizedMatcher = pair.matcher;
+	const normalizedExpected = pair.expected;
+	switch (operator) {
+		case "equal to": return normalizedMatcher === normalizedExpected;
+		case "not equal to": return normalizedMatcher !== normalizedExpected;
+		case "starts with": return normalizedMatcher.startsWith(normalizedExpected);
+		case "ends with": return normalizedMatcher.endsWith(normalizedExpected);
+		case "contains": return normalizedMatcher.includes(normalizedExpected);
+		default: throw new Error(`Operator ${operator} not supported in string matcher`);
+	}
+};
+const orderIncludesProductWithTag = (condition, matcher) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product with tag";
+	assert(primitive === "string", primitiveError("string"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchStringOperator(condition, matcher);
+};
+//#endregion
+//#region src/rules/monitoringMatcher.ts
+const windowOf = (condition) => {
+	if (!("window_minutes" in condition)) return void 0;
+	return condition.window_minutes;
+};
+const accumulatedEvents = (condition, count) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Accumulated events";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	if (typeof count === "undefined") return false;
+	return matchNumberOperator(condition, count);
+};
+const apiErrorRate = (condition, rate) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "API error rate";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	if (typeof rate === "undefined") return false;
+	return matchNumberOperator(condition, rate);
+};
+const httpStatus = (condition, status) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "HTTP status";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	if (typeof status === "undefined") return false;
+	return matchNumberOperator(condition, status);
+};
+const requestPath = (condition, path) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Request path";
+	assert(primitive === "string", primitiveError("string"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchStringOperator(condition, path);
+};
+const failureMessage = (condition, message) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Failure message";
+	assert(primitive === "string", primitiveError("string"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchStringOperator(condition, message);
+};
+const windowMinutes = (condition) => {
+	return windowOf(condition);
+};
+//#endregion
+//#region src/rules/recurringDateCron.ts
 import_dayjs_min.default.extend(utc);
 import_dayjs_min.default.extend(timezone);
 import_dayjs_min.default.extend(isBetween);
@@ -7835,6 +7870,47 @@ const currentDate = (condition, referenceDate) => {
 	return matchRecurringDateOperator(condition, current);
 };
 //#endregion
+//#region src/rules/relativeDateMatcher.ts
+const matchRelativeDateOperator = (condition, matcher, referenceDate) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "relative date", primitiveError("relative date"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "string", "Invalid relative date value");
+	const [amountString, unitRaw] = value.split("/");
+	assert(amountString && unitRaw, "Amount & Unit required");
+	const amount = parseInt(amountString, 10);
+	const unit = unitRaw;
+	const issueDate = (0, import_dayjs_min.default)(referenceDate ?? (/* @__PURE__ */ new Date()).toISOString());
+	const matcherDate = (0, import_dayjs_min.default)(matcher);
+	switch (operator) {
+		case "occurred": {
+			const endDate = issueDate.subtract(amount, unit).endOf(unit);
+			const startDate = endDate.startOf(unit);
+			const sameStart = matcherDate.isSame(startDate, unit);
+			const afterStart = matcherDate.isAfter(startDate);
+			const sameEnd = matcherDate.isSame(endDate, unit);
+			const beforeEnd = matcherDate.isBefore(endDate);
+			return (sameStart || afterStart) && (sameEnd || beforeEnd);
+		}
+		case "occurred in the last": {
+			const targetDate = issueDate.subtract(amount, unit);
+			const sameTarget = matcherDate.isSame(targetDate, unit);
+			const afterTarget = matcherDate.isAfter(targetDate);
+			const sameIssue = matcherDate.isSame(issueDate, unit);
+			const beforeIssue = matcherDate.isBefore(issueDate);
+			return (sameTarget || afterTarget) && (sameIssue || beforeIssue);
+		}
+		case "occurred more than": {
+			const targetDate = issueDate.subtract(amount, unit);
+			return matcherDate.isBefore(targetDate, unit);
+		}
+		default: {
+			const msg = `Operator ${operator} not supported in relative date matcher`;
+			throw new Error(msg);
+		}
+	}
+};
+//#endregion
 //#region src/rules/RulesEngine.ts
 var RulesEngine = class {
 	order;
@@ -7932,6 +8008,7 @@ var RulesEngine = class {
 			const monitoring = this.getDependency("monitoring", type);
 			return httpStatus(condition, monitoring.http_status);
 		}
+		if (type === "Customer age") return matchNumberOperator(condition, this.customerAge());
 		throw new Error(`Condition ${type} not supported in number matcher`);
 	};
 	assertBoolean = (condition) => {
@@ -7989,17 +8066,40 @@ var RulesEngine = class {
 			default: throw new Error(`Condition ${type} not supported in enum matcher`);
 		}
 	};
+	customerAge = () => {
+		const dob = this.customer?.dob;
+		if (!dob) return void 0;
+		const born = new Date(dob);
+		const now = new Date(this.referenceDate ?? Date.now());
+		if (Number.isNaN(born.getTime()) || Number.isNaN(now.getTime())) return;
+		let age = now.getUTCFullYear() - born.getUTCFullYear();
+		const month = now.getUTCMonth() - born.getUTCMonth();
+		const beforeBirthday = now.getUTCDate() < born.getUTCDate();
+		if (month < 0 || month === 0 && beforeBirthday) age -= 1;
+		return age;
+	};
+	customerDate = (type) => {
+		const customer = this.customer;
+		if (type === "Birthday") return customer?.dob;
+		if (type === "Registration") return customer?.registered_at;
+		if (type === "Customer last visit") return customer?.last_visit_at;
+		if (type === "Customer last session") return customer?.last_session_at;
+	};
 	assertAbsoluteDate = (condition) => {
 		const { primitive, type } = condition;
 		assert(primitive === "absolute date", primitiveError("absolute date"));
-		const msg = `Condition ${type} not supported in absolute date matcher`;
-		throw new Error(msg);
+		if (type !== "Today") {
+			const msg = `Condition ${type} not supported in absolute date matcher`;
+			throw new Error(msg);
+		}
+		const today = this.referenceDate ?? (/* @__PURE__ */ new Date()).toISOString();
+		return matchAbsoluteDateOperator(condition, today);
 	};
 	assertRelativeDate = (condition) => {
 		const { primitive, type } = condition;
 		assert(primitive === "relative date", primitiveError("relative date"));
-		const msg = `Condition ${type} not supported in relative date matcher`;
-		throw new Error(msg);
+		const fact = this.customerDate(type);
+		return matchRelativeDateOperator(condition, fact, this.referenceDate);
 	};
 	assertRecurringDate = (condition) => {
 		const { primitive, type } = condition;
@@ -8104,66 +8204,6 @@ var RulesEngine = class {
 	};
 };
 //#endregion
-//#region src/rules/absoluteDateMatcher.ts
-const matchAbsoluteDateOperator = (condition, matcher) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "absolute date", primitiveError("absolute date"));
-	if (typeof matcher === "undefined") return false;
-	const matcherDate = (0, import_dayjs_min.default)(matcher);
-	const expectedDate = (0, import_dayjs_min.default)(value);
-	switch (operator) {
-		case "is": return matcherDate.isSame(expectedDate, "day");
-		case "is not": return !matcherDate.isSame(expectedDate, "day");
-		case "is before": return matcherDate.isBefore(expectedDate, "day");
-		case "is after": return matcherDate.isAfter(expectedDate, "day");
-		default: {
-			const msg = `Operator ${operator} not supported in absolute date matcher`;
-			throw new Error(msg);
-		}
-	}
-};
-//#endregion
-//#region src/rules/relativeDateMatcher.ts
-const matchRelativeDateOperator = (condition, matcher, referenceDate) => {
-	const { primitive, operator, value } = condition;
-	assert(primitive === "relative date", primitiveError("relative date"));
-	if (typeof matcher === "undefined") return false;
-	assert(typeof value === "string", "Invalid relative date value");
-	const [amountString, unitRaw] = value.split("/");
-	assert(amountString && unitRaw, "Amount & Unit required");
-	const amount = parseInt(amountString, 10);
-	const unit = unitRaw;
-	const issueDate = (0, import_dayjs_min.default)(referenceDate ?? (/* @__PURE__ */ new Date()).toISOString());
-	const matcherDate = (0, import_dayjs_min.default)(matcher);
-	switch (operator) {
-		case "occurred": {
-			const endDate = issueDate.subtract(amount, unit).endOf(unit);
-			const startDate = endDate.startOf(unit);
-			const sameStart = matcherDate.isSame(startDate, unit);
-			const afterStart = matcherDate.isAfter(startDate);
-			const sameEnd = matcherDate.isSame(endDate, unit);
-			const beforeEnd = matcherDate.isBefore(endDate);
-			return (sameStart || afterStart) && (sameEnd || beforeEnd);
-		}
-		case "occurred in the last": {
-			const targetDate = issueDate.subtract(amount, unit);
-			const sameTarget = matcherDate.isSame(targetDate, unit);
-			const afterTarget = matcherDate.isAfter(targetDate);
-			const sameIssue = matcherDate.isSame(issueDate, unit);
-			const beforeIssue = matcherDate.isBefore(issueDate);
-			return (sameTarget || afterTarget) && (sameIssue || beforeIssue);
-		}
-		case "occurred more than": {
-			const targetDate = issueDate.subtract(amount, unit);
-			return matcherDate.isBefore(targetDate, unit);
-		}
-		default: {
-			const msg = `Operator ${operator} not supported in relative date matcher`;
-			throw new Error(msg);
-		}
-	}
-};
-//#endregion
 //#region src/rules/checkout.ts
 const DEFAULT_SHIPPING_FIELDS = {
 	address_line1: "required",
@@ -8616,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, 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 };