@fire-spark/core 0.1.2 → 0.3.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { createAttemptReference, createPaymentError, currencyDecimals, defaultReversalFor, isPaymentError, memoryPaymentStorage, missingDeviceFields, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, scopedPaymentStorage, taxBreakdown, toChargeAmount, withTerminalLock } from "@fire-spark/payments";
+import { DIGITAL_COLLECT_AT, PARTIAL_APPROVAL_ERROR, activeIntent, amountTolerance, createAttemptReference, createPaymentError, currencyDecimals, currentIntent, defaultReversalFor, isDeliveryFee, isPaymentError, isRealPaymentMethod, isTenderSettled, isTipFee, liveTenders, memoryPaymentStorage, missingDeviceFields, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, 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";
@@ -2069,14 +2069,36 @@ const getPosLogDevice = () => {
 //#region src/services/http.ts
 var StorefrontHttpError = class extends Error {
 	status;
+	/** `details.code` when present, else the top-level `code`. */
 	code;
-	constructor(message, status, code) {
+	/** API `details` object (e.g. `{ code, payment_id, reason }`). */
+	details;
+	constructor(message, status, code, details = null) {
 		super(message);
 		this.name = "StorefrontHttpError";
 		this.status = status;
 		this.code = code;
+		this.details = details;
 	}
 };
+const parseErrorBody = (text) => {
+	try {
+		const json = JSON.parse(text);
+		if (!json || typeof json !== "object") return null;
+		return json;
+	} catch {
+		return null;
+	}
+};
+/** Error from a failed response body; message stays the raw body text. */
+const toStorefrontHttpError = (text, status) => {
+	const body = parseErrorBody(text);
+	const raw = body?.details;
+	const details = raw !== null && typeof raw === "object" ? raw : null;
+	const detailsCode = typeof details?.code === "string" ? details.code : null;
+	const bodyCode = typeof body?.code === "string" ? body.code : void 0;
+	return new StorefrontHttpError(text, status, detailsCode ?? bodyCode, details);
+};
 const isStorefrontNotFound = (error) => {
 	return error instanceof StorefrontHttpError && error.status === 404;
 };
@@ -2117,14 +2139,20 @@ const storefrontRequest = async (path, init = {}, options = {}) => {
 };
 const storefrontJson = async (path, init = {}, options = {}) => {
 	const response = await storefrontRequest(path, init, options);
-	if (!response.ok) throw new StorefrontHttpError(await response.text() || response.statusText, response.status);
+	if (!response.ok) {
+		const body = await response.text();
+		throw toStorefrontHttpError(body || response.statusText, response.status);
+	}
 	const json = await response.json();
 	if (json.data === void 0) throw new Error("Storefront response missing data");
 	return json.data;
 };
 const storefrontVoid = async (path, init = {}, options = {}) => {
 	const response = await storefrontRequest(path, init, options);
-	if (!response.ok) throw new StorefrontHttpError(await response.text() || response.statusText, response.status);
+	if (!response.ok) {
+		const body = await response.text();
+		throw toStorefrontHttpError(body || response.statusText, response.status);
+	}
 };
 const parseNdjsonDataLine = (line) => {
 	const trimmed = line.trim();
@@ -2156,7 +2184,10 @@ const readNdjsonLines = async function* (body) {
 /** Parse an NDJSON storefront body and yield each `{ data }` payload. */
 const storefrontNdjson = async function* (path, init = {}, options = {}) {
 	const response = await storefrontRequest(path, init, options);
-	if (!response.ok) throw new StorefrontHttpError(await response.text() || response.statusText, response.status);
+	if (!response.ok) {
+		const body = await response.text();
+		throw toStorefrontHttpError(body || response.statusText, response.status);
+	}
 	if (response.body) {
 		for await (const line of readNdjsonLines(response.body)) {
 			const data = parseNdjsonDataLine(line);
@@ -2481,7 +2512,7 @@ const placeOrder = (id, body = {}, options) => {
 		options
 	]);
 };
-/** Records (or updates by `metadata.attempt_reference`) one payment intent. */
+/** Records one tender attempt result (idempotent by `attempt_reference`). */
 const recordOrderPayment = (id, body, options) => {
 	const init = {
 		method: "POST",
@@ -2493,6 +2524,50 @@ const recordOrderPayment = (id, body, options) => {
 		options
 	]);
 };
+const postJson$1 = (path, body, options) => {
+	return storefrontJson(path, {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+};
+const tenderPath = (id, tenderId, action) => {
+	const tender = encodeURIComponent(tenderId);
+	return `${orderPath(id)}/tenders/${tender}/${action}`;
+};
+/** Creates or replaces the DRAFT intent; the server computes amounts. */
+const putPaymentIntent = (id, body, options) => {
+	const init = {
+		method: "PUT",
+		body: JSON.stringify(body)
+	};
+	return storefrontJson(...[
+		`${orderPath(id)}/payment-intent`,
+		init,
+		options
+	]);
+};
+/** Discards the DRAFT intent (`409 PAYMENT_INTENT_LOCKED` once placed). */
+const deletePaymentIntent = (id, options) => {
+	return storefrontJson(...[
+		`${orderPath(id)}/payment-intent`,
+		{ method: "DELETE" },
+		options
+	]);
+};
+/** New tender with `replaces_tender_id`; only over a `FAILED` tender (D25). */
+const replaceTender = (id, tenderId, body, options) => {
+	const path = tenderPath(id, tenderId, "replace");
+	return postJson$1(path, body, options);
+};
+const voidTender = (id, tenderId, body, options) => {
+	const path = tenderPath(id, tenderId, "void");
+	return postJson$1(path, body, options);
+};
+/** Full refund without `amount` / `items`; partial by amount or units. */
+const refundTender = (id, tenderId, body, options) => {
+	const path = tenderPath(id, tenderId, "refund");
+	return postJson$1(path, body, options);
+};
 const getOrderFulfillment = (id, options) => {
 	return storefrontJson(...[
 		`${orderPath(id)}/fulfillment`,
@@ -2562,7 +2637,7 @@ const validateOrder = async (body, options) => {
 		const details = parseValidationDetails(parsed);
 		if (details) throw new OrderValidationError(details.issues, details.lines);
 	}
-	throw new StorefrontHttpError(text || response.statusText, response.status);
+	throw toStorefrontHttpError(text || response.statusText, response.status);
 };
 //#endregion
 //#region src/services/payments.ts
@@ -2857,6 +2932,11 @@ const services = {
 		validate: validateOrder,
 		place: placeOrder,
 		recordPayment: recordOrderPayment,
+		putPaymentIntent,
+		deletePaymentIntent,
+		replaceTender,
+		voidTender,
+		refundTender,
 		getFulfillment: getOrderFulfillment,
 		listFulfillments: listOrderFulfillments
 	},
@@ -3043,21 +3123,18 @@ const createFlushController = (runtime) => {
 			totals: order.totals,
 			metadata: order.metadata
 		};
-		const b5 = { customer: order.customer };
-		const b6 = { payment_intents: order.payment_intents };
-		const b7 = { payment_status: order.payment_status };
-		const b8 = { redeem: order.redeem };
-		const b9 = { redemption_steps: order.redemption_steps };
+		const b5 = {
+			customer: order.customer,
+			redeem: order.redeem
+		};
+		const b6 = { redemption_steps: order.redemption_steps };
 		return {
 			...b1,
 			...b2,
 			...b3,
 			...b4,
 			...b5,
-			...b6,
-			...b7,
-			...b8,
-			...b9
+			...b6
 		};
 	};
 	const insertBody = (order) => {
@@ -3079,10 +3156,8 @@ const createFlushController = (runtime) => {
 			totals: order.totals,
 			metadata: order.metadata
 		};
-		const b7 = { payment_intents: order.payment_intents };
-		const b8 = { payment_status: order.payment_status };
-		const b9 = { redeem: order.redeem };
-		const b10 = { redemption_steps: order.redemption_steps };
+		const b7 = { redeem: order.redeem };
+		const b8 = { redemption_steps: order.redemption_steps };
 		return {
 			...b1,
 			...b2,
@@ -3091,9 +3166,7 @@ const createFlushController = (runtime) => {
 			...b5,
 			...b6,
 			...b7,
-			...b8,
-			...b9,
-			...b10
+			...b8
 		};
 	};
 	const flushNow = () => {
@@ -3357,168 +3430,693 @@ const emptyLines = () => {
 	return [];
 };
 //#endregion
-//#region src/order/payments/orchestrator.ts
-const AMBIGUOUS_QUERIES = 3;
-const defaultSleep = (ms, signal) => {
-	return new Promise((resolve) => {
-		const timer = setTimeout(resolve, ms);
-		signal?.addEventListener("abort", () => {
-			clearTimeout(timer);
-			resolve();
-		});
-	});
-};
-const defaultClock = {
-	now: () => Date.now(),
-	sleep: defaultSleep
-};
-var TimeoutSignal = class extends Error {};
-/**
-* Provider deadline that pauses while the customer is answering `ctx.ui`;
-* user waits run on `interaction_timeout_ms` instead.
-*/
-const createDeadline = (timeoutMs, onExpire) => {
-	let remaining = timeoutMs;
-	let startedAt = 0;
-	let timer = null;
-	let paused = 0;
-	const run = () => {
-		startedAt = Date.now();
-		timer = setTimeout(onExpire, Math.max(remaining, 0));
-	};
-	const stop = () => {
-		if (!timer) return;
-		clearTimeout(timer);
-		timer = null;
-		remaining -= Date.now() - startedAt;
+//#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()
 	};
-	return {
-		start: run,
-		pause: () => {
-			if (paused === 0) stop();
-			paused += 1;
-		},
-		resume: () => {
-			paused -= 1;
-			if (paused === 0) run();
-		},
-		clear: stop
+	const b2 = {
+		discount_rate: discountRate,
+		discount_total
 	};
-};
-const withUserTimeout = (promise, ms) => {
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			reject(new PaymentUserTimeout());
-		}, ms);
-		promise.then((value) => {
-			clearTimeout(timer);
-			resolve(value);
-		}, (error) => {
-			clearTimeout(timer);
-			reject(error);
-		});
-	});
-};
-var PaymentUserTimeout = class extends Error {};
-const timedUI = (ui, deadline, interactionMs) => {
-	const wrap = (call) => {
-		deadline.pause();
-		return withUserTimeout(call(), interactionMs).finally(() => deadline.resume());
+	const b3 = {
+		tax_rate: taxRate,
+		tax_total,
+		total: total.toNumber()
 	};
 	return {
-		message: (input) => ui.message(input),
-		action: (input) => ui.action(input),
-		select: (input) => {
-			return wrap(() => ui.select(input));
-		},
-		input: (input) => wrap(() => ui.input(input)),
-		confirm: (input) => wrap(() => ui.confirm(input))
+		...b1,
+		...b2,
+		...b3
 	};
 };
-/** Runs one adapter call with the provider timeout and the user clock. */
-const runTimed = async (ctx, call) => {
-	const controller = new AbortController();
-	const parent = ctx.signal;
-	const abort = () => controller.abort();
-	parent.addEventListener("abort", abort);
-	let expire = () => void 0;
-	const expired = new Promise((_, reject) => {
-		expire = () => {
-			controller.abort();
-			reject(new TimeoutSignal());
-		};
-	});
-	const deadline = createDeadline(ctx.policy.timeout_ms, () => expire());
-	const interaction = ctx.policy.interaction_timeout_ms;
-	const ui = timedUI(ctx.ui, deadline, interaction);
-	const scoped = {
-		...ctx,
-		ui,
-		signal: controller.signal
+const emptyTotals = (currency = "USD") => {
+	const b1 = {
+		currency,
+		subtotal: 0,
+		discount_rate: 0,
+		discount_total: 0
 	};
-	deadline.start();
-	try {
-		return await Promise.race([call(scoped), expired]);
-	} finally {
-		deadline.clear();
-		parent.removeEventListener("abort", abort);
-	}
-};
-const failed = (ctx, error, extra = {}) => {
-	const metadata = {
-		attempt_reference: ctx.attemptReference,
-		error,
-		...extra
+	const b2 = {
+		tax_rate: 0,
+		tax_total: 0,
+		total: 0
 	};
 	return {
-		status: "FAILED",
-		amount: ctx.amount.value,
-		metadata,
-		error
+		...b1,
+		...b2
 	};
 };
-const errorOf = (ctx, error, startedAt, clock) => {
-	const elapsed_ms = clock.now() - startedAt;
-	const attempt = ctx.attempt;
-	if (isPaymentError(error)) return {
-		...error.error,
-		attempt,
-		elapsed_ms
-	};
-	let code = "UNKNOWN";
-	if (error instanceof TimeoutSignal) code = "TIMEOUT";
-	if (error instanceof PaymentUserTimeout) code = "USER_TIMEOUT";
-	const extra = {
-		attempt,
-		elapsed_ms,
-		provider_message: error instanceof Error ? error.message : null
+//#endregion
+//#region src/order/redemptions.ts
+const ORDER_KEY = "ORDER";
+/** Points / balance paid with a REDEMPTION tender, not a discount (D16). */
+const isPaymentRedeem = (redeem) => {
+	return Boolean(redeem.payment_id);
+};
+const buildPaymentRedeem = (input) => {
+	const { reward_id, quantity, payment_id, amount, points } = input;
+	if (amount === void 0 || !(amount > 0)) throw new Error("Redeem with payment_id requires amount > 0");
+	if (points === void 0 || !(points >= 0)) throw new Error("Redeem with payment_id requires points ≥ 0");
+	const redeem = {
+		reward_id,
+		quantity,
+		payment_id,
+		amount
 	};
-	return createPaymentError(code, extra);
-};
-/** `start` that timed out after leaving the device is ambiguous. */
-const startError = (error) => {
-	if (error.code !== "TIMEOUT") return error;
-	return createPaymentError("AMBIGUOUS", {
-		attempt: error.attempt,
-		elapsed_ms: error.elapsed_ms
-	});
+	redeem.points = points;
+	if (input.program !== void 0) redeem.program = input.program;
+	if (input.expires_at !== void 0) redeem.expires_at = input.expires_at;
+	return redeem;
 };
-const isFinal = (result) => result.status !== "PENDING";
-const callOperation = async (ctx, operation, result, clock) => {
-	const startedAt = clock.now();
-	try {
-		return await runTimed(ctx, (scoped) => operation(scoped, result));
-	} catch (error) {
-		return failed(ctx, errorOf(ctx, error, startedAt, clock));
-	}
+/** Same rules as `vOrders.redeem()`; throws on invalid input. */
+const buildRedeem = (input) => {
+	const { reward_id, quantity, discount_rate, discount_amount } = input;
+	const { before_taxes, expires_at } = input;
+	if (!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 (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
+	};
+	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;
 };
-/** Query up to 3 times, cancel once, else FAILED + needs_review. */
-const resolveAmbiguous = async (adapter, ctx, pending, clock) => {
-	if (adapter.query) for (let i = 0; i < AMBIGUOUS_QUERIES; i += 1) {
-		await clock.sleep(ctx.policy.poll_interval_ms, ctx.signal);
-		const next = await callOperation(ctx, adapter.query, pending, clock);
-		if (next.status === "PAID") return next;
-		const definitive = next.error?.code !== "TIMEOUT" && !next.error?.retryable;
+/**
+* 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.
+*/
+const subtractRedeem = (items, reward_id, quantity) => {
+	if (!Number.isInteger(quantity) || quantity < 1) throw new Error("Redeem quantity must be an integer ≥ 1");
+	let pending = quantity;
+	const kept = [];
+	for (let i = items.length - 1; i >= 0; i--) {
+		const item = items[i];
+		if (pending === 0 || item.reward_id !== reward_id) {
+			kept.unshift(item);
+			continue;
+		}
+		const taken = Math.min(item.quantity, pending);
+		pending -= taken;
+		const rest = item.quantity - taken;
+		if (rest > 0) kept.unshift({
+			...item,
+			quantity: rest
+		});
+	}
+	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. */
+const redeemPools = (lines, redeem) => {
+	const pools = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const items = 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 = redeem.filter((item) => !isPaymentRedeem(item)).map((item) => ({
+		...order,
+		redeem: item
+	}));
+	pools.set(ORDER_KEY, pool);
+	return pools;
+};
+/**
+* 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).
+*/
+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);
+	});
+};
+/**
+* Rate compounds once per reward unit over the remaining value; amount is
+* per unit. With both, the rate discount is capped at `amount × quantity`.
+*/
+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;
+};
+/**
+* Root group money rebuilt from the line itself plus its children, i.e. the
+* menu price before any redemption. Child lines are never discounted.
+*/
+const stripRedemptionLines = (lines) => {
+	const children = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		if (line.parent_uid == null) continue;
+		const list = children.get(line.parent_uid) ?? [];
+		list.push(line);
+		children.set(line.parent_uid, list);
+	}
+	return lines.map((line) => {
+		if (line.parent_uid != null) return line;
+		const qty = new Big(line.quantity);
+		let sub = new Big(0);
+		let disc = new Big(0);
+		let tax = new Big(0);
+		let tot = new Big(0);
+		for (const child of children.get(line.uid) ?? []) {
+			sub = sub.plus(child.group_subtotal);
+			disc = disc.plus(child.group_discount);
+			tax = tax.plus(child.group_tax_total);
+			tot = tot.plus(child.group_total);
+		}
+		const gSub = new Big(line.subtotal).plus(sub.times(qty));
+		const gDisc = new Big(line.discount_total).plus(disc.times(qty));
+		const gTax = new Big(line.tax_total).plus(tax.times(qty));
+		const gTot = new Big(line.total).plus(tot.times(qty));
+		const u1 = { unit_group_subtotal: gSub.div(qty).toNumber() };
+		const u2 = { unit_group_discount: gDisc.div(qty).toNumber() };
+		const u3 = { unit_group_tax_total: gTax.div(qty).toNumber() };
+		const u4 = { unit_group_total: gTot.div(qty).toNumber() };
+		const g1 = { group_subtotal: gSub.toNumber() };
+		const g2 = { group_discount: gDisc.toNumber() };
+		const g3 = { group_tax_total: gTax.toNumber() };
+		const g4 = { group_total: gTot.toNumber() };
+		const p1 = {
+			...u1,
+			...u2,
+			...u3,
+			...u4
+		};
+		return {
+			...line,
+			...p1,
+			...g1,
+			...g2,
+			...g3,
+			...g4
+		};
+	});
+};
+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() };
+	return {
+		...line,
+		...u1,
+		...u2,
+		...u3,
+		...g1,
+		...g2,
+		...g3
+	};
+};
+/**
+* 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.
+*/
+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 b2 = id ? { target_id: id } : {};
+		const b3 = {
+			action,
+			discount_amount: discount.toNumber()
+		};
+		const b4 = {
+			before,
+			after: snapshot(roots, 1)
+		};
+		let b5 = {};
+		if (root) b5 = {
+			target_before: targetBefore,
+			target_after: snapshot([root], root.quantity)
+		};
+		return {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5
+		};
+	});
+	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
+	};
+};
+/** 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);
+	return {
+		lines,
+		redemption_steps,
+		totals: recomputeTotals(lines, currency)
+	};
+};
+//#endregion
+//#region src/order/tenders.ts
+/** Catalog provider of `REDEMPTION` payments (§3.3). */
+const DEFAULT_REDEMPTION_PROVIDER = "firespark";
+/**
+* Digital tender the SDK charges (`DEVICE`, §7.3). `KIOSK`, `COUNTER`,
+* `DOOR` and `OTHER` are in person: the POS, an operator or the courier
+* collects them (§12).
+*/
+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);
+};
+/**
+* Trims payment redeems in application order so their sum fits the cap;
+* points shrink in proportion. 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 ratio = amount > 0 ? fits / amount : 0;
+		const points = roundTo((item.points ?? 0) * ratio, 0);
+		return [{
+			...item,
+			amount: fits,
+			points
+		}];
+	});
+};
+/** One REDEMPTION tender per payment redeem of the order (D15, D19). */
+const redemptionTenderInputs = (redeem, providers = /* @__PURE__ */ new Map()) => {
+	return redeem.filter(isPaymentRedeem).map((item) => {
+		const payment_id = item.payment_id;
+		const fallback = DEFAULT_REDEMPTION_PROVIDER;
+		const provider = providers.get(payment_id) ?? fallback;
+		const program = item.program ?? item.reward_id;
+		const d1 = {
+			method: "REDEMPTION",
+			reward_id: item.reward_id
+		};
+		const d2 = {
+			program,
+			points: item.points ?? 0
+		};
+		const details = {
+			...d1,
+			...d2,
+			points_value: item.amount ?? 0
+		};
+		const t1 = {
+			method: "REDEMPTION",
+			provider,
+			payment_id
+		};
+		const t2 = {
+			collect_at: "OTHER",
+			allocation: null,
+			details
+		};
+		return {
+			...t1,
+			...t2
+		};
+	});
+};
+/** The one real tender of the simple flow (`allocation: null`). */
+const simpleTenderInput = (payment) => {
+	if (!payment.type || !payment.provider) return null;
+	if (!isRealPaymentMethod(payment.type)) return null;
+	const collect_at = payment.collect_at ?? "DEVICE";
+	const t1 = {
+		method: payment.type,
+		provider: payment.provider
+	};
+	const t2 = {
+		payment_id: payment.id,
+		collect_at,
+		allocation: null
+	};
+	return {
+		...t1,
+		...t2
+	};
+};
+/**
+* Charge order of §6.1: deferred capture (authorize only), immediate
+* capture reversible with cancel/refund, manual reversal only, then cash /
+* IDLE last.
+*/
+const chargeRank = (tender, adapter) => {
+	if (tender.method === "CASH") return 3;
+	if (adapter.capabilities?.deferredCapture) return 0;
+	if (adapter.cancel || adapter.refund) return 1;
+	return 2;
+};
+//#endregion
+//#region src/order/payments/orchestrator.ts
+const AMBIGUOUS_QUERIES = 3;
+const defaultSleep = (ms, signal) => {
+	return new Promise((resolve) => {
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			resolve();
+		});
+	});
+};
+const defaultClock = {
+	now: () => Date.now(),
+	sleep: defaultSleep
+};
+var TimeoutSignal = class extends Error {};
+/**
+* Provider deadline that pauses while the customer is answering `ctx.ui`;
+* user waits run on `interaction_timeout_ms` instead.
+*/
+const createDeadline = (timeoutMs, onExpire) => {
+	let remaining = timeoutMs;
+	let startedAt = 0;
+	let timer = null;
+	let paused = 0;
+	const run = () => {
+		startedAt = Date.now();
+		timer = setTimeout(onExpire, Math.max(remaining, 0));
+	};
+	const stop = () => {
+		if (!timer) return;
+		clearTimeout(timer);
+		timer = null;
+		remaining -= Date.now() - startedAt;
+	};
+	return {
+		start: run,
+		pause: () => {
+			if (paused === 0) stop();
+			paused += 1;
+		},
+		resume: () => {
+			paused -= 1;
+			if (paused === 0) run();
+		},
+		clear: stop
+	};
+};
+const withUserTimeout = (promise, ms) => {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			reject(new PaymentUserTimeout());
+		}, ms);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+};
+var PaymentUserTimeout = class extends Error {};
+const timedUI = (ui, deadline, interactionMs) => {
+	const wrap = (call) => {
+		deadline.pause();
+		return withUserTimeout(call(), interactionMs).finally(() => deadline.resume());
+	};
+	return {
+		message: (input) => ui.message(input),
+		action: (input) => ui.action(input),
+		select: (input) => {
+			return wrap(() => ui.select(input));
+		},
+		input: (input) => wrap(() => ui.input(input)),
+		confirm: (input) => wrap(() => ui.confirm(input))
+	};
+};
+/** Runs one adapter call with the provider timeout and the user clock. */
+const runTimed = async (ctx, call) => {
+	const controller = new AbortController();
+	const parent = ctx.signal;
+	const abort = () => controller.abort();
+	parent.addEventListener("abort", abort);
+	let expire = () => void 0;
+	const expired = new Promise((_, reject) => {
+		expire = () => {
+			controller.abort();
+			reject(new TimeoutSignal());
+		};
+	});
+	const deadline = createDeadline(ctx.policy.timeout_ms, () => expire());
+	const interaction = ctx.policy.interaction_timeout_ms;
+	const ui = timedUI(ctx.ui, deadline, interaction);
+	const scoped = {
+		...ctx,
+		ui,
+		signal: controller.signal
+	};
+	deadline.start();
+	try {
+		return await Promise.race([call(scoped), expired]);
+	} finally {
+		deadline.clear();
+		parent.removeEventListener("abort", abort);
+	}
+};
+const failed = (ctx, error, extra = {}) => {
+	const metadata = {
+		attempt_reference: ctx.attemptReference,
+		error,
+		...extra
+	};
+	return {
+		status: "FAILED",
+		amount: ctx.amount.value,
+		metadata,
+		error
+	};
+};
+const errorOf = (ctx, error, startedAt, clock) => {
+	const elapsed_ms = clock.now() - startedAt;
+	const attempt = ctx.attempt;
+	if (isPaymentError(error)) return {
+		...error.error,
+		attempt,
+		elapsed_ms
+	};
+	let code = "UNKNOWN";
+	if (error instanceof TimeoutSignal) code = "TIMEOUT";
+	if (error instanceof PaymentUserTimeout) code = "USER_TIMEOUT";
+	const extra = {
+		attempt,
+		elapsed_ms,
+		provider_message: error instanceof Error ? error.message : null
+	};
+	return createPaymentError(code, extra);
+};
+/** `start` that timed out after leaving the device is ambiguous. */
+const startError = (error) => {
+	if (error.code !== "TIMEOUT") return error;
+	return createPaymentError("AMBIGUOUS", {
+		attempt: error.attempt,
+		elapsed_ms: error.elapsed_ms
+	});
+};
+const isFinal = (result) => result.status !== "PENDING";
+const callOperation = async (ctx, operation, result, clock) => {
+	const startedAt = clock.now();
+	try {
+		return await runTimed(ctx, (scoped) => operation(scoped, result));
+	} catch (error) {
+		return failed(ctx, errorOf(ctx, error, startedAt, clock));
+	}
+};
+/** Query up to 3 times, cancel once, else FAILED + needs_review. */
+const resolveAmbiguous = async (adapter, ctx, pending, clock) => {
+	if (adapter.query) for (let i = 0; i < AMBIGUOUS_QUERIES; i += 1) {
+		await clock.sleep(ctx.policy.poll_interval_ms, ctx.signal);
+		const next = await callOperation(ctx, adapter.query, pending, clock);
+		if (next.status === "PAID") return next;
+		const definitive = next.error?.code !== "TIMEOUT" && !next.error?.retryable;
 		if (next.status === "FAILED" && definitive && next.error?.code !== "AMBIGUOUS") return next;
 	}
 	if (adapter.cancel) {
@@ -3676,13 +4274,20 @@ const record = (value) => {
 	if (!value || typeof value !== "object") return {};
 	return value;
 };
-/** PAID plus PENDING with `confirm_after_inject`, in the order currency. */
+const isPendingConfirm = (tender) => {
+	const confirm = record(tender.metadata).confirm_after_inject === true;
+	return tender.status === "PENDING" && confirm;
+};
+/** Live tenders of the current intent that hold the customer's money. */
+const chargedTenders = (intents) => {
+	return liveTenders(currentIntent(intents)).filter((tender) => {
+		return isTenderSettled(tender) || isPendingConfirm(tender);
+	});
+};
+/** Settled tenders plus PENDING `confirm_after_inject`, order currency. */
 const coveredAmount = (intents) => {
-	return intents.reduce((sum, intent) => {
-		const confirm = record(intent.metadata).confirm_after_inject === true;
-		const pendingConfirm = intent.status === "PENDING" && confirm;
-		if (intent.status !== "PAID" && !pendingConfirm) return sum;
-		return sum + intent.totals.total;
+	return chargedTenders(intents).reduce((sum, tender) => {
+		return sum + tender.amount.total;
 	}, 0);
 };
 const remainingAmount = (order) => {
@@ -3699,6 +4304,16 @@ const withOrderAmount = (result, amount) => {
 		amount
 	};
 };
+const partialOf = (result) => {
+	return record(result.metadata).partial_approval !== void 0;
+};
+/** D31: PAID for less than the tender (same currency only). */
+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;
+};
 const toFailure = (error) => {
 	const message = error instanceof Error ? error.message : "Terminal failed";
 	return {
@@ -3875,87 +4490,131 @@ var PaymentSession = class {
 		if (payment.method.method === "CASH") return this.options.cashCollectAt ?? "DOOR";
 		return this.options.collectAt ?? "DEVICE";
 	}
-	toIntent(payment, result, placedAt) {
-		const totals = {
-			...this.deps.getOrder().totals,
-			total: result.amount
-		};
-		const resolved_at = result.status !== "PENDING" && result.status !== "IDLE" ? (/* @__PURE__ */ new Date()).toISOString() : void 0;
-		const message = result.error?.message;
+	/** `collect_at` of a new tender: cash in person, the rest digital. */
+	tenderCollectAt(payment) {
+		if (payment.method.method === "CASH") return this.options.cashCollectAt ?? "DOOR";
+		return "DEVICE";
+	}
+	toRecord(tender, result) {
+		const metadata = { ...result.metadata };
+		const failure = result.error?.message;
+		const message = partialOf(result) ? PARTIAL_APPROVAL_ERROR : failure;
 		const b1 = {
-			payment_id: payment.id,
-			method: payment.method.method
-		};
-		const b2 = { provider: payment.provider.provider_id };
-		const b3 = {
-			collect_at: this.collectAt(payment),
-			status: result.status
-		};
-		const b4 = {
-			totals,
-			placed_at: placedAt,
-			resolved_at
-		};
-		const b5 = {
-			metadata: { ...result.metadata },
-			error_message: message
+			tender_id: tender.id,
+			status: result.status,
+			metadata
 		};
+		const b2 = { attempt_reference: tender.attempt_reference };
+		const b3 = result.details ? { details: result.details } : {};
 		return {
 			...b1,
 			...b2,
 			...b3,
-			...b4,
-			...b5
+			error_message: message
 		};
 	}
-	async recordResult(payment, result, placedAt) {
+	async recordResult(tender, result) {
 		const order = this.deps.getOrder();
-		const intent = this.toIntent(payment, result, placedAt);
+		const input = this.toRecord(tender, result);
 		const http = this.deps.http;
-		const p1 = [
-			order.id,
-			{ intent },
-			http
-		];
-		const next = await services.orders.recordPayment(...p1);
+		const next = await services.orders.recordPayment(order.id, input, http);
 		this.deps.applyOrder(next);
 	}
-	/**
-	* Charges `payment`: places the order with a PENDING intent if needed,
-	* runs the adapter with the merchant policy and records every result.
-	*/
-	async pay(payment, options = {}) {
-		const adapter = this.adapterFor(payment);
-		if (!adapter) {
-			const id = payment.id;
-			throw new Error(`No payment adapter installed for payment ${id}`);
-		}
+	registerPayment(payment) {
 		this.payments.set(payment.id, payment);
+	}
+	/** Merchant payments the intent tenders point to (`payment_id`). */
+	registerPayments(payments) {
+		payments.forEach((payment) => this.registerPayment(payment));
+	}
+	intentTenders() {
+		return liveTenders(currentIntent(this.deps.getOrder().payment_intents));
+	}
+	/** Adapter + payment of a device-charged real tender, or why not. */
+	chargerFor(tender) {
+		const id = tender.payment_id;
+		const payment = id ? this.payments.get(id) : void 0;
+		if (!payment) throw new Error(`Unknown payment ${id ?? "(none)"}`);
+		const adapter = this.adapterFor(payment);
+		if (!adapter) throw new Error(`No payment adapter installed for payment ${id}`);
 		const missing = this.missingFields(payment);
 		if (missing.length > 0) {
 			const keys = missing.map((field) => field.key).join(", ");
-			const id = payment.id;
 			throw new Error(`Payment ${id} is missing device fields: ${keys}`);
 		}
-		const remaining = this.remaining();
-		const amount = Math.min(options.amount ?? remaining, remaining);
-		if (amount <= 0) throw new Error("Order is already covered");
-		const attemptReference = createAttemptReference();
-		const placedAt = (/* @__PURE__ */ new Date()).toISOString();
-		const pending = {
-			status: payment.method.method === "CASH" ? "IDLE" : "PENDING",
-			amount: isPlaced(this.deps.getOrder()) ? amount : remaining,
-			metadata: { attempt_reference: attemptReference }
+		return {
+			payment,
+			adapter
 		};
-		const order = this.deps.getOrder();
-		if (!isPlaced(order)) {
-			const intent = this.toIntent(payment, pending, placedAt);
-			const p1 = {
-				id: payment.id,
-				intents: [intent]
+	}
+	/** Real tenders this device still has to charge, in §6.1 order. */
+	pendingCharges() {
+		return this.intentTenders().filter((tender) => {
+			if (!isRealPaymentMethod(tender.method)) return false;
+			if (!isDeviceCharged(tender)) return false;
+			return tender.status === "IDLE" || tender.status === "FAILED";
+		}).map((tender) => {
+			const charger = this.chargerFor(tender);
+			return {
+				tender,
+				...charger,
+				rank: chargeRank(tender, charger.adapter)
 			};
-			await this.deps.placeOrder({ payment: p1 });
-		} else await this.recordResult(payment, pending, placedAt);
+		}).toSorted((a, b) => {
+			if (a.rank !== b.rank) return a.rank - b.rank;
+			return a.tender.sequence - b.tender.sequence;
+		});
+	}
+	/** A FAILED tender is retried with a new `attempt_reference` (D25). */
+	withNewAttempt(tender) {
+		if (tender.status !== "FAILED") return tender;
+		const b1 = {
+			attempt_reference: createAttemptReference(),
+			previous_attempt_references: [...tender.previous_attempt_references, tender.attempt_reference]
+		};
+		return {
+			...tender,
+			...b1
+		};
+	}
+	/** D31: the provider approved less than the tender; void it, FAILED. */
+	async rejectPartial(adapter, ctx, result, tender) {
+		const voided = adapter.cancel ? await adapter.cancel(ctx, result).catch(() => null) : null;
+		const error = createPaymentError("INSUFFICIENT_FUNDS", { provider_message: `Approved ${result.amount}` });
+		const needs_review = voided?.status !== "CANCELLED";
+		const partial_approval = { approved_amount: result.amount };
+		const metadata = {
+			...result.metadata,
+			error,
+			needs_review,
+			partial_approval
+		};
+		return {
+			status: "FAILED",
+			amount: tender.amount.total,
+			metadata,
+			error
+		};
+	}
+	async chargeTender(current, charger, options) {
+		const { payment, adapter } = charger;
+		const tender = this.withNewAttempt(current);
+		const emit = options.onProgress ?? (() => void 0);
+		await emit({
+			type: "tender_started",
+			tender
+		});
+		const amount = tender.amount.total;
+		const attemptReference = tender.attempt_reference;
+		const metadata = { attempt_reference: attemptReference };
+		if (!(payment.method.method === "CASH") && tender.status !== "PENDING") {
+			const pending = {
+				status: "PENDING",
+				amount,
+				metadata
+			};
+			await this.recordResult(tender, pending);
+		}
 		const controller = new AbortController();
 		const abort = () => controller.abort();
 		options.signal?.addEventListener("abort", abort);
@@ -3968,66 +4627,171 @@ var PaymentSession = class {
 			];
 			const ctx = await this.buildContext(...a1);
 			const onProgress = async (progress) => {
-				await options.onProgress?.(progress);
+				await emit({
+					type: "tender_pending",
+					tender,
+					result: progress
+				});
 				if (progress.status !== "PENDING") return;
-				await this.recordResult(payment, progress, placedAt);
+				await this.recordResult(tender, progress);
 			};
 			const attempt = await runPaymentAttempt(adapter, ctx, {
 				...this.deps.runOptions,
 				onProgress
 			});
-			const result = withOrderAmount(attempt, amount);
-			if (result.status !== "IDLE") await this.recordResult(payment, result, placedAt);
+			let result = withOrderAmount(attempt, amount);
+			if (isPartialApproval(result, tender, ctx)) result = await this.rejectPartial(adapter, ctx, result, tender);
+			if (result.status !== "IDLE") await this.recordResult(tender, result);
+			const type = result.status === "FAILED" ? "tender_failed" : "tender_paid";
+			if (result.status !== "IDLE") await emit({
+				type,
+				tender,
+				result
+			});
 			return result;
 		} finally {
 			options.signal?.removeEventListener("abort", abort);
 		}
 	}
-	intentResult(intent) {
-		const metadata = record(intent.metadata);
+	outcome(results, failed) {
+		const order = this.deps.getOrder();
+		const tenders = liveTenders(currentIntent(order.payment_intents));
+		const s1 = {
+			order,
+			results,
+			needsReview: tenders.some((tender) => {
+				return record(tender.metadata).needs_review === true;
+			})
+		};
+		if (failed) return {
+			status: "FAILED",
+			...s1,
+			...failed
+		};
+		return {
+			status: tenders.every((tender) => isTenderSettled(tender)) ? "PAID" : "PENDING",
+			...s1
+		};
+	}
+	/** Charges every device tender left, stopping at the first failure. */
+	async chargeRemaining(options) {
+		const results = [];
+		for (const next of this.pendingCharges()) {
+			const tender = this.intentTenders().find((t) => t.id === next.tender.id);
+			if (!tender) continue;
+			const result = await this.chargeTender(tender, next, options);
+			results.push(result);
+			if (result.status !== "FAILED") continue;
+			const failed = this.intentTenders().find((t) => t.id === tender.id);
+			return this.outcome(results, {
+				tender: failed ?? tender,
+				result
+			});
+		}
+		return this.outcome(results);
+	}
+	/**
+	* Places the order (simple flow: `payment` becomes the one real tender)
+	* and charges the real device tenders in sequence (§6.1). A failure
+	* stops here with the order frozen: `retryTender`, `replaceTender` or
+	* cancel and refund. In-person tenders are never charged here.
+	*/
+	async payIntent(options = {}) {
+		const { payment } = options;
+		if (payment) this.registerPayment(payment);
+		if (!isPlaced(this.deps.getOrder())) {
+			if (payment) this.chargerFor({ payment_id: payment.id });
+			const p1 = payment ? this.placePayment(payment) : void 0;
+			await this.deps.placeOrder(p1 ? { payment: p1 } : {});
+		}
+		return this.chargeRemaining(options);
+	}
+	/** Charges a FAILED tender again with a new `attempt_reference`. */
+	async retryTender(tenderId, options = {}) {
+		const tender = this.intentTenders().find((item) => item.id === tenderId);
+		if (!tender) throw new Error(`Unknown tender ${tenderId}`);
+		if (tender.status !== "FAILED") throw new Error(`Only a FAILED tender can be retried (${tender.status})`);
+		return this.chargeRemaining(options);
+	}
+	/**
+	* Changes the method of a FAILED tender (same allocation and amount);
+	* then `payIntent()` / `retryTender` charges the new tender.
+	*/
+	async replaceTender(tenderId, payment, collectAt) {
+		this.registerPayment(payment);
+		const order = this.deps.getOrder();
+		const method = payment.method.method;
+		const provider = payment.provider.provider_id;
+		const collect_at = collectAt ?? this.tenderCollectAt(payment);
+		const body = {
+			method,
+			payment_id: payment.id,
+			provider,
+			collect_at
+		};
+		const http = this.deps.http;
+		const replace = services.orders.replaceTender;
+		const next = await replace(order.id, tenderId, body, http);
+		this.deps.applyOrder(next);
+		return next;
+	}
+	/** `PlaceOrderInput.payment` of the simple flow for `payment`. */
+	placePayment(payment) {
+		const type = payment.method.method;
+		const provider = payment.provider.provider_id;
+		const collect_at = this.tenderCollectAt(payment);
+		return {
+			id: payment.id,
+			type,
+			provider,
+			collect_at
+		};
+	}
+	tenderResult(tender) {
+		const metadata = record(tender.metadata);
 		const error = metadata.error;
+		const attempt_reference = tender.attempt_reference;
+		const m1 = {
+			...metadata,
+			attempt_reference
+		};
 		return {
-			status: intent.status,
-			amount: intent.totals.total,
-			metadata,
+			status: tender.status,
+			amount: tender.amount.total,
+			metadata: m1,
 			...error ? { error } : {}
 		};
 	}
-	async contextFor(intent) {
-		const payment = intent.payment_id ? this.payments.get(intent.payment_id) : null;
+	async contextFor(tender) {
+		const payment = tender.payment_id ? this.payments.get(tender.payment_id) : null;
 		if (!payment) return null;
 		const adapter = this.adapterFor(payment);
 		if (!adapter) return null;
-		const result = this.intentResult(intent);
-		const reference = result.metadata.attempt_reference;
-		if (!reference) return null;
+		const result = this.tenderResult(tender);
+		const reference = tender.attempt_reference;
 		const signal = new AbortController().signal;
 		const a1 = [
 			payment,
-			intent.totals.total,
+			tender.amount.total,
 			reference,
 			signal
 		];
 		return {
-			payment,
 			adapter,
 			result,
-			ctx: await this.buildContext(...a1),
-			placedAt: intent.placed_at
+			ctx: await this.buildContext(...a1)
 		};
 	}
 	/** After the order is injected: confirm PENDING `confirm_after_inject`. */
 	async confirmAfterInject() {
 		const intents = this.deps.getOrder().payment_intents;
+		const tenders = liveTenders(currentIntent(intents));
 		const results = [];
-		for (const intent of intents) {
-			const metadata = record(intent.metadata);
-			if (intent.status !== "PENDING") continue;
-			if (metadata.confirm_after_inject !== true) continue;
-			const found = await this.contextFor(intent);
+		for (const tender of tenders.filter(isPendingConfirm)) {
+			const found = await this.contextFor(tender);
 			const confirm = found?.adapter.confirm;
 			if (!found || !confirm) continue;
-			const { payment, result, ctx, placedAt } = found;
+			const { result, ctx } = found;
 			const confirmed = await confirm(ctx, result).catch((error) => {
 				const err = createPaymentError("UNKNOWN", { provider_message: error instanceof Error ? error.message : null });
 				const m1 = {
@@ -4046,27 +4810,31 @@ var PaymentSession = class {
 				metadata: { ...confirmed.metadata }
 			};
 			delete next.metadata.confirm_after_inject;
-			await this.recordResult(payment, next, placedAt);
+			await this.recordResult(tender, next);
 			results.push(next);
 		}
 		return results;
 	}
 	/**
-	* Undo charges of this order (injection failed or split payment
-	* abandoned): cancel, refund or flag for manual reversal.
+	* Undo the device charges of this order (injection failed, or the
+	* customer chose "cancel and refund"): cancel, refund or flag for manual
+	* reversal. REDEMPTION reserves are released by the server on cancel.
 	*/
-	async reverseAll() {
+	async reverseAll(options = {}) {
 		const intents = this.deps.getOrder().payment_intents;
 		const outcomes = [];
-		for (const intent of intents) {
-			const confirm = record(intent.metadata).confirm_after_inject === true;
-			if (!(intent.status === "PAID" || confirm) || intent.status === "IDLE") continue;
-			const found = await this.contextFor(intent);
+		for (const tender of chargedTenders(intents)) {
+			if (tender.status === "IDLE") continue;
+			const found = await this.contextFor(tender);
 			if (!found) continue;
-			const { payment, adapter, result, ctx, placedAt } = found;
+			await options.onProgress?.({
+				type: "reversing",
+				tender
+			});
+			const { adapter, result, ctx } = found;
 			const outcome = await reversePayment(adapter, ctx, result);
-			const reversed = withOrderAmount(outcome.result, intent.totals.total);
-			await this.recordResult(payment, reversed, placedAt);
+			const reversed = withOrderAmount(outcome.result, tender.amount.total);
+			await this.recordResult(tender, reversed);
 			outcomes.push(outcome);
 		}
 		return outcomes;
@@ -4166,409 +4934,129 @@ const getOpenPeriodAt = (periods, now) => {
 	if (periods.length === 0) return null;
 	const coveringSpecific = periods.filter((period) => {
 		return periodCoversDate(period, now);
-	});
-	const fallback = periods.filter((period) => !hasSpecificDates(period));
-	const specificOpens = coveringSpecific.filter((period) => !period.closed);
-	if (coveringSpecific.filter((period) => period.closed).some((period) => isClosedAt(period, now))) return null;
-	if (specificOpens.length > 0) return specificOpens.find((period) => isOpenAt(period, now)) ?? null;
-	if (fallback.some((period) => isClosedAt(period, now))) return null;
-	return fallback.filter((period) => !period.closed).find((period) => isOpenAt(period, now)) ?? null;
-};
-const atTimeOnDate = (day, time) => {
-	const [hours = "0", minutes = "0"] = time.split(":");
-	const next = new Date(day);
-	next.setHours(Number(hours), Number(minutes), 0, 0);
-	return next;
-};
-const isWithinPeriodDates = (period, instantMs) => {
-	if (!hasSpecificDates(period)) return true;
-	const startMs = Date.parse(period.start_date);
-	const endMs = Date.parse(period.end_date);
-	if (Number.isNaN(startMs) || Number.isNaN(endMs)) return false;
-	return startMs <= instantMs && instantMs <= endMs;
-};
-const dayPeriods = (schedule, instant) => {
-	const day = DAY_OF_WEEK[instant.getDay()];
-	if (!day) return [];
-	return schedule.find((row) => row.day_of_week === day)?.periods ?? [];
-};
-const getActiveUntil = (periods, now) => {
-	const open = getOpenPeriodAt(periods, now);
-	if (!open?.end_time) return null;
-	let untilMs = atTimeOnDate(now, open.end_time).getTime();
-	const openIsSpecific = hasSpecificDates(open);
-	for (const period of periods) {
-		if (!period.closed || !period.start_time) continue;
-		const closeMs = atTimeOnDate(now, period.start_time).getTime();
-		if (closeMs <= now.getTime() || closeMs >= untilMs) continue;
-		if (!isWithinPeriodDates(period, closeMs)) continue;
-		if (!hasSpecificDates(period) && openIsSpecific) continue;
-		untilMs = closeMs;
-	}
-	return new Date(untilMs);
-};
-const getNextStart = (schedule, now) => {
-	const nowMs = now.getTime();
-	let nextStartMs = null;
-	const consider = (candidate, periods) => {
-		const startMs = candidate.getTime();
-		if (startMs <= nowMs) return;
-		if (!isPeriodsActiveAt(periods, candidate)) return;
-		if (nextStartMs === null || startMs < nextStartMs) nextStartMs = startMs;
-	};
-	for (let dayOffset = 0; dayOffset < 8; dayOffset += 1) {
-		const candidateDate = new Date(now);
-		candidateDate.setDate(candidateDate.getDate() + dayOffset);
-		candidateDate.setSeconds(0, 0);
-		const periods = dayPeriods(schedule, candidateDate);
-		if (periods.length === 0) continue;
-		for (const period of periods) {
-			if (period.closed || !period.start_time) continue;
-			const start = atTimeOnDate(candidateDate, period.start_time);
-			if (!isWithinPeriodDates(period, start.getTime())) continue;
-			consider(start, periods);
-		}
-		for (const period of periods) {
-			if (!period.closed || !period.end_time) continue;
-			const reopen = atTimeOnDate(candidateDate, period.end_time);
-			if (!isWithinPeriodDates(period, reopen.getTime())) continue;
-			consider(reopen, periods);
-		}
-	}
-	return nextStartMs === null ? null : new Date(nextStartMs);
-};
-/** Whether `schedule` is in hours now, and until / next open. */
-const getScheduleWindow = (schedule, now = /* @__PURE__ */ new Date()) => {
-	if (schedule == null) return {
-		active: true,
-		until: null
-	};
-	const periods = dayPeriods(schedule, now);
-	if (isPeriodsActiveAt(periods, now)) return {
-		active: true,
-		until: getActiveUntil(periods, now)
-	};
-	return {
-		active: false,
-		next: getNextStart(schedule, now)
-	};
-};
-const isOnSchedule = (schedule, now) => {
-	return getScheduleWindow(schedule, now).active;
-};
-//#endregion
-//#region src/order/recommendations.ts
-const DEFAULT_RECOMMENDATION_TYPES = ["CROSS_SELL"];
-const linkedRecommendationIds = (pricing) => {
-	return [...pricing.recommendations_ids ?? [], ...(pricing.recommendations ?? []).map((link) => link.recommendation_id)];
-};
-const collectRecommendations = (config) => {
-	const { lines, lookup, quantity, types } = config;
-	if (quantity <= 0) return [];
-	const typeSet = new Set(types ?? DEFAULT_RECOMMENDATION_TYPES);
-	const roots = lines.filter((line) => line.parent_uid == null);
-	const fingerprints = roots.map((root) => computeLineFingerprint(root, lines));
-	const cartKeys = new Set(fingerprints);
-	const seenTargetIds = /* @__PURE__ */ new Set();
-	const products = [];
-	for (const root of roots) {
-		const source = lookup.productsById[root.id];
-		if (!source) continue;
-		for (const recommendationId of linkedRecommendationIds(source.pricing)) {
-			const recommendation = lookup.recommendationsById[recommendationId];
-			if (!recommendation || !typeSet.has(recommendation.type)) continue;
-			const targetId = recommendation.target_product_id;
-			if (seenTargetIds.has(targetId)) continue;
-			if (cartKeys.has(bareProductFingerprint(targetId))) continue;
-			const target = lookup.productsById[targetId];
-			if (!target || target.status !== "ACTIVE") continue;
-			if (!isOnSchedule(target.availability.schedules)) continue;
-			seenTargetIds.add(targetId);
-			products.push(target);
-			if (products.length >= quantity) return products;
-		}
-	}
-	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";
-/** Same rules as `vOrders.redeem()`; throws on invalid input. */
-const buildRedeem = (input) => {
-	const { reward_id, quantity, discount_rate, discount_amount } = input;
-	const { expires_at } = input;
-	if (!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 (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");
-	if (expires_at !== void 0 && Number.isNaN(Date.parse(expires_at))) throw new Error("Redeem expires_at must be an ISO datetime");
-	const redeem = {
-		reward_id,
-		quantity
-	};
-	if (discount_rate !== void 0) redeem.discount_rate = discount_rate;
-	if (discount_amount !== void 0) redeem.discount_amount = discount_amount;
-	if (expires_at !== void 0) redeem.expires_at = expires_at;
-	return redeem;
-};
-/**
-* 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.
-*/
-const subtractRedeem = (items, reward_id, quantity) => {
-	if (!Number.isInteger(quantity) || quantity < 1) throw new Error("Redeem quantity must be an integer ≥ 1");
-	let pending = quantity;
-	const kept = [];
-	for (let i = items.length - 1; i >= 0; i--) {
-		const item = items[i];
-		if (pending === 0 || item.reward_id !== reward_id) {
-			kept.unshift(item);
-			continue;
-		}
-		const taken = Math.min(item.quantity, pending);
-		pending -= taken;
-		const rest = item.quantity - taken;
-		if (rest > 0) kept.unshift({
-			...item,
-			quantity: rest
-		});
-	}
-	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. */
-const redeemPools = (lines, redeem) => {
-	const pools = /* @__PURE__ */ new Map();
-	for (const line of lines) {
-		const items = 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 = redeem.map((item) => ({
-		...order,
-		redeem: item
-	}));
-	pools.set(ORDER_KEY, pool);
-	return pools;
+	});
+	const fallback = periods.filter((period) => !hasSpecificDates(period));
+	const specificOpens = coveringSpecific.filter((period) => !period.closed);
+	if (coveringSpecific.filter((period) => period.closed).some((period) => isClosedAt(period, now))) return null;
+	if (specificOpens.length > 0) return specificOpens.find((period) => isOpenAt(period, now)) ?? null;
+	if (fallback.some((period) => isClosedAt(period, now))) return null;
+	return fallback.filter((period) => !period.closed).find((period) => isOpenAt(period, now)) ?? null;
 };
-/**
-* 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).
-*/
-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 atTimeOnDate = (day, time) => {
+	const [hours = "0", minutes = "0"] = time.split(":");
+	const next = new Date(day);
+	next.setHours(Number(hours), Number(minutes), 0, 0);
+	return next;
 };
-const minBig = (a, b) => {
-	return a.lt(b) ? a : b;
+const isWithinPeriodDates = (period, instantMs) => {
+	if (!hasSpecificDates(period)) return true;
+	const startMs = Date.parse(period.start_date);
+	const endMs = Date.parse(period.end_date);
+	if (Number.isNaN(startMs) || Number.isNaN(endMs)) return false;
+	return startMs <= instantMs && instantMs <= endMs;
 };
-const left = (run) => {
-	return run.base.minus(run.discount);
+const dayPeriods = (schedule, instant) => {
+	const day = DAY_OF_WEEK[instant.getDay()];
+	if (!day) return [];
+	return schedule.find((row) => row.day_of_week === day)?.periods ?? [];
 };
-const rateOf = (discount, base) => {
-	if (base.lte(0)) return 0;
-	return minBig(discount.div(base), new Big(1)).toNumber();
+const getActiveUntil = (periods, now) => {
+	const open = getOpenPeriodAt(periods, now);
+	if (!open?.end_time) return null;
+	let untilMs = atTimeOnDate(now, open.end_time).getTime();
+	const openIsSpecific = hasSpecificDates(open);
+	for (const period of periods) {
+		if (!period.closed || !period.start_time) continue;
+		const closeMs = atTimeOnDate(now, period.start_time).getTime();
+		if (closeMs <= now.getTime() || closeMs >= untilMs) continue;
+		if (!isWithinPeriodDates(period, closeMs)) continue;
+		if (!hasSpecificDates(period) && openIsSpecific) continue;
+		untilMs = closeMs;
+	}
+	return new Date(untilMs);
 };
-const snapshot = (run) => {
-	const b1 = {
-		value: left(run).toNumber(),
-		quantity: run.quantity
+const getNextStart = (schedule, now) => {
+	const nowMs = now.getTime();
+	let nextStartMs = null;
+	const consider = (candidate, periods) => {
+		const startMs = candidate.getTime();
+		if (startMs <= nowMs) return;
+		if (!isPeriodsActiveAt(periods, candidate)) return;
+		if (nextStartMs === null || startMs < nextStartMs) nextStartMs = startMs;
+	};
+	for (let dayOffset = 0; dayOffset < 8; dayOffset += 1) {
+		const candidateDate = new Date(now);
+		candidateDate.setDate(candidateDate.getDate() + dayOffset);
+		candidateDate.setSeconds(0, 0);
+		const periods = dayPeriods(schedule, candidateDate);
+		if (periods.length === 0) continue;
+		for (const period of periods) {
+			if (period.closed || !period.start_time) continue;
+			const start = atTimeOnDate(candidateDate, period.start_time);
+			if (!isWithinPeriodDates(period, start.getTime())) continue;
+			consider(start, periods);
+		}
+		for (const period of periods) {
+			if (!period.closed || !period.end_time) continue;
+			const reopen = atTimeOnDate(candidateDate, period.end_time);
+			if (!isWithinPeriodDates(period, reopen.getTime())) continue;
+			consider(reopen, periods);
+		}
+	}
+	return nextStartMs === null ? null : new Date(nextStartMs);
+};
+/** Whether `schedule` is in hours now, and until / next open. */
+const getScheduleWindow = (schedule, now = /* @__PURE__ */ new Date()) => {
+	if (schedule == null) return {
+		active: true,
+		until: null
+	};
+	const periods = dayPeriods(schedule, now);
+	if (isPeriodsActiveAt(periods, now)) return {
+		active: true,
+		until: getActiveUntil(periods, now)
 	};
-	const b2 = { discount_amount: run.discount.toNumber() };
-	const b3 = { discount_rate: rateOf(run.discount, run.base) };
 	return {
-		...b1,
-		...b2,
-		...b3
+		active: false,
+		next: getNextStart(schedule, now)
 	};
 };
-/**
-* Rate compounds once per reward unit over the remaining value; amount is
-* per unit. With both, the rate discount is capped at `amount × quantity`.
-*/
-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 isOnSchedule = (schedule, now) => {
+	return getScheduleWindow(schedule, now).active;
 };
-const runningFor = (base, quantity) => {
-	return {
-		base: new Big(base),
-		discount: new Big(0),
-		quantity
-	};
+//#endregion
+//#region src/order/recommendations.ts
+const DEFAULT_RECOMMENDATION_TYPES = ["CROSS_SELL"];
+const linkedRecommendationIds = (pricing) => {
+	return [...pricing.recommendations_ids ?? [], ...(pricing.recommendations ?? []).map((link) => link.recommendation_id)];
 };
-/**
-* Replays every redeem in persisted step order over the root lines' group
-* totals. A discount never exceeds what is left on its target or the order.
-*/
-const computeRedemptionSteps = (lines, redeem, steps) => {
-	const sequence = sequenceRedeems(lines, redeem, steps);
-	if (sequence.length === 0) return [];
+const collectRecommendations = (config) => {
+	const { lines, lookup, quantity, types } = config;
+	if (quantity <= 0) return [];
+	const typeSet = new Set(types ?? DEFAULT_RECOMMENDATION_TYPES);
 	const roots = lines.filter((line) => line.parent_uid == null);
-	let orderBase = new Big(0);
-	const lineRuns = /* @__PURE__ */ new Map();
+	const fingerprints = roots.map((root) => computeLineFingerprint(root, lines));
+	const cartKeys = new Set(fingerprints);
+	const seenTargetIds = /* @__PURE__ */ new Set();
+	const products = [];
 	for (const root of roots) {
-		orderBase = orderBase.plus(root.group_total);
-		lineRuns.set(root.uid, runningFor(root.group_total, root.quantity));
-	}
-	const order = runningFor(orderBase, 1);
-	return sequence.map((item) => {
-		const line = item.target_id ? lineRuns.get(item.target_id) : void 0;
-		const before = snapshot(order);
-		const targetBefore = line ? snapshot(line) : void 0;
-		const orderLeft = left(order);
-		const targetLeft = line ? left(line) : orderLeft;
-		const raw = redeemDiscount(item.redeem, targetLeft);
-		const discount = minBig(minBig(raw, targetLeft), orderLeft);
-		order.discount = order.discount.plus(discount);
-		if (line) line.discount = line.discount.plus(discount);
-		const action = discount.gt(0) ? "UPDATE" : "READ";
-		const { reward_id, quantity } = item.redeem;
-		const b1 = {
-			reward_id,
-			reward_quantity: quantity,
-			target: item.target
-		};
-		const b2 = item.target_id ? { target_id: item.target_id } : {};
-		const b3 = {
-			action,
-			discount_amount: discount.toNumber()
-		};
-		const b4 = {
-			before,
-			after: snapshot(order)
-		};
-		let b5 = {};
-		if (line) b5 = {
-			target_before: targetBefore,
-			target_after: snapshot(line)
-		};
-		return {
-			...b1,
-			...b2,
-			...b3,
-			...b4,
-			...b5
-		};
-	});
-};
-/** Subtract redemption discounts from line-based order totals. */
-const applyRedemptionTotals = (totals, steps) => {
-	if (steps.length === 0) return totals;
-	let redeemed = new Big(0);
-	for (const step of steps) redeemed = redeemed.plus(step.discount_amount);
-	const discountTotal = new Big(totals.discount_total).plus(redeemed);
-	const subtotal = new Big(totals.subtotal);
-	const discount_rate = rateOf(discountTotal, subtotal);
-	const discount_total = discountTotal.toNumber();
-	const total = new Big(totals.total).minus(redeemed).toNumber();
-	return {
-		...totals,
-		discount_rate,
-		discount_total,
-		total
-	};
-};
-/** Steps + totals for a set of lines and redeems, keeping step order. */
-const recomputeRedemptions = (input) => {
-	const { lines, redeem, currency } = input;
-	const steps = input.redemption_steps;
-	const redemption_steps = computeRedemptionSteps(lines, redeem, steps);
-	const lineTotals = recomputeTotals(lines, currency);
-	return {
-		redemption_steps,
-		totals: applyRedemptionTotals(lineTotals, redemption_steps)
-	};
+		const source = lookup.productsById[root.id];
+		if (!source) continue;
+		for (const recommendationId of linkedRecommendationIds(source.pricing)) {
+			const recommendation = lookup.recommendationsById[recommendationId];
+			if (!recommendation || !typeSet.has(recommendation.type)) continue;
+			const targetId = recommendation.target_product_id;
+			if (seenTargetIds.has(targetId)) continue;
+			if (cartKeys.has(bareProductFingerprint(targetId))) continue;
+			const target = lookup.productsById[targetId];
+			if (!target || target.status !== "ACTIVE") continue;
+			if (!isOnSchedule(target.availability.schedules)) continue;
+			seenTargetIds.add(targetId);
+			products.push(target);
+			if (products.length >= quantity) return products;
+		}
+	}
+	return products;
 };
 //#endregion
 //#region src/order/Order.ts
@@ -4633,11 +5121,11 @@ 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 lines = structuredClone(source.lines);
+	const sourceLines = structuredClone(source.lines);
 	const is_anonymous = options.isAnonymous ?? source.is_anonymous;
 	const redeem = structuredClone(source.redeem ?? []);
-	const { redemption_steps, totals } = recomputeRedemptions({
-		lines,
+	const { lines, redemption_steps, totals } = recomputeRedemptions({
+		lines: sourceLines,
 		redeem,
 		redemption_steps: source.redemption_steps ?? [],
 		currency: source.totals.currency
@@ -4689,14 +5177,8 @@ const buildLocalDraft = (insert) => {
 	const is_anonymous = insert.is_anonymous ?? false;
 	const totals = insert.totals ?? emptyTotals();
 	const metadata = insert.metadata ?? {};
-	const payment_intents = (insert.payment_intents ?? []).map((intent) => {
-		const metadata = intent.metadata ?? {};
-		return {
-			...intent,
-			metadata
-		};
-	});
-	const payment_status = insert.payment_status ?? "IDLE";
+	const payment_intents = [];
+	const payment_status = "IDLE";
 	const b1 = {
 		uid: randomUUID(),
 		id: insert.id,
@@ -4788,6 +5270,9 @@ var Order = class Order {
 	http;
 	flush;
 	payments;
+	/** Real tenders chosen with `setTenders`; REDEMPTION ones come from redeem. */
+	realTenders = null;
+	redemptionProviders = /* @__PURE__ */ new Map();
 	constructor(config, notify) {
 		this.draft = cloneOrder(config.order);
 		this.synced = cloneOrder(config.order);
@@ -4986,12 +5471,16 @@ 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.
+	* the order in which redeems were applied. With `payment_id` (points /
+	* balance) it is not a discount: the order gets a REDEMPTION tender for
+	* it, capped at total − tip − delivery (D15, D18, D19).
 	*/
 	applyRedeem(input) {
 		if (this.deleted) return;
-		const { line_uid, ...rest } = input;
+		const { line_uid, provider, ...rest } = input;
 		const redeem = buildRedeem(rest);
+		if (isPaymentRedeem(redeem) && line_uid !== void 0) throw new Error("Points / balance redeems apply to the whole order");
+		if (redeem.payment_id && provider) this.redemptionProviders.set(redeem.payment_id, provider);
 		if (line_uid === void 0) {
 			this.commitLines({ redeem: [...this.draft.redeem ?? [], redeem] });
 			return;
@@ -5009,7 +5498,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.
+	* latest applied first. Removing more units than applied clears them all
+	* (and the REDEMPTION tender of a points / balance redeem).
 	*/
 	removeRedeem(input) {
 		if (this.deleted) return;
@@ -5153,19 +5643,72 @@ var Order = class Order {
 		};
 		await services.orders.validate(body, this.http);
 	}
+	/** Tenders of the next intent: real ones plus one per payment redeem. */
+	getTenders(payment) {
+		const simple = payment ? simpleTenderInput(payment) : null;
+		const real = simple ? [simple] : this.realTenders ?? [];
+		const redeem = this.draft.redeem ?? [];
+		const providers = this.redemptionProviders;
+		return [...real, ...redemptionTenderInputs(redeem, providers)];
+	}
+	/**
+	* Chooses the real tenders (with allocation for mixed payments) and saves
+	* the DRAFT intent; the server returns amounts per tender. REDEMPTION
+	* tenders are added from the redeems, never passed here.
+	*/
+	async setTenders(tenders) {
+		if (tenders.some((tender) => !isRealPaymentMethod(tender.method))) throw new Error("REDEMPTION tenders come from applyRedeem");
+		this.realTenders = tenders;
+		return this.syncPaymentIntent(this.getTenders());
+	}
+	/** Drops the chosen tenders and discards the DRAFT intent. */
+	async clearTenders() {
+		this.realTenders = null;
+		if (activeIntent(this.draft.payment_intents)?.status !== "DRAFT") return this.getOrder();
+		const id = this.draft.id;
+		const next = await services.orders.deletePaymentIntent(id, this.http);
+		this.applyServerOrder(next);
+		return this.getOrder();
+	}
+	async syncPaymentIntent(tenders) {
+		await this.persist();
+		await this.flush.settle();
+		const id = this.draft.id;
+		const put = services.orders.putPaymentIntent;
+		const next = await put(id, { tenders }, this.http);
+		this.applyServerOrder(next);
+		return this.getOrder();
+	}
+	applyServerOrder(next) {
+		this.draft = cloneOrder(next);
+		this.synced = cloneOrder(next);
+		this.notify();
+	}
+	/**
+	* 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).
+	*/
 	async placeOrder(input = {}) {
 		await this.persist();
 		await this.flush.settle();
 		await this.validateOrder();
+		let body = input;
+		if (!input.intent_id) {
+			const tenders = this.getTenders(input.payment);
+			const needsPayment = input.payment && !simpleTenderInput(input.payment);
+			if (tenders.length > 0 && !needsPayment) {
+				const intent = activeIntent((await this.syncPaymentIntent(tenders)).payment_intents);
+				if (intent) body = { intent_id: intent.id };
+			}
+		}
 		try {
-			await services.orders.place(this.draft.id, input, this.http);
+			await services.orders.place(this.draft.id, body, this.http);
 		} catch (error) {
 			if (!(error instanceof StorefrontHttpError) || error.status !== 409) throw error;
 		}
 		const next = await services.orders.get(this.draft.id, this.http);
-		this.draft = cloneOrder(next);
-		this.synced = cloneOrder(next);
-		this.notify();
+		this.applyServerOrder(next);
 	}
 	/** Installed `@fire-spark/payments-*` adapters (provider + method). */
 	setPaymentAdapters(adapters) {
@@ -5191,21 +5734,73 @@ var Order = class Order {
 	getMissingPaymentFields(payment) {
 		return this.payments.missingFields(payment);
 	}
-	/** Order total minus PAID (and confirm-after-inject) intents. */
+	/** Order total minus settled (and confirm-after-inject) tenders. */
 	getRemainingAmount() {
 		return this.payments.remaining();
 	}
-	/** Places the order if needed and charges `payment` (all or part). */
+	/** Merchant payments the tenders point to (`payment_id`). */
+	setPayments(payments) {
+		this.payments.registerPayments(payments);
+	}
+	/**
+	* Places the order if needed and charges its real device tenders in
+	* sequence (§6.1); stops at the first failure with the order frozen.
+	*/
+	payIntent(options) {
+		return this.payments.payIntent(options);
+	}
+	/** Charges a FAILED tender again with a new attempt reference (D25). */
+	retryTender(tenderId, options) {
+		return this.payments.retryTender(tenderId, options);
+	}
+	/** Changes the method of a FAILED tender; then `payIntent()` again. */
+	replaceTender(tenderId, payment, collectAt) {
+		return this.payments.replaceTender(tenderId, payment, collectAt);
+	}
+	/** "Cancel and refund": reverses device charges, then cancels the order. */
+	async cancelAndRefund(options) {
+		const outcomes = await this.payments.reverseAll(options);
+		await this.cancelOrder();
+		return outcomes;
+	}
+	/** Voids one tender (operator flow); idempotent per call. */
+	async voidTender(tenderId, reason) {
+		const idempotency_key = createAttemptReference();
+		const body = reason ? {
+			idempotency_key,
+			reason
+		} : { idempotency_key };
+		const id = this.draft.id;
+		const next = await services.orders.voidTender(id, tenderId, body, this.http);
+		this.applyServerOrder(next);
+		return this.getOrder();
+	}
+	/** Refunds one tender: all of it, an amount, or some units. */
+	async refundTender(tenderId, input = {}) {
+		const body = {
+			...input,
+			idempotency_key: createAttemptReference()
+		};
+		const id = this.draft.id;
+		const refund = services.orders.refundTender;
+		const next = await refund(id, tenderId, body, this.http);
+		this.applyServerOrder(next);
+		return this.getOrder();
+	}
+	/** @deprecated Use `payIntent({ payment })`. */
 	pay(payment, options) {
-		return this.payments.pay(payment, options);
+		return this.payments.payIntent({
+			...options,
+			payment
+		});
 	}
 	/** Confirms intents that waited for the order injection. */
 	confirmPaymentsAfterInject() {
 		return this.payments.confirmAfterInject();
 	}
 	/** Cancels or refunds every charge of this order (or flags it manual). */
-	reversePayments() {
-		return this.payments.reverseAll();
+	reversePayments(options) {
+		return this.payments.reverseAll(options);
 	}
 	/** Terminal admin operation (init, test, closeBatch, status, extra). */
 	runPaymentTerminal(payment, key) {
@@ -5213,14 +5808,20 @@ var Order = class Order {
 	}
 	/** Applies lines/redeem, replaying redemption steps and totals. */
 	commitLines(patch) {
-		const lines = patch.lines ?? this.draft.lines;
-		const redeem = patch.redeem ?? this.draft.redeem ?? [];
-		const { redemption_steps, totals } = recomputeRedemptions({
-			lines,
-			redeem,
-			redemption_steps: this.draft.redemption_steps ?? [],
-			currency: this.draft.totals.currency
+		const patched = patch.lines ?? this.draft.lines;
+		const applied = patch.redeem ?? this.draft.redeem ?? [];
+		const steps = this.draft.redemption_steps ?? [];
+		const currency = this.draft.totals.currency;
+		const { lines, redemption_steps, totals } = recomputeRedemptions({
+			lines: patched,
+			redeem: applied,
+			redemption_steps: steps,
+			currency
 		});
+		const redeem = clampPaymentRedeems(applied, redemptionCap({
+			lines,
+			totals
+		}), currency);
 		this.draft = {
 			...this.draft,
 			lines,
@@ -5903,9 +6504,38 @@ const validateRedemptions = (input, issues, lineIssues) => {
 		for (const issue of expired) pushLineIssue(lineIssues, line.uid, issue);
 	}
 	checkRedemptionTargets(input.lines, redeem, steps, issues, lineIssues);
-	const expected = computeRedemptionSteps(input.lines, redeem, steps);
-	compareRedemptionSteps(steps, expected, issues);
-	return expected;
+	const replayed = replayRedemptions(input.lines, redeem, steps);
+	compareRedemptionSteps(steps, replayed.redemption_steps, issues);
+	return replayed.lines;
+};
+const REDEEMED_GROUP_FIELDS = [
+	["group_discount", "DISCOUNT_MISMATCH"],
+	["unit_group_discount", "DISCOUNT_MISMATCH"],
+	["group_tax_total", "TAX_MISMATCH"],
+	["unit_group_tax_total", "TAX_MISMATCH"],
+	["group_total", "PRICE_MISMATCH"],
+	["unit_group_total", "PRICE_MISMATCH"]
+];
+/** Root group money must carry exactly the replayed redemption discounts. */
+const compareRedeemedRoots = (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) {
+			if (bigEq(line[field], wanted[field])) continue;
+			const b1 = {
+				code,
+				field,
+				expected: bigStr(wanted[field])
+			};
+			pushLineIssue(out, line.uid, {
+				...b1,
+				actual: bigStr(line[field])
+			});
+		}
+	}
 };
 /** Compare cart lines/totals against a fresh menu (exact Big.js equality). */
 const validateOrderAgainstMenu = (input) => {
@@ -5918,7 +6548,8 @@ const validateOrderAgainstMenu = (input) => {
 		lines: {}
 	};
 	if (!input.menuActive) issues.push({ code: "MENU_CLOSED" });
-	const roots = input.lines.filter((line) => line.parent_uid == null);
+	const menuLines = stripRedemptionLines(input.lines);
+	const roots = menuLines.filter((line) => line.parent_uid == null);
 	if (roots.length === 0) {
 		issues.push({ code: "EMPTY_ORDER" });
 		return {
@@ -5933,12 +6564,13 @@ const validateOrderAgainstMenu = (input) => {
 			checkFeeSelfConsistency(root, lineIssues);
 			continue;
 		}
-		validateProductRoot(root, input.lines, lookup, locale, lineIssues);
+		validateProductRoot(root, menuLines, lookup, locale, lineIssues);
 	}
 	checkRootProductQuantities(roots, lookup, lineIssues);
 	if (input.expectedFeeLines) compareExpectedFeeLines(input.lines, input.expectedFeeLines, lineIssues);
-	const expectedSteps = validateRedemptions(input, issues, lineIssues);
-	const expectedTotals = applyRedemptionTotals(recomputeTotals(input.lines, input.totals.currency), expectedSteps);
+	const redeemed = validateRedemptions(input, issues, lineIssues);
+	compareRedeemedRoots(input.lines, redeemed, lineIssues);
+	const expectedTotals = recomputeTotals(redeemed, input.totals.currency);
 	for (const field of TOTALS_FIELDS) {
 		if (bigEq(input.totals[field], expectedTotals[field])) continue;
 		issues.push({
@@ -6324,6 +6956,22 @@ const isAnonymousOrder = (condition, isAnonymous) => {
 	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) => {
@@ -6436,17 +7084,29 @@ const matchEnumOperator = (condition, 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 matchEnumOperator(condition, collectAt);
+	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 matchEnumOperator(condition, method);
+	return matchEnumSet(condition, method);
 };
 const paymentStatus = (condition, status) => {
 	const matcherType = "Payment status";
@@ -7204,6 +7864,14 @@ var RulesEngine = class {
 			if (typeof value !== "boolean") return false;
 			return orderIncludesProductWithTag$3(condition, value);
 		});
+		if (type === "Payment is mixed") {
+			const payment = this.getDependency("payment", type);
+			return paymentIsMixed(condition, payment.is_mixed);
+		}
+		if (type === "Payment captured") {
+			const payment = this.getDependency("payment", type);
+			return paymentCaptured(condition, payment.captured);
+		}
 		throw new Error(`Condition ${type} not supported in boolean matcher`);
 	};
 	assertCurrency = (condition) => {
@@ -7224,8 +7892,14 @@ var RulesEngine = class {
 		assert(primitive === "enum", primitiveError("enum"));
 		const payment = this.getDependency("payment", type);
 		switch (type) {
-			case "Payment collect at": return paymentCollectAt(condition, payment.collect_at);
-			case "Payment method": return paymentMethod(condition, payment.method);
+			case "Payment collect at": {
+				const collectAt = payment.collect_ats ?? payment.collect_at;
+				return paymentCollectAt(condition, collectAt);
+			}
+			case "Payment method": {
+				const method = payment.methods ?? payment.method;
+				return paymentMethod(condition, method);
+			}
 			case "Payment status": return paymentStatus(condition, payment.status);
 			default: throw new Error(`Condition ${type} not supported in enum matcher`);
 		}
@@ -7857,4 +8531,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, isDeviceNotLinked, isExpiryComplete, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isPosDeviceNotLinked, isPosUnauthorized, isStorefrontNotFound, isVariantBase, listMenusStream, localizePosError, log, logError, luhnCheck, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, normalizeCardholderName, parseExpiry, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, serializeError, services, setLineQuantity, storefrontJson, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, verifyWebhookSignature, visitedStates };
+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, parseExpiry, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, redemptionCap, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, serializeError, services, setLineQuantity, storefrontJson, stripRedemptionLines, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, verifyWebhookSignature, visitedStates };