@fire-spark/core 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createAttemptReference, createPaymentError, currencyDecimals, defaultReversalFor, isPaymentError, 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";
@@ -27,10 +28,37 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
+//#region src/productCustomization/clamp.utils.ts
+const clampModifierQuantity = (type, quantity, min, max) => {
+	let next = Math.max(0, Math.floor(quantity));
+	if (type === "RADIO" || type === "CHECKBOX") next = next > 0 ? 1 : 0;
+	if (next === 0) return 0;
+	let lower = min;
+	if (type === "QUANTITY") lower = 0;
+	return Math.min(max, Math.max(lower, next));
+};
+const clampProductQuantity = (quantity, min, max) => {
+	return Math.min(max, Math.max(min, Math.max(0, Math.floor(quantity))));
+};
+//#endregion
 //#region src/productCustomization/catalog.utils.ts
 const resolvePricingModifier = (product, groupId) => {
 	return product.pricing.modifiers.find((modifier) => modifier.modifier_group_id === groupId);
 };
+/** Unit price and tax of a modifier in a group. A variant base listed in the
+* group keeps the limits; the variant it resolves to sets what is charged. */
+const modifierUnitPricing = (listed, ordered, groupId) => {
+	const product = ordered ?? listed;
+	const entry = resolvePricingModifier(product, groupId);
+	const { price, tax_rate, is_tax_inclusive } = product.pricing;
+	const taxRate = entry?.tax_rate ?? tax_rate;
+	const isTaxInclusive = entry?.is_tax_inclusive ?? is_tax_inclusive;
+	return {
+		price: entry?.price ?? price,
+		taxRate,
+		isTaxInclusive
+	};
+};
 const inferControlType = (pricingModifier, group) => {
 	if (pricingModifier?.display_type) return pricingModifier.display_type;
 	const gMin = group.minimum_quantity;
@@ -65,12 +93,12 @@ const collectReferencedGroupIds = (products) => {
 	for (const product of products) for (const groupId of product.pricing.modifier_group_ids ?? []) ids.add(groupId);
 	return ids;
 };
-const inferGroupFromProducts = (groupId, modifierIds, products) => {
+const inferGroupFromProducts = (groupId, modifierIds, productsById) => {
 	let minimum_quantity = 0;
 	let maximum_quantity = 1;
 	let charge_above_quantity = null;
 	for (const modifierId of modifierIds) {
-		const entry = products.find((entry) => entry.id === modifierId)?.pricing.modifiers?.find((modifier) => modifier.modifier_group_id === groupId);
+		const entry = productsById.get(modifierId)?.pricing.modifiers?.find((modifier) => modifier.modifier_group_id === groupId);
 		if (!entry) continue;
 		minimum_quantity = Math.max(minimum_quantity, entry.minimum_quantity ?? 0);
 		maximum_quantity = Math.max(maximum_quantity, entry.maximum_quantity ?? 1);
@@ -94,26 +122,324 @@ const resolveModifierGroupsForLookup = (products, modifierGroups) => {
 	const idsByGroup = collectModifierIdsByGroupId(products);
 	const referenced = collectReferencedGroupIds(products);
 	const needed = /* @__PURE__ */ new Set([...referenced, ...idsByGroup.keys()]);
+	let productsById = null;
 	for (const groupId of needed) {
 		if (byId.has(groupId)) continue;
 		const modifierIds = idsByGroup.get(groupId) ?? [];
 		if (modifierIds.length === 0) continue;
-		byId.set(groupId, inferGroupFromProducts(groupId, modifierIds, products));
+		productsById ??= new Map(products.map((product) => [product.id, product]));
+		const args = [
+			groupId,
+			modifierIds,
+			productsById
+		];
+		byId.set(groupId, inferGroupFromProducts(...args));
 	}
 	return [...byId.values()];
 };
 //#endregion
-//#region src/productCustomization/clamp.utils.ts
-const clampModifierQuantity = (type, quantity, min, max) => {
-	let next = Math.max(0, Math.floor(quantity));
-	if (type === "RADIO" || type === "CHECKBOX") next = next > 0 ? 1 : 0;
-	if (next === 0) return 0;
-	let lower = min;
-	if (type === "QUANTITY") lower = 0;
-	return Math.min(max, Math.max(lower, next));
+//#region src/productCustomization/store.ts
+const createStore = () => {
+	return {
+		quantities: {},
+		initialQuantities: {},
+		selections: {},
+		initialSelections: {}
+	};
 };
-const clampProductQuantity = (quantity, min, max) => {
-	return Math.min(max, Math.max(min, Math.max(0, Math.floor(quantity))));
+const getQuantity = (store, path) => {
+	return store.quantities[path] ?? 0;
+};
+const setQuantity = (store, path, quantity) => {
+	if (quantity <= 0) delete store.quantities[path];
+	if (quantity <= 0) return;
+	store.quantities[path] = quantity;
+};
+const isInSubtree = (key, path) => {
+	return key === path || key.startsWith(`${path}/`);
+};
+const clearSubtree = (store, path) => {
+	for (const key of Object.keys(store.quantities)) if (isInSubtree(key, path)) delete store.quantities[key];
+	for (const key of Object.keys(store.selections)) if (isInSubtree(key, path)) delete store.selections[key];
+};
+/** True when `productId` already sits on `path` (root or any modifier), so
+* descending into it again would loop through a cyclic menu. */
+const pathVisits = (path, productId) => {
+	if (isInSubtree(path, `/${productId}`)) return true;
+	const segment = `/modifier/${productId}`;
+	return path.endsWith(segment) || path.includes(`${segment}/`);
+};
+/** Entries at or below `path`, e.g. to restore one product's subtree. */
+const pickSubtree = (entries, path) => {
+	const picked = {};
+	for (const [key, value] of Object.entries(entries)) if (isInSubtree(key, path)) picked[key] = value;
+	return picked;
+};
+const cloneQuantities = (quantities) => {
+	return { ...quantities };
+};
+const cloneSelections = (selections) => {
+	const next = {};
+	for (const [key, value] of Object.entries(selections)) next[key] = { ...value };
+	return next;
+};
+//#endregion
+//#region src/productCustomization/variants.ts
+const isSelectable = (product) => {
+	if (product.status === "INACTIVE") return false;
+	return product.availability.status !== "HIDDEN";
+};
+const isInStock = (product) => {
+	return product.availability.status !== "OUT_OF_STOCK";
+};
+const isVariantBase = (product) => {
+	return (product.pricing.variant_group_ids ?? []).length > 0;
+};
+const variantGroupsOf = (lookup, base) => {
+	const groups = [];
+	for (const groupId of base.pricing.variant_group_ids ?? []) {
+		const group = lookup.variantGroupsById?.[groupId];
+		if (group) groups.push(group);
+	}
+	return groups;
+};
+const selectionFor = (groups, entry) => {
+	const selection = {};
+	for (const group of groups) {
+		const option = group.variants.find((variant) => {
+			return entry.variant_group_option_ids.includes(variant.id);
+		});
+		if (option) selection[group.id] = option.id;
+	}
+	return selection;
+};
+/** Base selector for a product: itself when it has variant groups, else the
+* first base it resolves from (with its options preselected). */
+const resolveVariantBase = (lookup, product) => {
+	if (isVariantBase(product)) return {
+		base: product,
+		selection: {}
+	};
+	for (const entry of product.pricing.variants ?? []) {
+		const base = lookup.productsById[entry.product_id];
+		if (!base || !isVariantBase(base)) continue;
+		return {
+			base,
+			selection: selectionFor(variantGroupsOf(lookup, base), entry)
+		};
+	}
+	return null;
+};
+const variantEntryFor = (product, baseId) => {
+	return product.pricing.variants?.find((entry) => entry.product_id === baseId);
+};
+const buildVariantCandidates = (lookup, base) => {
+	const byId = /* @__PURE__ */ new Map();
+	for (const group of variantGroupsOf(lookup, base)) for (const option of group.variants) for (const productId of option.product_ids) {
+		const product = lookup.productsById[productId];
+		if (!product || !isSelectable(product)) continue;
+		if (byId.has(productId)) continue;
+		const entry = variantEntryFor(product, base.id);
+		if (!entry) continue;
+		const optionIds = new Set(entry.variant_group_option_ids);
+		byId.set(productId, {
+			product,
+			optionIds
+		});
+	}
+	return [...byId.values()];
+};
+const indexCache = /* @__PURE__ */ new WeakMap();
+const variantIndexFor = (lookup, base) => {
+	let byBase = indexCache.get(lookup);
+	if (!byBase) {
+		byBase = /* @__PURE__ */ new Map();
+		indexCache.set(lookup, byBase);
+	}
+	const cached = byBase.get(base.id);
+	if (cached) return cached;
+	const index = {
+		groups: variantGroupsOf(lookup, base),
+		candidates: buildVariantCandidates(lookup, base)
+	};
+	byBase.set(base.id, index);
+	return index;
+};
+const variantCandidates = (lookup, base) => {
+	return variantIndexFor(lookup, base).candidates;
+};
+/** Normalized selection for a base and the product it resolves to, if any. */
+const resolveVariantSelection = (lookup, base, selection) => {
+	const { groups, candidates } = variantIndexFor(lookup, base);
+	const next = normalizeSelection(groups, candidates, selection);
+	return {
+		selection: next,
+		product: findVariantProduct(groups, candidates, next)
+	};
+};
+/** Options of `base` that resolve to `product`, or null if it isn't one. */
+const selectionForVariant = (lookup, base, product) => {
+	const entry = variantEntryFor(product, base.id);
+	if (!entry) return null;
+	return selectionFor(variantIndexFor(lookup, base).groups, entry);
+};
+/** True when `product` is what `base` resolves to for its own options. */
+const resolvesFromBase = (lookup, base, product) => {
+	if (!isVariantBase(base)) return false;
+	const selection = selectionForVariant(lookup, base, product);
+	if (!selection) return false;
+	const { groups, candidates } = variantIndexFor(lookup, base);
+	return findVariantProduct(groups, candidates, selection)?.id === product.id;
+};
+/** True when some active, visible base still resolves to this product. */
+const isOfferedVariant = (lookup, product) => {
+	return (product.pricing.variants ?? []).some((entry) => {
+		const base = lookup.productsById[entry.product_id];
+		if (!base || !isSelectable(base)) return false;
+		return resolvesFromBase(lookup, base, product);
+	});
+};
+const matching = (candidates, optionIds) => {
+	return candidates.filter((candidate) => {
+		return optionIds.every((id) => candidate.optionIds.has(id));
+	});
+};
+const priorOptionIds = (groups, index, selection) => {
+	const ids = [];
+	for (const group of groups.slice(0, index)) {
+		const selected = selection[group.id];
+		if (selected) ids.push(selected);
+	}
+	return ids;
+};
+const visibleOptions = (candidates, group, prior) => {
+	return group.variants.flatMap((option) => {
+		const matches = matching(candidates, [...prior, option.id]);
+		if (matches.length === 0) return [];
+		return [{
+			option,
+			disabled: !matches.some((match) => isInStock(match.product))
+		}];
+	});
+};
+/** Drops picks no longer reachable from earlier groups and auto-picks groups
+* left with a single enabled option. Out-of-stock picks are kept so an
+* explicit variant still resolves (and reports OUT_OF_STOCK downstream). */
+const normalizeSelection = (groups, candidates, selection) => {
+	const next = {};
+	groups.forEach((group, index) => {
+		const prior = priorOptionIds(groups, index, next);
+		const visible = visibleOptions(candidates, group, prior);
+		const current = selection[group.id];
+		const kept = visible.find((entry) => entry.option.id === current);
+		if (kept) {
+			next[group.id] = kept.option.id;
+			return;
+		}
+		const enabled = visible.filter((entry) => !entry.disabled);
+		if (enabled.length === 1 && enabled[0]) next[group.id] = enabled[0].option.id;
+	});
+	return next;
+};
+const findVariantProduct = (groups, candidates, selection) => {
+	const optionIds = groups.map((group) => selection[group.id]);
+	if (optionIds.some((id) => !id)) return null;
+	const [match] = matching(candidates, optionIds);
+	return match?.product ?? null;
+};
+const buildVariantGroupCtxs = (groups, candidates, selection, onSelect, pathPrefix = "") => {
+	return groups.map((group, index) => {
+		const path = `${pathPrefix}/variant/${group.id}`;
+		const prior = priorOptionIds(groups, index, selection);
+		const selectedId = selection[group.id] ?? null;
+		const options = visibleOptions(candidates, group, prior).map((entry) => {
+			return {
+				path: `${path}/option/${entry.option.id}`,
+				data: entry.option,
+				selected: entry.option.id === selectedId,
+				disabled: entry.disabled,
+				select: () => {
+					if (!entry.disabled) onSelect(group.id, entry.option.id);
+				}
+			};
+		});
+		return {
+			path,
+			data: group,
+			selectedId,
+			status: selectedId ? "VALID" : "INCOMPLETE",
+			options
+		};
+	});
+};
+//#endregion
+//#region src/productCustomization/seed.ts
+/** Product whose modifier groups hang below a modifier path: a variant base
+* defers to the variant its stored options resolve to (auto-picks persist). */
+const customizedProduct = (store, lookup, product, path) => {
+	if (!isVariantBase(product)) return product;
+	const { selection, product: resolved } = resolveVariantSelection(...[
+		lookup,
+		product,
+		store.selections[path] ?? {}
+	]);
+	if (Object.keys(selection).length > 0) store.selections[path] = selection;
+	else delete store.selections[path];
+	return resolved ?? product;
+};
+const applyCatalogDefaults = (store, lookup, product, path) => {
+	setQuantity(store, path, product.pricing.minimum_quantity);
+	applyNestedDefaults(store, lookup, product, path);
+};
+const applyNestedDefaults = (store, lookup, product, path) => {
+	for (const groupId of product.pricing.modifier_group_ids) {
+		const group = lookup.modifierGroupsById[groupId];
+		if (!group) continue;
+		let radioDefaultApplied = false;
+		for (const modifierId of group.modifier_ids) {
+			const modifierProduct = lookup.productsById[modifierId];
+			if (!modifierProduct || pathVisits(path, modifierId)) continue;
+			const modifierPath = `${path}/group/${groupId}/modifier/${modifierId}`;
+			const pricingModifier = resolvePricingModifier(modifierProduct, groupId);
+			const defaultQuantity = pricingModifier?.default_quantity ?? 0;
+			if (defaultQuantity <= 0) continue;
+			if (inferControlType(pricingModifier, group) === "RADIO") {
+				if (radioDefaultApplied) continue;
+				radioDefaultApplied = true;
+			}
+			setQuantity(store, modifierPath, defaultQuantity);
+			applyNestedDefaults(store, lookup, customizedProduct(...[
+				store,
+				lookup,
+				modifierProduct,
+				modifierPath
+			]), modifierPath);
+		}
+	}
+};
+const applyNestedInitial = (store, lookup, product, path, quantities) => {
+	for (const groupId of product.pricing.modifier_group_ids) {
+		const group = lookup.modifierGroupsById[groupId];
+		if (!group) continue;
+		for (const modifierId of group.modifier_ids) {
+			const modifierProduct = lookup.productsById[modifierId];
+			if (!modifierProduct || pathVisits(path, modifierId)) continue;
+			const modifierPath = `${path}/group/${groupId}/modifier/${modifierId}`;
+			if (quantities[modifierPath] !== void 0) setQuantity(store, modifierPath, quantities[modifierPath]);
+			if (getQuantity(store, modifierPath) <= 0) continue;
+			const nested = customizedProduct(...[
+				store,
+				lookup,
+				modifierProduct,
+				modifierPath
+			]);
+			applyNestedInitial(store, lookup, nested, modifierPath, quantities);
+		}
+	}
+};
+const applyInitialQuantities = (store, lookup, product, path, quantities) => {
+	setQuantity(store, path, quantities[path] ?? product.pricing.minimum_quantity);
+	applyNestedInitial(store, lookup, product, path, quantities);
 };
 //#endregion
 //#region ../../node_modules/.pnpm/big.js@6.2.1/node_modules/big.js/big.mjs
@@ -541,7 +867,11 @@ const forEachBillableUnit = (group, modifiers, onUnit) => {
 	for (const modifier of modifiers) {
 		if (modifier.quantity <= 0) continue;
 		const pricingModifier = resolvePricingModifier(modifier.data, group.id);
-		const unit = new Big(pricingModifier?.price ?? modifier.data.pricing.price);
+		const unit = new Big(modifierUnitPricing(...[
+			modifier.data,
+			modifier.resolved,
+			group.id
+		]).price);
 		const modifierChargeAbove = pricingModifier?.charge_above_quantity ?? 0;
 		let remaining = billableQuantity(modifier.quantity, modifierChargeAbove);
 		while (remaining > 0) {
@@ -584,95 +914,20 @@ const computeTotalPrice = (product) => {
 	return unit.plus(mods).times(product.quantity).toNumber();
 };
 //#endregion
-//#region src/productCustomization/store.ts
-const getQuantity = (store, path) => {
-	return store.quantities[path] ?? 0;
-};
-const setQuantity = (store, path, quantity) => {
-	if (quantity <= 0) delete store.quantities[path];
-	if (quantity <= 0) return;
-	store.quantities[path] = quantity;
-};
-const clearSubtree = (store, path) => {
-	for (const key of Object.keys(store.quantities)) if (key === path || key.startsWith(`${path}/`)) delete store.quantities[key];
-};
-const cloneQuantities = (quantities) => {
-	return { ...quantities };
-};
-//#endregion
 //#region src/productCustomization/refresh.ts
-const refreshModifierFields = (modifier, group, store) => {
-	const pricingModifier = resolvePricingModifier(modifier.data, group.data.id);
-	modifier.min = pricingModifier?.minimum_quantity ?? 0;
-	modifier.max = pricingModifier?.maximum_quantity ?? group.data.maximum_quantity;
-	modifier.required = modifier.min > 0;
-	modifier.quantity = getQuantity(store, modifier.path);
-	modifier.type = inferControlType(pricingModifier, group.data);
-};
-const refreshProductTree = (product, store) => {
+const refreshProductTree = (product, runtime) => {
+	const { store, variantSyncs } = runtime;
 	product.quantity = getQuantity(store, product.path);
 	for (const group of product.groups) {
+		let selectedQuantity = 0;
 		for (const modifier of group.modifiers) {
-			refreshModifierFields(modifier, group, store);
-			if (modifier.product) {
-				modifier.product.quantity = modifier.quantity;
-				refreshProductTree(modifier.product, store);
-			}
+			modifier.quantity = getQuantity(store, modifier.path);
+			selectedQuantity += modifier.quantity;
+			variantSyncs.get(modifier)?.();
+			if (modifier.product) refreshProductTree(modifier.product, runtime);
 		}
 		computeGroupModifierLinePrices(group.data, group.modifiers);
-		group.selectedQuantity = group.modifiers.reduce((sum, modifier) => {
-			return sum + modifier.quantity;
-		}, 0);
-	}
-};
-//#endregion
-//#region src/productCustomization/seed.ts
-const applyCatalogDefaults = (store, lookup, product, path) => {
-	setQuantity(store, path, product.pricing.minimum_quantity);
-	applyNestedDefaults(store, lookup, product, path);
-};
-const applyNestedDefaults = (store, lookup, product, path) => {
-	for (const groupId of product.pricing.modifier_group_ids) {
-		const group = lookup.modifierGroupsById[groupId];
-		if (!group) continue;
-		let radioDefaultApplied = false;
-		for (const modifierId of group.modifier_ids) {
-			const modifierProduct = lookup.productsById[modifierId];
-			if (!modifierProduct) continue;
-			const modifierPath = `${path}/group/${groupId}/modifier/${modifierId}`;
-			const pricingModifier = resolvePricingModifier(modifierProduct, groupId);
-			const defaultQuantity = pricingModifier?.default_quantity ?? 0;
-			if (defaultQuantity <= 0) continue;
-			if (inferControlType(pricingModifier, group) === "RADIO") {
-				if (radioDefaultApplied) continue;
-				radioDefaultApplied = true;
-			}
-			setQuantity(store, modifierPath, defaultQuantity);
-			applyNestedDefaults(store, lookup, modifierProduct, modifierPath);
-		}
-	}
-};
-const applyInitialQuantities = (store, lookup, product, path, quantities) => {
-	if (quantities[path] !== void 0) setQuantity(store, path, quantities[path]);
-	else setQuantity(store, path, product.pricing.minimum_quantity);
-	for (const groupId of product.pricing.modifier_group_ids) {
-		const group = lookup.modifierGroupsById[groupId];
-		if (!group) continue;
-		for (const modifierId of group.modifier_ids) {
-			const modifierProduct = lookup.productsById[modifierId];
-			if (!modifierProduct) continue;
-			const modifierPath = `${path}/group/${groupId}/modifier/${modifierId}`;
-			if (quantities[modifierPath] !== void 0) setQuantity(store, modifierPath, quantities[modifierPath]);
-			if (getQuantity(store, modifierPath) > 0) {
-				const args1 = [
-					store,
-					lookup,
-					modifierProduct
-				];
-				const args2 = [modifierPath, quantities];
-				applyInitialQuantities(...args1, ...args2);
-			}
-		}
+		group.selectedQuantity = selectedQuantity;
 	}
 };
 //#endregion
@@ -694,6 +949,7 @@ const validateModifier = (modifier, options) => {
 		if (nestedStatus === "INVALID") status = "INVALID";
 		else if (status === "VALID" && nestedStatus !== "VALID") status = "INCOMPLETE";
 	}
+	if (quantity > 0 && status === "VALID" && !modifier.resolved) status = "INCOMPLETE";
 	return finalize(status, soft);
 };
 const validateGroup = (group, options) => {
@@ -749,26 +1005,92 @@ const validateProduct = (product, options) => {
 	product.status = "VALID";
 	return product.status;
 };
+const validateRoot = (runtime, options) => {
+	refreshProductTree(runtime.root, runtime);
+	const status = validateProduct(runtime.root, options);
+	if (status === "IDLE" || !runtime.pendingVariants?.()) return status;
+	runtime.root.status = "INCOMPLETE";
+	return runtime.root.status;
+};
 const runAfterChange = (runtime) => {
-	refreshProductTree(runtime.root, runtime.store);
-	validateProduct(runtime.root, { soft: true });
+	validateRoot(runtime, { soft: true });
 	runtime.listeners.forEach((listener) => listener());
 };
 //#endregion
 //#region src/productCustomization/createCtx.ts
-const createModifierCtx = (runtime, productCtx, group, modifierProduct, modifierPath) => {
+const retargetModifierProduct = (runtime, ctx, product) => {
+	const { store, lookup } = runtime;
+	const prefix = `${ctx.path}/group/`;
+	const carried = {};
+	for (const [key, value] of Object.entries(store.quantities)) {
+		if (!key.startsWith(prefix)) continue;
+		carried[key] = value;
+		delete store.quantities[key];
+	}
+	const args = [
+		store,
+		lookup,
+		product,
+		ctx.path
+	];
+	if (Object.keys(carried).length > 0) applyNestedInitial(...args, carried);
+	else if (getQuantity(store, ctx.path) > 0) applyNestedDefaults(...args);
+	assignProduct(runtime, ctx, product);
+};
+const attachModifierVariants = (runtime, modifier) => {
+	const { store, lookup } = runtime;
+	const base = modifier.data;
+	const path = modifier.path;
+	const { groups, candidates } = variantIndexFor(lookup, base);
+	let lastKey = null;
+	const selectHandler = (groupId, optionId) => {
+		const current = store.selections[path] ?? {};
+		store.selections[path] = {
+			...current,
+			[groupId]: optionId
+		};
+		if (getQuantity(store, path) > 0) {
+			runAfterChange(runtime);
+			return;
+		}
+		modifier.onChange(Math.max(1, modifier.min));
+	};
+	const sync = () => {
+		if (JSON.stringify(store.selections[path] ?? {}) === lastKey) return;
+		const target = customizedProduct(store, lookup, base, path);
+		const selection = store.selections[path] ?? {};
+		lastKey = JSON.stringify(selection);
+		modifier.resolved = target === base ? null : target;
+		if (!modifier.product) modifier.product = createProductCtx(runtime, target, path, false);
+		else if (modifier.product.data.id !== target.id) retargetModifierProduct(runtime, modifier.product, target);
+		modifier.variants = buildVariantGroupCtxs(...[
+			groups,
+			candidates,
+			selection,
+			selectHandler,
+			path
+		]);
+	};
+	runtime.variantSyncs.set(modifier, sync);
+	sync();
+};
+const createModifierCtx = (runtime, group, modifierProduct, parentPath) => {
+	const modifierPath = `${group.path}/modifier/${modifierProduct.id}`;
 	const pricingModifier = resolvePricingModifier(...[modifierProduct, group.data.id]);
 	const type = inferControlType(pricingModifier, group.data);
+	const min = pricingModifier?.minimum_quantity ?? 0;
 	const modifier = {
 		path: modifierPath,
-		min: pricingModifier?.minimum_quantity ?? 0,
+		min,
 		max: pricingModifier?.maximum_quantity ?? group.data.maximum_quantity,
-		quantity: 0,
-		required: (pricingModifier?.minimum_quantity ?? 0) > 0,
+		quantity: getQuantity(runtime.store, modifierPath),
+		required: min > 0,
 		status: "IDLE",
 		data: modifierProduct,
 		type,
 		product: null,
+		variants: [],
+		resolved: modifierProduct,
 		linePrice: 0,
 		onChange: () => {}
 	};
@@ -790,7 +1112,9 @@ const createModifierCtx = (runtime, productCtx, group, modifierProduct, modifier
 		} else setQuantity(runtime.store, modifierPath, next);
 		runAfterChange(runtime);
 	};
-	if (modifierProduct.pricing.modifier_group_ids.length > 0) modifier.product = createProductCtx(...[
+	if (pathVisits(parentPath, modifierProduct.id)) return modifier;
+	if (isVariantBase(modifierProduct)) attachModifierVariants(runtime, modifier);
+	else if (modifierProduct.pricing.modifier_group_ids.length > 0) modifier.product = createProductCtx(...[
 		runtime,
 		modifierProduct,
 		modifierPath,
@@ -798,10 +1122,9 @@ const createModifierCtx = (runtime, productCtx, group, modifierProduct, modifier
 	]);
 	return modifier;
 };
-const createModifierGroupCtx = (runtime, productCtx, group, productPath) => {
-	const groupPath = `${productPath}/group/${group.id}`;
+const createModifierGroupCtx = (runtime, group, productPath) => {
 	const groupCtx = {
-		path: groupPath,
+		path: `${productPath}/group/${group.id}`,
 		min: group.minimum_quantity,
 		max: group.maximum_quantity,
 		required: group.minimum_quantity > 0,
@@ -814,25 +1137,36 @@ const createModifierGroupCtx = (runtime, productCtx, group, productPath) => {
 	for (const modifierId of group.modifier_ids) {
 		const modifierProduct = runtime.lookup.productsById[modifierId];
 		if (!modifierProduct) continue;
-		const modifierPath = `${groupPath}/modifier/${modifierId}`;
-		const args1 = [
+		const args = [
 			runtime,
-			productCtx,
-			groupCtx
+			groupCtx,
+			modifierProduct,
+			productPath
 		];
-		const args2 = [modifierProduct, modifierPath];
-		const ctx = createModifierCtx(...args1, ...args2);
-		groupCtx.modifiers.push(ctx);
+		groupCtx.modifiers.push(createModifierCtx(...args));
 	}
 	return groupCtx;
 };
+const assignProduct = (runtime, productCtx, product) => {
+	productCtx.data = product;
+	productCtx.min = product.pricing.minimum_quantity;
+	productCtx.max = product.pricing.maximum_quantity;
+	productCtx.required = product.pricing.minimum_quantity > 0;
+	const groups = [];
+	for (const groupId of product.pricing.modifier_group_ids) {
+		const group = runtime.lookup.modifierGroupsById[groupId];
+		if (!group) continue;
+		groups.push(createModifierGroupCtx(runtime, group, productCtx.path));
+	}
+	productCtx.groups = groups;
+};
 const createProductCtx = (runtime, product, path, isRoot) => {
 	const productCtx = {
 		path,
-		min: product.pricing.minimum_quantity,
-		max: product.pricing.maximum_quantity,
-		quantity: 0,
-		required: product.pricing.minimum_quantity > 0,
+		min: 0,
+		max: 0,
+		quantity: getQuantity(runtime.store, path),
+		required: false,
 		status: "IDLE",
 		data: product,
 		groups: [],
@@ -840,28 +1174,23 @@ const createProductCtx = (runtime, product, path, isRoot) => {
 		validate: () => "IDLE",
 		reset: () => {}
 	};
-	productCtx.groups = product.pricing.modifier_group_ids.map((groupId) => {
-		const group = runtime.lookup.modifierGroupsById[groupId];
-		if (!group) return null;
-		return createModifierGroupCtx(runtime, productCtx, group, path);
-	}).filter((entry) => entry !== null);
+	assignProduct(runtime, productCtx, product);
 	productCtx.onChange = (quantity) => {
 		const next = clampProductQuantity(quantity, productCtx.min, productCtx.max);
 		if (next <= 0) clearSubtree(runtime.store, path);
 		setQuantity(runtime.store, path, next);
 		runAfterChange(runtime);
 	};
-	productCtx.validate = (options) => {
-		refreshProductTree(runtime.root, runtime.store);
-		return validateProduct(runtime.root, options);
-	};
+	productCtx.validate = (options) => validateRoot(runtime, options);
 	productCtx.reset = (options) => {
-		clearSubtree(runtime.store, path);
+		const { store, lookup } = runtime;
+		clearSubtree(store, path);
 		if (options?.force) {
-			if (isRoot) applyCatalogDefaults(runtime.store, runtime.lookup, product, path);
+			if (isRoot) applyCatalogDefaults(store, lookup, productCtx.data, path);
 		} else {
-			for (const [key, value] of Object.entries(runtime.store.initialQuantities)) if (key === path || key.startsWith(`${path}/`)) setQuantity(runtime.store, key, value);
-			if (isRoot && getQuantity(runtime.store, path) === 0) setQuantity(runtime.store, path, product.pricing.minimum_quantity);
+			Object.assign(store.quantities, pickSubtree(store.initialQuantities, path));
+			for (const [key, value] of Object.entries(pickSubtree(store.initialSelections, path))) store.selections[key] = { ...value };
+			if (isRoot && getQuantity(store, path) === 0) setQuantity(store, path, productCtx.data.pricing.minimum_quantity);
 		}
 		runAfterChange(runtime);
 	};
@@ -869,55 +1198,146 @@ const createProductCtx = (runtime, product, path, isRoot) => {
 };
 //#endregion
 //#region src/productCustomization/createSession.ts
+const reroot = (entries, from, to) => {
+	const next = {};
+	for (const [key, value] of Object.entries(entries)) {
+		if (key === from) next[to] = value;
+		if (key.startsWith(`${from}/`)) next[`${to}${key.slice(from.length)}`] = value;
+	}
+	return next;
+};
 const createSession = (lookup, productId, options) => {
 	const product = lookup.productsById[productId];
 	if (!product) throw new Error(`Product "${productId}" was not found in menu.`);
-	const rootPath = `/${productId}`;
-	const store = {
-		quantities: {},
-		initialQuantities: {}
-	};
+	const store = createStore();
+	const snapshotVariants = options?.snapshot?.variants;
+	if (snapshotVariants) store.selections = cloneSelections(snapshotVariants);
 	const seed = options?.snapshot?.quantities ?? options?.initial ?? null;
-	if (seed) {
-		applyInitialQuantities(store, lookup, product, rootPath, seed);
-		store.initialQuantities = cloneQuantities(store.quantities);
-	} else {
-		applyCatalogDefaults(store, lookup, product, rootPath);
-		store.initialQuantities = cloneQuantities(store.quantities);
-	}
+	const seedArgs = [
+		store,
+		lookup,
+		product,
+		`/${product.id}`
+	];
+	if (seed) applyInitialQuantities(...seedArgs, seed);
+	else applyCatalogDefaults(...seedArgs);
 	const listeners = /* @__PURE__ */ new Set();
 	const runtime = {
 		lookup,
 		store,
 		listeners,
+		variantSyncs: /* @__PURE__ */ new WeakMap(),
 		root: null
 	};
-	runtime.root = createProductCtx(runtime, product, rootPath, true);
-	refreshProductTree(runtime.root, runtime.store);
-	validateProduct(runtime.root);
+	const variantBase = resolveVariantBase(lookup, product);
+	const { groups, candidates } = variantBase ? variantIndexFor(lookup, variantBase.base) : {
+		groups: [],
+		candidates: []
+	};
+	let selection = {};
+	let variantCtxs = [];
+	const moveStoreRoot = (from, next) => {
+		const to = `/${next.id}`;
+		const carried = reroot(store.quantities, from, to);
+		const quantity = getQuantity(store, from);
+		store.quantities = {};
+		store.selections = reroot(store.selections, from, to);
+		const hasModifiers = Object.keys(carried).length > 1;
+		const args = [
+			store,
+			lookup,
+			next,
+			to
+		];
+		if (hasModifiers) applyInitialQuantities(...args, carried);
+		else applyCatalogDefaults(...args);
+		const { minimum_quantity: min, maximum_quantity: max } = next.pricing;
+		setQuantity(store, to, clampProductQuantity(quantity, min, max));
+	};
+	const resolveRoot = (nextSelection, current) => {
+		if (!variantBase) return current;
+		selection = normalizeSelection(groups, candidates, nextSelection);
+		const next = findVariantProduct(groups, candidates, selection) ?? variantBase.base;
+		if (next.id !== current.id) moveStoreRoot(`/${current.id}`, next);
+		return next;
+	};
+	const rebuildVariantCtxs = () => {
+		if (!variantBase) return;
+		variantCtxs = buildVariantGroupCtxs(...[
+			groups,
+			candidates,
+			selection
+		], selectHandler);
+	};
+	const applySelection = (nextSelection) => {
+		const current = runtime.root.data;
+		const next = resolveRoot(nextSelection, current);
+		if (next.id !== current.id) runtime.root = createProductCtx(runtime, next, `/${next.id}`, true);
+		rebuildVariantCtxs();
+	};
+	const selectHandler = (groupId, optionId) => {
+		applySelection({
+			...selection,
+			[groupId]: optionId
+		});
+		runAfterChange(runtime);
+	};
+	runtime.pendingVariants = () => {
+		return variantBase !== null && runtime.root.data.id === variantBase.base.id;
+	};
+	const rootProduct = resolveRoot(variantBase?.selection ?? {}, product);
+	runtime.root = createProductCtx(runtime, rootProduct, `/${rootProduct.id}`, true);
+	rebuildVariantCtxs();
+	const initialSelection = { ...selection };
+	store.initialQuantities = cloneQuantities(store.quantities);
+	store.initialSelections = cloneSelections(store.selections);
+	validateRoot(runtime);
+	const activeSelections = () => {
+		const variants = {};
+		for (const [path, entry] of Object.entries(store.selections)) if (getQuantity(store, path) > 0) variants[path] = { ...entry };
+		return variants;
+	};
 	return {
-		root: runtime.root,
+		get root() {
+			return runtime.root;
+		},
+		get base() {
+			return variantBase?.base ?? null;
+		},
+		get variants() {
+			return variantCtxs;
+		},
 		subscribe: (listener) => {
 			listeners.add(listener);
 			return () => listeners.delete(listener);
 		},
 		snapshot: () => {
+			const productId = runtime.root.data.id;
+			const quantities = cloneQuantities(store.quantities);
+			const variants = activeSelections();
+			if (Object.keys(variants).length === 0) return {
+				productId,
+				quantities
+			};
 			return {
 				productId,
-				quantities: cloneQuantities(store.quantities)
+				quantities,
+				variants
 			};
 		},
 		totalPrice: () => {
-			refreshProductTree(runtime.root, runtime.store);
+			refreshProductTree(runtime.root, runtime);
 			return computeTotalPrice(runtime.root);
 		},
-		validate: (options) => {
-			refreshProductTree(runtime.root, runtime.store);
-			const status = validateProduct(runtime.root, options);
+		validate: (validateOptions) => {
+			const status = validateRoot(runtime, validateOptions);
 			runtime.listeners.forEach((listener) => listener());
 			return status;
 		},
-		reset: (options) => runtime.root.reset(options)
+		reset: (resetOptions) => {
+			applySelection(initialSelection);
+			runtime.root.reset(resetOptions);
+		}
 	};
 };
 //#endregion
@@ -988,33 +1408,74 @@ const flattenMenuCategories = (categories, categoriesById, options) => {
 };
 //#endregion
 //#region src/productCustomization/fromOrderLines.ts
+/** Group slot of a child line: listed directly, or as the variant of a base
+* listed in one of the parent's modifier groups. */
+const matchModifierLine = (lookup, parent, childId) => {
+	const groups = parent.pricing.modifier_group_ids.flatMap((groupId) => {
+		const group = lookup.modifierGroupsById[groupId];
+		return group ? [group] : [];
+	});
+	for (const group of groups) {
+		if (!group.modifier_ids.includes(childId)) continue;
+		return {
+			groupId: group.id,
+			modifierId: childId,
+			selection: null
+		};
+	}
+	const child = lookup.productsById[childId];
+	for (const entry of child?.pricing.variants ?? []) {
+		const base = lookup.productsById[entry.product_id];
+		if (!child || !base) continue;
+		const group = groups.find((g) => g.modifier_ids.includes(base.id));
+		if (!group) continue;
+		const selection = selectionForVariant(lookup, base, child);
+		if (!selection) continue;
+		return {
+			groupId: group.id,
+			modifierId: base.id,
+			selection
+		};
+	}
+	return null;
+};
 /**
 * Inverse of {@link toOrderLines}: rebuild a {@link Snapshot} from a root cart
 * line so {@link createSession} can reopen it via `{ snapshot }`.
 */
 const fromOrderLines = (root, lines, lookup) => {
 	const quantities = { [`/${root.id}`]: root.quantity };
-	const walk = (parentProductId, parentUid, pathPrefix) => {
-		const parentProduct = lookup.productsById[parentProductId];
+	const variants = {};
+	const childrenByParent = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		if (line.parent_uid == null) continue;
+		const siblings = childrenByParent.get(line.parent_uid) ?? [];
+		siblings.push(line);
+		childrenByParent.set(line.parent_uid, siblings);
+	}
+	const walk = (parentLine, pathPrefix) => {
+		const parentProduct = lookup.productsById[parentLine.id];
 		if (!parentProduct) return;
-		for (const child of lines) {
-			if (child.parent_uid !== parentUid) continue;
-			let matchedPath = null;
-			for (const groupId of parentProduct.pricing.modifier_group_ids) {
-				if (!lookup.modifierGroupsById[groupId]?.modifier_ids.includes(child.id)) continue;
-				matchedPath = `${pathPrefix}/group/${groupId}/modifier/${child.id}`;
-				break;
-			}
-			if (!matchedPath) continue;
-			quantities[matchedPath] = child.quantity;
-			walk(child.id, child.uid, matchedPath);
+		for (const child of childrenByParent.get(parentLine.uid) ?? []) {
+			const match = matchModifierLine(lookup, parentProduct, child.id);
+			if (!match) continue;
+			const { groupId, modifierId, selection } = match;
+			const path = `${pathPrefix}/group/${groupId}/modifier/${modifierId}`;
+			quantities[path] = child.quantity;
+			if (selection) variants[path] = selection;
+			walk(child, path);
 		}
 	};
-	walk(root.id, root.uid, `/${root.id}`);
-	return {
+	walk(root, `/${root.id}`);
+	if (Object.keys(variants).length === 0) return {
 		productId: root.id,
 		quantities
 	};
+	return {
+		productId: root.id,
+		quantities,
+		variants
+	};
 };
 //#endregion
 //#region src/productCustomization/menu.ts
@@ -1024,6 +1485,8 @@ const indexMenu = (menu) => {
 	const modifierGroupsById = {};
 	const modifierGroups = resolveModifierGroupsForLookup(...[menu.products, menu.modifier_groups]);
 	for (const group of modifierGroups) modifierGroupsById[group.id] = group;
+	const variantGroupsById = {};
+	for (const group of menu.variant_groups ?? []) variantGroupsById[group.id] = group;
 	const categoriesById = {};
 	for (const category of menu.categories) categoriesById[category.id] = category;
 	const recommendationsById = {};
@@ -1031,21 +1494,149 @@ const indexMenu = (menu) => {
 	return {
 		productsById,
 		modifierGroupsById,
+		variantGroupsById,
 		categoriesById,
 		recommendationsById
 	};
 };
 //#endregion
-//#region src/shared/randomUUID.ts
-/** UUID v4 — works when `crypto.randomUUID` is missing (React Native / Hermes). */
-const randomUUID = () => {
-	const c = globalThis.crypto;
-	if (typeof c?.randomUUID === "function") return c.randomUUID();
-	if (typeof c?.getRandomValues !== "function") throw new Error("crypto.getRandomValues is required");
-	const bytes = /* @__PURE__ */ new Uint8Array(16);
-	c.getRandomValues(bytes);
-	bytes[6] = bytes[6] & 15 | 64;
-	bytes[8] = bytes[8] & 63 | 128;
+//#region src/productCustomization/startingPrice.ts
+const marginalCost = (candidate) => {
+	const { quantity, chargeAbove, unit, nested } = candidate;
+	return quantity >= chargeAbove ? unit.plus(nested) : nested;
+};
+const pickCheapest = (candidates) => {
+	let best = null;
+	for (const candidate of candidates) {
+		if (candidate.quantity >= candidate.max) continue;
+		if (!best || marginalCost(candidate).lt(marginalCost(best))) best = candidate;
+	}
+	return best;
+};
+const groupCost = (group, candidates) => {
+	const groupChargeAbove = group.charge_above_quantity ?? 0;
+	let chargedCount = 0;
+	let total = new Big(0);
+	for (const candidate of candidates) {
+		if (candidate.quantity <= 0) continue;
+		const billable = billableQuantity(...[candidate.quantity, candidate.chargeAbove]);
+		const freeLeft = Math.max(0, groupChargeAbove - chargedCount);
+		const charged = billable - Math.min(billable, freeLeft);
+		chargedCount += billable;
+		total = total.plus(candidate.unit.times(charged));
+		total = total.plus(candidate.nested.times(candidate.quantity));
+	}
+	return total;
+};
+const cheapestModifierUnit = (lookup, groupId, listed, walk) => {
+	const { state, visiting } = walk;
+	const options = isVariantBase(listed) ? variantCandidates(lookup, listed).map((c) => c.product) : [listed];
+	let best = null;
+	for (const ordered of options) {
+		if (ordered !== listed && visiting.has(ordered.id)) {
+			state.cycleHits += 1;
+			continue;
+		}
+		const unit = new Big(modifierUnitPricing(...[
+			listed,
+			ordered,
+			groupId
+		]).price);
+		const nested = nestedModifiersCost(lookup, ordered, state, visiting);
+		if (best && unit.plus(nested).gte(best.unit.plus(best.nested))) continue;
+		best = {
+			unit,
+			nested
+		};
+	}
+	return best;
+};
+const cheapestGroupCost = (lookup, group, state, visiting) => {
+	const candidates = [];
+	for (const modifierId of group.modifier_ids) {
+		const modifierProduct = lookup.productsById[modifierId];
+		if (!modifierProduct) continue;
+		if (visiting.has(modifierId)) {
+			state.cycleHits += 1;
+			continue;
+		}
+		const pricingModifier = resolvePricingModifier(modifierProduct, group.id);
+		const cost = cheapestModifierUnit(lookup, group.id, modifierProduct, {
+			state,
+			visiting
+		});
+		if (!cost) continue;
+		const quantity = pricingModifier?.minimum_quantity ?? 0;
+		const max = pricingModifier?.maximum_quantity ?? group.maximum_quantity;
+		const chargeAbove = pricingModifier?.charge_above_quantity ?? 0;
+		candidates.push({
+			quantity,
+			max,
+			...cost,
+			chargeAbove
+		});
+	}
+	const selected = candidates.reduce((sum, c) => sum + c.quantity, 0);
+	let remaining = group.minimum_quantity - selected;
+	while (remaining > 0) {
+		const cheapest = pickCheapest(candidates);
+		if (!cheapest) break;
+		const { quantity, chargeAbove, max } = cheapest;
+		const step = Math.min(remaining, (quantity < chargeAbove ? Math.min(chargeAbove, max) : max) - quantity);
+		cheapest.quantity += step;
+		remaining -= step;
+	}
+	return groupCost(group, candidates);
+};
+const nestedModifiersCost = (lookup, product, state, visiting) => {
+	const cached = state.cache.get(product.id);
+	if (cached) return cached;
+	const cycleHitsBefore = state.cycleHits;
+	const nextVisiting = new Set(visiting).add(product.id);
+	let total = new Big(0);
+	for (const groupId of product.pricing.modifier_group_ids) {
+		const group = lookup.modifierGroupsById[groupId];
+		if (!group) continue;
+		const args = [
+			lookup,
+			group,
+			state,
+			nextVisiting
+		];
+		total = total.plus(cheapestGroupCost(...args));
+	}
+	if (state.cycleHits === cycleHitsBefore) state.cache.set(product.id, total);
+	return total;
+};
+/** Lowest unit price reachable while satisfying every required modifier.
+* For a variant base, the cheapest of its variant products. */
+const computeStartingPrice = (lookup, product, cache = /* @__PURE__ */ new Map()) => {
+	if (isVariantBase(product)) {
+		const prices = variantCandidates(lookup, product).map((c) => computeStartingPrice(lookup, c.product, cache));
+		if (prices.length > 0) return Math.min(...prices);
+	}
+	const modifiers = nestedModifiersCost(...[
+		lookup,
+		product,
+		{
+			cache,
+			cycleHits: 0
+		},
+		/* @__PURE__ */ new Set()
+	]);
+	return new Big(product.pricing.price).plus(modifiers).toNumber();
+};
+//#endregion
+//#region src/shared/randomUUID.ts
+/** UUID v4 — works when `crypto.randomUUID` is missing (React Native / Hermes). */
+const randomUUID = () => {
+	const c = globalThis.crypto;
+	if (typeof c?.randomUUID === "function") return c.randomUUID();
+	if (typeof c?.getRandomValues !== "function") throw new Error("crypto.getRandomValues is required");
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	c.getRandomValues(bytes);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
 	const toHex = (b) => b.toString(16).padStart(2, "0");
 	const hex = Array.from(bytes, toHex).join("");
 	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
@@ -1209,62 +1800,44 @@ const flatten = (node, out) => {
 	out.push(line);
 	for (const child of children) flatten(child, out);
 };
-const appendModifierLines = (config) => {
-	for (const modifier of config.modifiers) {
-		if (modifier.quantity <= 0) continue;
-		const groupId = modifier.path.split("/group/")[1]?.split("/")[0];
-		let pricing;
-		if (groupId) pricing = resolvePricingModifier(modifier.data, groupId);
-		const taxRate = pricing?.tax_rate ?? modifier.data.pricing.tax_rate;
-		const fromGroup = pricing?.is_tax_inclusive;
-		const fromData = modifier.data.pricing.is_tax_inclusive;
-		const isTaxInclusive = fromGroup ?? fromData;
-		let unitSubtotal = new Big(0);
-		if (modifier.quantity > 0) unitSubtotal = new Big(modifier.linePrice).div(modifier.quantity);
-		const name = displayName(modifier.data.name, config.locale);
-		const l1 = {
-			product: modifier.data,
-			name
-		};
-		const l2 = {
-			quantity: modifier.quantity,
-			unitSubtotal
-		};
-		const l3 = {
-			taxRate,
-			isTaxInclusive
-		};
-		const l4 = { parent_uid: config.parentUid };
-		const l5 = { parent_id: config.parentId };
-		const line = buildLine({
-			...l1,
-			...l2,
-			...l3,
-			...l4,
-			...l5
-		});
-		config.parent.children.push(line);
-		if (modifier.product) for (const group of modifier.product.groups) {
-			const n1 = { modifiers: group.modifiers };
-			const n2 = {
-				parentUid: line.uid,
-				parentId: line.id
-			};
-			const n3 = {
-				parent: line,
-				locale: config.locale
-			};
-			appendModifierLines({
-				...n1,
-				...n2,
-				...n3
-			});
-		}
-	}
+const appendGroupLines = (groups, parent, locale) => {
+	for (const group of groups) for (const modifier of group.modifiers) appendModifierLine(modifier, group.data.id, parent, locale);
+};
+const appendModifierLine = (modifier, groupId, parent, locale) => {
+	const product = modifier.resolved;
+	if (modifier.quantity <= 0 || !product) return;
+	const { taxRate, isTaxInclusive } = modifierUnitPricing(...[
+		modifier.data,
+		product,
+		groupId
+	]);
+	const unitSubtotal = new Big(modifier.linePrice).div(modifier.quantity);
+	const l1 = {
+		product,
+		name: displayName(product.name, locale),
+		quantity: modifier.quantity,
+		unitSubtotal
+	};
+	const l2 = {
+		taxRate,
+		isTaxInclusive
+	};
+	const l3 = {
+		parent_uid: parent.uid,
+		parent_id: parent.id
+	};
+	const line = buildLine({
+		...l1,
+		...l2,
+		...l3
+	});
+	parent.children.push(line);
+	if (modifier.product) appendGroupLines(modifier.product.groups, line, locale);
 };
 /** Flatten a customized product tree into priced OrderLine rows. */
 const toOrderLines = (root, locale) => {
 	if (root.quantity <= 0) return [];
+	if (isVariantBase(root.data)) return [];
 	const name = displayName(root.data.name, locale);
 	const unitSubtotal = new Big(root.data.pricing.price);
 	const t1 = {
@@ -1287,22 +1860,7 @@ const toOrderLines = (root, locale) => {
 		...t3,
 		...t4
 	});
-	for (const group of root.groups) {
-		const n1 = { modifiers: group.modifiers };
-		const n2 = {
-			parentUid: rootLine.uid,
-			parentId: rootLine.id
-		};
-		const n3 = {
-			parent: rootLine,
-			locale
-		};
-		appendModifierLines({
-			...n1,
-			...n2,
-			...n3
-		});
-	}
+	appendGroupLines(root.groups, rootLine, locale);
 	finalizeGroupMoney(rootLine);
 	const lines = [];
 	flatten(rootLine, lines);
@@ -1409,6 +1967,105 @@ const buildCustomerSnapshot = (source) => {
 	} };
 };
 //#endregion
+//#region src/logs/limits.ts
+/** Mirrors the API limits so oversized logs are trimmed, not rejected. */
+const LOG_LIMITS = {
+	message: 2e3,
+	detail: 2e3,
+	alias: 64,
+	status: 64,
+	contextId: 128,
+	errorName: 128,
+	stack: 8e3,
+	cause: 2e3,
+	batch: 50,
+	keepaliveBytes: 6e4
+};
+const truncate = (value, max) => {
+	if (value.length <= max) return value;
+	return `${value.slice(0, max - 1)}…`;
+};
+//#endregion
+//#region src/logs/context.ts
+const emptyContext = () => {
+	return {
+		channel_id: null,
+		fulfillment_id: null,
+		store_id: null,
+		brand_id: null,
+		device_id: null
+	};
+};
+let context = emptyContext();
+let posDevice = null;
+const cleanId = (value) => {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	return trimmed.slice(0, LOG_LIMITS.contextId);
+};
+const SCOPE_KEYS = [
+	"channel_id",
+	"fulfillment_id",
+	"store_id",
+	"brand_id"
+];
+/** Only keys present in `scope` change; `null` clears one. */
+const captureLogScope = (scope) => {
+	if (!scope) return;
+	const next = { ...context };
+	for (const key of SCOPE_KEYS) {
+		if (scope[key] === void 0) continue;
+		next[key] = cleanId(scope[key]);
+	}
+	context = next;
+};
+const captureLogDevice = (device_id) => {
+	const id = cleanId(device_id);
+	if (id) context = {
+		...context,
+		device_id: id
+	};
+};
+/** `{ device: { uid }, scope }` as returned by kiosk link and POS pair. */
+const captureLogDeviceConfig = (config) => {
+	if (!config || typeof config !== "object") return;
+	const value = config;
+	captureLogDevice(value.device?.uid);
+	captureLogScope(value.scope);
+};
+/** POS calls carry device credentials; logs reuse them for the POS route. */
+const capturePosLogDevice = (input, options) => {
+	if (!input || typeof input !== "object") return;
+	const value = input;
+	const device_uid = cleanId(value.device_uid);
+	const { device_secret } = value;
+	if (!device_uid || typeof device_secret !== "string") return;
+	if (!device_secret) return;
+	posDevice = {
+		device_uid,
+		device_secret,
+		http: {
+			baseUrl: options?.baseUrl,
+			fetchImpl: options?.fetchImpl
+		}
+	};
+	captureLogDevice(device_uid);
+};
+const clearLogDevice = () => {
+	posDevice = null;
+	context = {
+		...context,
+		device_id: null
+	};
+};
+const getLogContext = () => {
+	return { ...context };
+};
+const getPosLogDevice = () => {
+	return posDevice;
+};
+//#endregion
 //#region src/services/http.ts
 var StorefrontHttpError = class extends Error {
 	status;
@@ -1526,6 +2183,7 @@ const preferencesQuery = (scope) => {
 	return query ? `${path}?${query}` : path;
 };
 const getPreferences = (scope = {}, options) => {
+	captureLogScope(scope);
 	return storefrontJson(...[
 		preferencesQuery(scope),
 		{},
@@ -1614,7 +2272,7 @@ const kioskFetch = async (path, init, options) => {
 	};
 	return fetchImpl(kioskUrl(path, options), req);
 };
-const readError = async (response) => {
+const readError$1 = async (response) => {
 	const text = await response.text();
 	try {
 		return JSON.parse(text);
@@ -1642,10 +2300,12 @@ const getKioskConfig = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
-	return (await response.json()).data;
+	const json = await response.json();
+	captureLogDeviceConfig(json.data);
+	return json.data;
 };
 const postKioskHeartbeat = async (input, options) => {
 	const path = "/api/storefront/v1/kiosk/devices/me";
@@ -1655,9 +2315,10 @@ const postKioskHeartbeat = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
+	captureLogDevice(input.device_uid);
 	return await response.json();
 };
 const postKioskHealthSamples = async (input, options) => {
@@ -1668,9 +2329,10 @@ const postKioskHealthSamples = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
+	captureLogDevice(input.device_uid);
 	return await response.json();
 };
 const patchKioskOverrides = async (input, options) => {
@@ -1681,7 +2343,7 @@ const patchKioskOverrides = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
 	return (await response.json()).data;
@@ -1694,9 +2356,10 @@ const unlinkKioskSelf = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
+	clearLogDevice();
 	return (await response.json()).data;
 };
 /** 403 wrong or expired code, 429 too many tries for the current code. */
@@ -1708,7 +2371,7 @@ const verifyKioskAdminCode = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
 	return (await response.json()).data;
@@ -1727,9 +2390,10 @@ const fetchKioskRealtimeToken = async (input, options) => {
 	};
 	const response = await kioskFetch(path, init, options);
 	if (!response.ok) {
-		const body = await readError(response);
+		const body = await readError$1(response);
 		throwKioskError(body, response.status);
 	}
+	captureLogDevice(input.device_uid);
 	return (await response.json()).data;
 };
 //#endregion
@@ -1747,9 +2411,11 @@ const menuQuery = (scope, stream) => {
 	return `/api/storefront/v1/menus${query ? `?${query}` : ""}`;
 };
 const listMenus = (scope = {}, options) => {
+	captureLogScope(scope);
 	return storefrontJson(menuQuery(scope), {}, options);
 };
 const listMenusStream = (scope = {}, options = {}) => {
+	captureLogScope(scope);
 	const { category_limit, product_limit, ...http } = options;
 	return storefrontNdjson(menuQuery(scope, {
 		streaming: true,
@@ -1815,6 +2481,18 @@ const placeOrder = (id, body = {}, options) => {
 		options
 	]);
 };
+/** Records (or updates by `metadata.attempt_reference`) one payment intent. */
+const recordOrderPayment = (id, body, options) => {
+	const init = {
+		method: "POST",
+		body: JSON.stringify(body)
+	};
+	return storefrontJson(...[
+		`${orderPath(id)}/payments`,
+		init,
+		options
+	]);
+};
 const getOrderFulfillment = (id, options) => {
 	return storefrontJson(...[
 		`${orderPath(id)}/fulfillment`,
@@ -1893,6 +2571,229 @@ const listPayments = (input, options) => {
 	for (const [key, value] of Object.entries(input)) if (value) params.set(key, value);
 	return storefrontJson(`/api/storefront/v1/payments?${params.toString()}`, {}, options);
 };
+/** Server half of an adapter (`POST /payments/:id/operations/:operation`). */
+const callPaymentOperation = (paymentId, operation, body, options) => {
+	return storefrontJson(`/api/storefront/v1/payments/${encodeURIComponent(paymentId)}/operations/${encodeURIComponent(operation)}`, {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+};
+/** Reports a failed terminal operation (`payment.terminal_failed`). */
+const reportTerminalFailure = (paymentId, body, options) => {
+	return storefrontJson(`/api/storefront/v1/payments/${encodeURIComponent(paymentId)}/terminal-failures`, {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+};
+//#endregion
+//#region src/i18n/pos.ts
+const enUS = {
+	DEVICE_NOT_LINKED: "This register is not linked.",
+	DEVICE_NOT_ACTIVE: "This register is not active.",
+	PAIRING_CODE_INVALID: "That pairing code is not valid.",
+	RELINK_CODE_INVALID: "That re-link code is not valid.",
+	RELINK_CODE_EXPIRED: "That re-link code has expired.",
+	PIN_INVALID: "The PIN is incorrect.",
+	PIN_LOCKED: "This PIN is locked. Try again later.",
+	OPERATOR_NOT_ASSIGNED: "This operator is not assigned to this store.",
+	AUTHORIZER_NOT_ALLOWED: "This person cannot authorize this action.",
+	SESSION_ALREADY_OPEN: "A cash session is already open on this register.",
+	SESSION_NOT_OPEN: "Open a cash session first.",
+	BREAKDOWN_MISMATCH: "The cash breakdown does not match the amount.",
+	DIFFERENCE_NEEDS_AUTH: "The difference needs a manager PIN.",
+	KIOSK_ORDER_NOT_SETTLEABLE: "This kiosk order cannot be settled here.",
+	PAYMENT_NOT_AVAILABLE: "This payment method is not available on this register."
+};
+const posErrorMessages = {
+	en: enUS,
+	"en-US": enUS,
+	es: {
+		DEVICE_NOT_LINKED: "Esta caja no está vinculada.",
+		DEVICE_NOT_ACTIVE: "Esta caja no está activa.",
+		PAIRING_CODE_INVALID: "Ese código de vinculación no es válido.",
+		RELINK_CODE_INVALID: "Ese código de revinculación no es válido.",
+		RELINK_CODE_EXPIRED: "Ese código de revinculación expiró.",
+		PIN_INVALID: "El PIN es incorrecto.",
+		PIN_LOCKED: "Este PIN está bloqueado. Inténtalo más tarde.",
+		OPERATOR_NOT_ASSIGNED: "Este operador no está asignado a esta tienda.",
+		AUTHORIZER_NOT_ALLOWED: "Esta persona no puede autorizar esta acción.",
+		SESSION_ALREADY_OPEN: "Ya hay una sesión de caja abierta aquí.",
+		SESSION_NOT_OPEN: "Abre una sesión de caja primero.",
+		BREAKDOWN_MISMATCH: "El desglose de efectivo no coincide con el monto.",
+		DIFFERENCE_NEEDS_AUTH: "La diferencia necesita el PIN de un supervisor.",
+		KIOSK_ORDER_NOT_SETTLEABLE: "Este pedido de kiosco no se puede cobrar aquí.",
+		PAYMENT_NOT_AVAILABLE: "Este método de pago no está disponible en esta caja."
+	},
+	"pt-BR": {
+		DEVICE_NOT_LINKED: "Este caixa não está vinculado.",
+		DEVICE_NOT_ACTIVE: "Este caixa não está ativo.",
+		PAIRING_CODE_INVALID: "Esse código de vinculação não é válido.",
+		RELINK_CODE_INVALID: "Esse código de revinculação não é válido.",
+		RELINK_CODE_EXPIRED: "Esse código de revinculação expirou.",
+		PIN_INVALID: "O PIN está incorreto.",
+		PIN_LOCKED: "Este PIN está bloqueado. Tente novamente mais tarde.",
+		OPERATOR_NOT_ASSIGNED: "Este operador não está cadastrado nesta loja.",
+		AUTHORIZER_NOT_ALLOWED: "Esta pessoa não pode autorizar esta ação.",
+		SESSION_ALREADY_OPEN: "Já existe uma sessão de caixa aberta aqui.",
+		SESSION_NOT_OPEN: "Abra uma sessão de caixa primeiro.",
+		BREAKDOWN_MISMATCH: "A composição do dinheiro não confere com o valor.",
+		DIFFERENCE_NEEDS_AUTH: "A diferença precisa do PIN de um supervisor.",
+		KIOSK_ORDER_NOT_SETTLEABLE: "Este pedido do totem não pode ser cobrado aqui.",
+		PAYMENT_NOT_AVAILABLE: "Esta forma de pagamento não está disponível neste caixa."
+	}
+};
+const posErrorMessage = (code, locale = "en-US") => {
+	if (!code) return void 0;
+	return (posErrorMessages[locale] ?? posErrorMessages["en-US"])[code];
+};
+//#endregion
+//#region src/services/pos.ts
+const posUrl = (path, options) => {
+	const override = options?.baseUrl;
+	const base = override ? resolveBaseUrl(override) : resolveBaseUrl();
+	if (!path.startsWith("/")) return `${base}/${path}`;
+	return `${base}${path}`;
+};
+const posFetch = async (path, init, options) => {
+	const fetchImpl = options?.fetchImpl ?? fetch;
+	const headers = new Headers(init.headers);
+	if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+	const signal = options?.signal ?? init.signal;
+	const req = {
+		...init,
+		headers,
+		signal
+	};
+	return fetchImpl(posUrl(path, options), req);
+};
+const readError = async (response) => {
+	const text = await response.text();
+	try {
+		return JSON.parse(text);
+	} catch {
+		return { error: text || response.statusText };
+	}
+};
+const validationDetails = (details) => {
+	if (!details || typeof details !== "object") return null;
+	const record = details;
+	if (!Array.isArray(record.issues) || !record.lines) return null;
+	return {
+		issues: record.issues,
+		lines: record.lines
+	};
+};
+/** A sale the menu rejects comes back as a 422 with issues, like checkout. */
+const throwPosError = (body, status) => {
+	const details = status === 422 ? validationDetails(body.details) : null;
+	if (details) throw new OrderValidationError(details.issues, details.lines);
+	throw new StorefrontHttpError(body.error ?? "Request failed", status, body.code);
+};
+const postJson = async (path, input, options) => {
+	const init = {
+		method: "POST",
+		body: JSON.stringify(input)
+	};
+	const response = await posFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwPosError(body, response.status);
+	}
+	capturePosLogDevice(input, options);
+	return await response.json();
+};
+/** Pairing answers with the device config; the secret came from the app. */
+const captureLinkedDevice = (data, device_secret, options) => {
+	captureLogDeviceConfig(data);
+	const device = data?.device;
+	capturePosLogDevice({
+		device_uid: device?.uid,
+		device_secret
+	}, options);
+};
+const isPosDeviceNotLinked = (error) => {
+	if (!(error instanceof StorefrontHttpError)) return false;
+	if (error.code === "DEVICE_NOT_LINKED") return true;
+	if (error.status !== 404) return false;
+	return error.message.includes("DEVICE_NOT_LINKED");
+};
+const isPosUnauthorized = (error) => {
+	return error instanceof StorefrontHttpError && error.status === 401;
+};
+const isPosPinLocked = (error) => {
+	return error instanceof StorefrontHttpError && error.code === "PIN_LOCKED";
+};
+const localizePosError = (error, locale = "en-US") => {
+	if (!(error instanceof StorefrontHttpError)) return void 0;
+	return posErrorMessage(error.code, locale);
+};
+const pairPosDevice = async (input, options) => {
+	const json = await postJson("/api/storefront/v1/pos/devices/pair", input, options);
+	captureLinkedDevice(json.data, input.device_secret, options);
+	return json.data;
+};
+const relinkPosDevice = async (input, options) => {
+	const json = await postJson("/api/storefront/v1/pos/devices/relink", input, options);
+	captureLinkedDevice(json.data, input.device_secret, options);
+	return json.data;
+};
+const postPosHeartbeat = async (input, options) => {
+	return postJson("/api/storefront/v1/pos/devices/me", input, options);
+};
+const postPosHealthSamples = async (input, options) => {
+	return postJson("/api/storefront/v1/pos/devices/me/health", input, options);
+};
+const postPosDeviceLogs = async (input, options) => {
+	return postJson("/api/storefront/v1/pos/devices/me/logs", input, options);
+};
+const listPosOperators = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/operators", input, options)).data;
+};
+const verifyPosOperator = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/operators/verify", input, options)).data;
+};
+const listPosAuthorizers = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/authorizers", input, options)).data;
+};
+const verifyPosAuthorizer = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/auth/verify", input, options)).data;
+};
+const openPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/open", input, options)).data;
+};
+const countPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/count", input, options)).data;
+};
+const withdrawPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/withdraw", input, options)).data;
+};
+const drawerPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/drawer", input, options)).data;
+};
+const closePosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/close", input, options)).data;
+};
+const shiftEndPosSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/shift-end", input, options)).data;
+};
+/** The device's open caja and its events, or `{ session: null }`. */
+const getPosCurrentSession = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/sessions/current", input, options)).data;
+};
+const listPosKioskOrders = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/kiosk-orders", input, options)).data;
+};
+/** Safe to retry with the same `client_id`; the server dedupes the settle. */
+const settlePosKioskOrder = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/kiosk-orders/settle", input, options)).data;
+};
+const getPosCatalog = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/catalog", input, options)).data;
+};
+/** Safe to retry with the same `client_id`; the server dedupes the sale. */
+const createPosOrder = async (input, options) => {
+	return (await postJson("/api/storefront/v1/pos/orders", input, options)).data;
+};
 //#endregion
 //#region src/services/stores.ts
 const storesPath = (suffix) => {
@@ -1921,8 +2822,8 @@ const listNearbyStores = (input, options) => {
 	};
 	return storefrontJson(withQuery(storesPath("nearby"), query), {}, options);
 };
-const getStore = (id, options) => {
-	return storefrontJson(storesPath(encodeURIComponent(id)), {}, options);
+const getStore = (id, input = {}, options) => {
+	return storefrontJson(withQuery(storesPath(encodeURIComponent(id)), { ...input }), {}, options);
 };
 //#endregion
 //#region src/services/index.ts
@@ -1955,10 +2856,15 @@ const services = {
 		reorder: reorderOrder,
 		validate: validateOrder,
 		place: placeOrder,
+		recordPayment: recordOrderPayment,
 		getFulfillment: getOrderFulfillment,
 		listFulfillments: listOrderFulfillments
 	},
-	payments: { list: listPayments },
+	payments: {
+		list: listPayments,
+		operation: callPaymentOperation,
+		terminalFailure: reportTerminalFailure
+	},
 	stores: {
 		list: listStores,
 		nearby: listNearbyStores,
@@ -1976,6 +2882,32 @@ const services = {
 		isAdminCodeLocked: isKioskAdminCodeLocked,
 		isDeviceNotLinked,
 		isKioskUnauthorized
+	},
+	pos: {
+		pair: pairPosDevice,
+		relink: relinkPosDevice,
+		heartbeat: postPosHeartbeat,
+		postHealthSamples: postPosHealthSamples,
+		postLogs: postPosDeviceLogs,
+		listOperators: listPosOperators,
+		verifyOperator: verifyPosOperator,
+		listAuthorizers: listPosAuthorizers,
+		verifyAuthorizer: verifyPosAuthorizer,
+		openSession: openPosSession,
+		countSession: countPosSession,
+		withdraw: withdrawPosSession,
+		drawer: drawerPosSession,
+		closeSession: closePosSession,
+		shiftEnd: shiftEndPosSession,
+		currentSession: getPosCurrentSession,
+		listKioskOrders: listPosKioskOrders,
+		settleKioskOrder: settlePosKioskOrder,
+		getCatalog: getPosCatalog,
+		createOrder: createPosOrder,
+		isDeviceNotLinked: isPosDeviceNotLinked,
+		isUnauthorized: isPosUnauthorized,
+		isPinLocked: isPosPinLocked,
+		localizeError: localizePosError
 	}
 };
 const DISALLOWED = /[^A-Za-z0-9]/g;
@@ -2057,7 +2989,7 @@ const genOrderId = (storeId) => {
 };
 //#endregion
 //#region src/order/retry.ts
-const defaultSleep = (ms) => {
+const defaultSleep$1 = (ms) => {
 	return new Promise((resolve) => {
 		setTimeout(resolve, ms);
 	});
@@ -2066,7 +2998,7 @@ const defaultSleep = (ms) => {
 const withExponentialRetry = async (run, options = {}) => {
 	const extraAttempts = options.extraAttempts ?? 3;
 	const baseDelayMs = options.baseDelayMs ?? 100;
-	const sleep = options.sleep ?? defaultSleep;
+	const sleep = options.sleep ?? defaultSleep$1;
 	let lastError;
 	for (let attempt = 0; attempt <= extraAttempts; attempt += 1) try {
 		return await run();
@@ -2317,104 +3249,873 @@ const removeSubtree = (lines, rootUid) => {
 			grew = true;
 		}
 	}
-	return lines.filter((line) => !drop.has(line.uid));
-};
-const scaleLineQuantity = (line, nextQty) => {
-	const qty = new Big(nextQty);
-	const subtotal = new Big(line.unit_subtotal).times(qty).toNumber();
-	const discount_total = new Big(line.unit_discount).times(qty).toNumber();
-	const tax_total = new Big(line.unit_tax_total).times(qty).toNumber();
-	const total = new Big(line.unit_total).times(qty).toNumber();
-	const gSub = new Big(line.unit_group_subtotal).times(qty).toNumber();
-	const gDisc = new Big(line.unit_group_discount).times(qty).toNumber();
-	const gTax = new Big(line.unit_group_tax_total).times(qty).toNumber();
-	const gTot = new Big(line.unit_group_total).times(qty).toNumber();
-	const b1 = {
-		...line,
-		quantity: nextQty,
-		subtotal,
-		discount_total
-	};
-	const b2 = {
-		tax_total,
-		total,
-		group_subtotal: gSub,
-		group_discount: gDisc
-	};
-	const b3 = {
-		group_tax_total: gTax,
-		group_total: gTot
-	};
-	return {
-		...b1,
-		...b2,
-		...b3
-	};
-};
-const collectDescendantUids = (lines, rootUid) => {
-	const uids = /* @__PURE__ */ new Set([rootUid]);
-	let grew = true;
-	while (grew) {
-		grew = false;
-		for (const line of lines) if (line.parent_uid && uids.has(line.parent_uid) && !uids.has(line.uid)) {
-			uids.add(line.uid);
-			grew = true;
+	return lines.filter((line) => !drop.has(line.uid));
+};
+const scaleLineQuantity = (line, nextQty) => {
+	const qty = new Big(nextQty);
+	const subtotal = new Big(line.unit_subtotal).times(qty).toNumber();
+	const discount_total = new Big(line.unit_discount).times(qty).toNumber();
+	const tax_total = new Big(line.unit_tax_total).times(qty).toNumber();
+	const total = new Big(line.unit_total).times(qty).toNumber();
+	const gSub = new Big(line.unit_group_subtotal).times(qty).toNumber();
+	const gDisc = new Big(line.unit_group_discount).times(qty).toNumber();
+	const gTax = new Big(line.unit_group_tax_total).times(qty).toNumber();
+	const gTot = new Big(line.unit_group_total).times(qty).toNumber();
+	const b1 = {
+		...line,
+		quantity: nextQty,
+		subtotal,
+		discount_total
+	};
+	const b2 = {
+		tax_total,
+		total,
+		group_subtotal: gSub,
+		group_discount: gDisc
+	};
+	const b3 = {
+		group_tax_total: gTax,
+		group_total: gTot
+	};
+	return {
+		...b1,
+		...b2,
+		...b3
+	};
+};
+const collectDescendantUids = (lines, rootUid) => {
+	const uids = /* @__PURE__ */ new Set([rootUid]);
+	let grew = true;
+	while (grew) {
+		grew = false;
+		for (const line of lines) if (line.parent_uid && uids.has(line.parent_uid) && !uids.has(line.uid)) {
+			uids.add(line.uid);
+			grew = true;
+		}
+	}
+	return uids;
+};
+/** Partition a flat batch into root trees (root first, then descendants). */
+const partitionTrees = (batch) => {
+	const roots = batch.filter((line) => line.parent_uid == null);
+	const trees = [];
+	for (const root of roots) {
+		const uids = collectDescendantUids(batch, root.uid);
+		trees.push(batch.filter((line) => uids.has(line.uid)));
+	}
+	return trees;
+};
+const addLines = (lines, incoming) => {
+	const batch = Array.isArray(incoming) ? incoming : [incoming];
+	let next = lines;
+	for (const tree of partitionTrees(batch)) {
+		const root = tree.find((line) => line.parent_uid == null);
+		if (!root) continue;
+		const fingerprint = computeLineFingerprint(root, tree);
+		const existingRoot = next.find((line) => {
+			if (line.parent_uid != null) return false;
+			return computeLineFingerprint(line, next) === fingerprint;
+		});
+		if (existingRoot) {
+			const mergedQty = existingRoot.quantity + root.quantity;
+			next = next.map((line) => {
+				if (line.uid !== existingRoot.uid) return line;
+				return scaleLineQuantity(line, mergedQty);
+			});
+			continue;
+		}
+		next = [...next, ...tree];
+	}
+	return next;
+};
+const removeLine = (lines, lineUid) => {
+	return removeSubtree(lines, lineUid);
+};
+const subtractLine = (lines, lineUid, quantity = 1) => {
+	const target = lines.find((line) => line.uid === lineUid);
+	if (!target) return lines;
+	const nextQty = target.quantity - quantity;
+	if (nextQty <= 0) return removeSubtree(lines, lineUid);
+	return lines.map((line) => {
+		if (line.uid !== lineUid) return line;
+		return scaleLineQuantity(line, nextQty);
+	});
+};
+/** Rescale one line's money to `quantity`; zero or less drops its subtree. */
+const setLineQuantity = (lines, lineUid, quantity) => {
+	if (quantity <= 0) return removeSubtree(lines, lineUid);
+	return lines.map((line) => {
+		if (line.uid !== lineUid) return line;
+		return scaleLineQuantity(line, quantity);
+	});
+};
+/** Drop a root subtree, then add the replacement tree (may merge by fingerprint). */
+const replaceLine = (lines, lineUid, next) => {
+	return addLines(removeSubtree(lines, lineUid), next);
+};
+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;
+	};
+	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) {
+		const cancelled = await callOperation(ctx, adapter.cancel, pending, clock);
+		if (cancelled.status === "CANCELLED") return cancelled;
+	}
+	const error = createPaymentError("AMBIGUOUS", { attempt: ctx.attempt });
+	return failed(ctx, error, { needs_review: true });
+};
+/** PENDING with an action: poll until paid, rejected or the QR expires. */
+const pollPending = async (adapter, ctx, pending, clock, options) => {
+	if (pending.metadata.confirm_after_inject) return pending;
+	if (!adapter.query) return pending;
+	const expiresAt = clock.now() + ctx.policy.qr_ttl_ms;
+	let current = pending;
+	while (clock.now() < expiresAt) {
+		if (ctx.signal.aborted) break;
+		await clock.sleep(ctx.policy.poll_interval_ms, ctx.signal);
+		if (ctx.signal.aborted) break;
+		const next = await callOperation(ctx, adapter.query, current, clock);
+		if (next.status === "FAILED" && next.error?.retryable) continue;
+		if (isFinal(next)) return next;
+		current = next;
+		await options.onProgress?.(current);
+	}
+	if (adapter.cancel) await callOperation(ctx, adapter.cancel, current, clock);
+	const code = ctx.signal.aborted ? "CANCELLED_BY_USER" : "WALLET_EXPIRED";
+	return failed(ctx, createPaymentError(code, { attempt: ctx.attempt }));
+};
+const runStart = async (adapter, ctx, clock) => {
+	const startedAt = clock.now();
+	try {
+		return await runTimed(ctx, (scoped) => adapter.start(scoped));
+	} catch (error) {
+		const raw = errorOf(ctx, error, startedAt, clock);
+		return failed(ctx, startError(raw));
+	}
+};
+const toTerminalContext = (ctx) => {
+	const b1 = {
+		paymentId: ctx.paymentId,
+		attempt: ctx.attempt
+	};
+	const b2 = { attemptReference: ctx.attemptReference };
+	const b3 = {
+		environment: ctx.environment,
+		config: ctx.config
+	};
+	const b4 = {
+		deviceSettings: ctx.deviceSettings,
+		policy: ctx.policy
+	};
+	const b5 = {
+		ui: ctx.ui,
+		storage: ctx.storage,
+		server: ctx.server
+	};
+	return {
+		...b1,
+		...b2,
+		...b3,
+		...b4,
+		...b5,
+		signal: ctx.signal
+	};
+};
+const closeBatch = async (adapter, ctx) => {
+	const close = adapter.terminal?.closeBatch;
+	if (!close) return false;
+	const done = await close(toTerminalContext(ctx)).catch(() => null);
+	return Boolean(done?.ok);
+};
+/**
+* One payment attempt with the policy of section 7: timeout, retries on
+* retryable errors (same `attempt_reference`), batch close and retry,
+* polling for actions and resolution of ambiguous results.
+*/
+const runPaymentAttempt = async (adapter, ctx, options = {}) => {
+	const clock = options.clock ?? defaultClock;
+	return withTerminalLock(ctx.paymentId, async () => {
+		let batchClosed = false;
+		let attempt = 1;
+		while (true) {
+			const current = {
+				...ctx,
+				attempt
+			};
+			const result = await runStart(adapter, current, clock);
+			const code = result.error?.code;
+			if (code === "BATCH_CLOSE_REQUIRED" && !batchClosed) {
+				batchClosed = true;
+				if (await closeBatch(adapter, current)) continue;
+			}
+			if (code === "AMBIGUOUS") {
+				await options.onProgress?.({
+					...result,
+					status: "PENDING"
+				});
+				return resolveAmbiguous(adapter, current, result, clock);
+			}
+			const canRetry = attempt < ctx.policy.max_attempts;
+			if (result.status === "FAILED" && result.error?.retryable && canRetry) {
+				attempt += 1;
+				continue;
+			}
+			if (result.status !== "PENDING") return result;
+			await options.onProgress?.(result);
+			return pollPending(adapter, current, result, clock, options);
+		}
+	});
+};
+/** Undo a charge after a failed injection or an incomplete split payment. */
+const reversePayment = async (adapter, ctx, result, options = {}) => {
+	const clock = options.clock ?? defaultClock;
+	const now = options.now ?? new Date(clock.now());
+	let kind = (adapter.reversalFor ?? defaultReversalFor)(result, now);
+	const operation = kind === "cancel" ? adapter.cancel : adapter.refund;
+	if (kind !== "manual" && !operation) kind = "manual";
+	if (kind === "manual" || !operation) {
+		const error = createPaymentError("MANUAL_REVERSAL_REQUIRED");
+		const m1 = {
+			...result.metadata,
+			error,
+			needs_review: true
+		};
+		return {
+			kind: "manual",
+			result: {
+				...result,
+				metadata: m1,
+				error
+			}
+		};
+	}
+	const run = () => callOperation(ctx, operation, result, clock);
+	const next = await withTerminalLock(ctx.paymentId, run);
+	return {
+		kind,
+		result: next
+	};
+};
+//#endregion
+//#region src/order/payments/session.ts
+const noopUI = {
+	message: () => void 0,
+	action: () => void 0,
+	select: () => Promise.reject(/* @__PURE__ */ new Error("Payment UI not configured")),
+	input: () => Promise.reject(/* @__PURE__ */ new Error("Payment UI not configured")),
+	confirm: () => Promise.resolve(false)
+};
+const adapterKey = (provider, method) => {
+	return `${provider}:${method}`;
+};
+const record = (value) => {
+	if (!value || typeof value !== "object") return {};
+	return value;
+};
+/** PAID plus PENDING with `confirm_after_inject`, in the 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;
+	}, 0);
+};
+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 isPlaced = (order) => order.status !== "OPEN";
+/** Orchestrator failures carry the charge-currency amount, not the order's. */
+const withOrderAmount = (result, amount) => {
+	if (result.status !== "FAILED") return result;
+	return {
+		...result,
+		amount
+	};
+};
+const toFailure = (error) => {
+	const message = error instanceof Error ? error.message : "Terminal failed";
+	return {
+		ok: false,
+		message,
+		error: createPaymentError("UNKNOWN", { provider_message: message })
+	};
+};
+/**
+* Payment state of one order: adapters, device settings and the attempt
+* orchestration. The app only provides adapters, UI and storage.
+*/
+var PaymentSession = class {
+	deps;
+	adapters = /* @__PURE__ */ new Map();
+	payments = /* @__PURE__ */ new Map();
+	ui = noopUI;
+	storage = memoryPaymentStorage();
+	options = {};
+	constructor(deps) {
+		this.deps = deps;
+	}
+	setAdapters(adapters) {
+		this.adapters.clear();
+		for (const adapter of adapters) this.adapters.set(adapterKey(adapter.provider, adapter.method), adapter);
+	}
+	setUI(ui) {
+		this.ui = ui;
+	}
+	setStorage(storage) {
+		this.storage = storage;
+	}
+	setOptions(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		captureLogDevice(options.deviceId);
+	}
+	adapterFor(payment) {
+		const key = adapterKey(payment.provider.provider_id, payment.method.method);
+		return this.adapters.get(key) ?? null;
+	}
+	/** Device fields still missing for a payment on this device. */
+	missingFields(payment) {
+		const adapter = this.adapterFor(payment);
+		if (!adapter) return [];
+		const fromCatalog = record(payment.method.config).device_fields;
+		const fields = adapter.deviceFields ?? fromCatalog;
+		const settings = this.options.deviceSettings?.[payment.id];
+		return missingDeviceFields(Array.isArray(fields) ? fields : [], settings);
+	}
+	/**
+	* Merchant payments with an installed adapter (provider + method) that
+	* are fully configured on this device.
+	*/
+	available(payments) {
+		return payments.filter((payment) => {
+			if (!this.adapterFor(payment)) return false;
+			this.payments.set(payment.id, payment);
+			return this.missingFields(payment).length === 0;
+		});
+	}
+	remaining() {
+		return remainingAmount(this.deps.getOrder());
+	}
+	server(payment, attempt) {
+		const order_id = this.deps.getOrder().id;
+		const http = this.deps.http;
+		return { call: (operation, input) => {
+			const body = {
+				order_id,
+				attempt_reference: attempt,
+				input
+			};
+			const op = services.payments.operation;
+			return op(payment.id, operation, body, http);
+		} };
+	}
+	async chargeAmount(payment, value, server) {
+		const config = record(payment.config);
+		const orderCurrency = this.deps.getOrder().totals.currency;
+		const chargeCurrency = config.charge_currency;
+		if (!chargeCurrency || chargeCurrency === orderCurrency) return toChargeAmount({
+			value,
+			orderCurrency
+		});
+		const exchange = record(config.exchange_rate);
+		let rate = typeof exchange.rate === "number" ? exchange.rate : null;
+		if (exchange.source === "provider") {
+			const input = {
+				from: orderCurrency,
+				to: chargeCurrency
+			};
+			rate = (await server.call("exchange_rate", input)).rate;
+		}
+		return toChargeAmount({
+			value,
+			orderCurrency,
+			chargeCurrency,
+			rate
+		});
+	}
+	async buildContext(payment, amount, attemptReference, signal) {
+		const order = this.deps.getOrder();
+		const server = this.server(payment, attemptReference);
+		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 info = order.customer.customer_info;
+		const customer = {
+			document: info.document_number ?? null,
+			documentType: info.document_type ?? null,
+			phone: info.phone ?? null
+		};
+		const environment = resolveProviderEnvironment({
+			isProduction: this.options.isProduction ?? false,
+			paymentConfig: config
+		});
+		const policy = resolvePaymentPolicy({
+			methodConfig,
+			paymentConfig: config
+		});
+		const prefix = `payments:${payment.id}`;
+		const storage = scopedPaymentStorage(this.storage, prefix);
+		const deviceSettings = this.options.deviceSettings?.[payment.id] ?? {};
+		const totals = order.totals;
+		const o1 = {
+			id: order.id,
+			currency: totals.currency,
+			totals
+		};
+		const b1 = {
+			paymentId: payment.id,
+			order: o1,
+			customer
+		};
+		const b2 = {
+			amount: conversion.amount,
+			taxes,
+			attemptReference
+		};
+		const b3 = {
+			collectAt: this.collectAt(payment),
+			attempt: 1
+		};
+		const b4 = {
+			environment,
+			config,
+			deviceSettings,
+			policy
+		};
+		const b5 = {
+			ui: this.ui,
+			storage,
+			server,
+			signal
+		};
+		return {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5
+		};
+	}
+	collectAt(payment) {
+		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;
+		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
+		};
+		return {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5
+		};
+	}
+	async recordResult(payment, result, placedAt) {
+		const order = this.deps.getOrder();
+		const intent = this.toIntent(payment, result, placedAt);
+		const http = this.deps.http;
+		const p1 = [
+			order.id,
+			{ intent },
+			http
+		];
+		const next = await services.orders.recordPayment(...p1);
+		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}`);
+		}
+		this.payments.set(payment.id, payment);
+		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 }
+		};
+		const order = this.deps.getOrder();
+		if (!isPlaced(order)) {
+			const intent = this.toIntent(payment, pending, placedAt);
+			const p1 = {
+				id: payment.id,
+				intents: [intent]
+			};
+			await this.deps.placeOrder({ payment: p1 });
+		} else await this.recordResult(payment, pending, placedAt);
+		const controller = new AbortController();
+		const abort = () => controller.abort();
+		options.signal?.addEventListener("abort", abort);
+		try {
+			const a1 = [
+				payment,
+				amount,
+				attemptReference,
+				controller.signal
+			];
+			const ctx = await this.buildContext(...a1);
+			const onProgress = async (progress) => {
+				await options.onProgress?.(progress);
+				if (progress.status !== "PENDING") return;
+				await this.recordResult(payment, progress, placedAt);
+			};
+			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);
+			return result;
+		} finally {
+			options.signal?.removeEventListener("abort", abort);
 		}
 	}
-	return uids;
-};
-/** Partition a flat batch into root trees (root first, then descendants). */
-const partitionTrees = (batch) => {
-	const roots = batch.filter((line) => line.parent_uid == null);
-	const trees = [];
-	for (const root of roots) {
-		const uids = collectDescendantUids(batch, root.uid);
-		trees.push(batch.filter((line) => uids.has(line.uid)));
+	intentResult(intent) {
+		const metadata = record(intent.metadata);
+		const error = metadata.error;
+		return {
+			status: intent.status,
+			amount: intent.totals.total,
+			metadata,
+			...error ? { error } : {}
+		};
 	}
-	return trees;
-};
-const addLines = (lines, incoming) => {
-	const batch = Array.isArray(incoming) ? incoming : [incoming];
-	let next = lines;
-	for (const tree of partitionTrees(batch)) {
-		const root = tree.find((line) => line.parent_uid == null);
-		if (!root) continue;
-		const fingerprint = computeLineFingerprint(root, tree);
-		const existingRoot = next.find((line) => {
-			if (line.parent_uid != null) return false;
-			return computeLineFingerprint(line, next) === fingerprint;
-		});
-		if (existingRoot) {
-			const mergedQty = existingRoot.quantity + root.quantity;
-			next = next.map((line) => {
-				if (line.uid !== existingRoot.uid) return line;
-				return scaleLineQuantity(line, mergedQty);
+	async contextFor(intent) {
+		const payment = intent.payment_id ? this.payments.get(intent.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 signal = new AbortController().signal;
+		const a1 = [
+			payment,
+			intent.totals.total,
+			reference,
+			signal
+		];
+		return {
+			payment,
+			adapter,
+			result,
+			ctx: await this.buildContext(...a1),
+			placedAt: intent.placed_at
+		};
+	}
+	/** After the order is injected: confirm PENDING `confirm_after_inject`. */
+	async confirmAfterInject() {
+		const intents = this.deps.getOrder().payment_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);
+			const confirm = found?.adapter.confirm;
+			if (!found || !confirm) continue;
+			const { payment, result, ctx, placedAt } = found;
+			const confirmed = await confirm(ctx, result).catch((error) => {
+				const err = createPaymentError("UNKNOWN", { provider_message: error instanceof Error ? error.message : null });
+				const m1 = {
+					...result.metadata,
+					error: err
+				};
+				return {
+					...result,
+					status: "FAILED",
+					metadata: m1,
+					error: err
+				};
 			});
-			continue;
+			const next = {
+				...confirmed,
+				metadata: { ...confirmed.metadata }
+			};
+			delete next.metadata.confirm_after_inject;
+			await this.recordResult(payment, next, placedAt);
+			results.push(next);
 		}
-		next = [...next, ...tree];
+		return results;
+	}
+	/**
+	* Undo charges of this order (injection failed or split payment
+	* abandoned): cancel, refund or flag for manual reversal.
+	*/
+	async reverseAll() {
+		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);
+			if (!found) continue;
+			const { payment, adapter, result, ctx, placedAt } = found;
+			const outcome = await reversePayment(adapter, ctx, result);
+			const reversed = withOrderAmount(outcome.result, intent.totals.total);
+			await this.recordResult(payment, reversed, placedAt);
+			outcomes.push(outcome);
+		}
+		return outcomes;
+	}
+	/** Runs a terminal operation (init, test, closeBatch, status, extra). */
+	async runTerminal(payment, key) {
+		const terminal = this.adapterFor(payment)?.terminal;
+		if (!terminal) return {
+			ok: false,
+			message: "No terminal operations"
+		};
+		const base = {
+			init: terminal.init,
+			test: terminal.test
+		};
+		const more = {
+			closeBatch: terminal.closeBatch,
+			status: terminal.status
+		};
+		const named = {
+			...base,
+			...more
+		};
+		const extra = terminal.extra?.find((item) => item.key === key)?.run;
+		const operation = named[key] ?? extra;
+		if (!operation) return {
+			ok: false,
+			message: `Unknown operation ${key}`
+		};
+		const signal = new AbortController().signal;
+		const reference = createAttemptReference();
+		const result = await operation(toTerminalContext(await this.buildContext(payment, 0, reference, signal))).catch(toFailure);
+		if (!result.ok) await this.reportTerminal(payment, key, result);
+		return result;
+	}
+	async reportTerminal(payment, operation, result) {
+		const fallback = createPaymentError("UNKNOWN");
+		const error = result.error ?? {
+			...fallback,
+			message: result.message ?? fallback.message
+		};
+		const body = {
+			operation,
+			device_id: this.options.deviceId ?? null,
+			error
+		};
+		const report = services.payments.terminalFailure;
+		await report(payment.id, body, this.deps.http).catch(() => void 0);
 	}
-	return next;
-};
-const removeLine = (lines, lineUid) => {
-	return removeSubtree(lines, lineUid);
-};
-const subtractLine = (lines, lineUid, quantity = 1) => {
-	const target = lines.find((line) => line.uid === lineUid);
-	if (!target) return lines;
-	const nextQty = target.quantity - quantity;
-	if (nextQty <= 0) return removeSubtree(lines, lineUid);
-	return lines.map((line) => {
-		if (line.uid !== lineUid) return line;
-		return scaleLineQuantity(line, nextQty);
-	});
-};
-/** Drop a root subtree, then add the replacement tree (may merge by fingerprint). */
-const replaceLine = (lines, lineUid, next) => {
-	return addLines(removeSubtree(lines, lineUid), next);
-};
-const emptyLines = () => {
-	return [];
 };
 //#endregion
 //#region src/schedule/schedule.ts
@@ -3086,9 +4787,11 @@ var Order = class Order {
 	externalNotify;
 	http;
 	flush;
+	payments;
 	constructor(config, notify) {
 		this.draft = cloneOrder(config.order);
 		this.synced = cloneOrder(config.order);
+		this.rememberLogScope();
 		this.persisted = config.persisted;
 		this.http = config.http;
 		this.externalNotify = notify;
@@ -3112,6 +4815,16 @@ var Order = class Order {
 			fresh: config.fresh ?? false,
 			sleep: config.sleep
 		});
+		this.payments = new PaymentSession({
+			getOrder: () => this.draft,
+			placeOrder: (input) => this.placeOrder(input),
+			applyOrder: (next) => {
+				this.draft = cloneOrder(next);
+				this.synced = cloneOrder(next);
+				this.notify();
+			},
+			http: this.http
+		});
 	}
 	/**
 	* Opens a cart session: reuses an existing OPEN order for the scope, or a
@@ -3324,6 +5037,12 @@ var Order = class Order {
 		});
 		this.commitLines({ lines });
 	}
+	rememberLogScope() {
+		captureLogScope({
+			...this.draft,
+			brand_id: this.draft.brand_id ?? null
+		});
+	}
 	setScope(scope) {
 		if (this.deleted) return;
 		this.draft = {
@@ -3333,6 +5052,7 @@ var Order = class Order {
 			fulfillment_id: scope.fulfillment_id ?? this.draft.fulfillment_id,
 			brand_id: scope.brand_id === void 0 ? this.draft.brand_id : optionalBrandId(scope.brand_id)
 		};
+		this.rememberLogScope();
 		this.scheduleAfterMutate();
 	}
 	/** Shallow-merges into order metadata; `null` values are kept as-is. */
@@ -3447,6 +5167,50 @@ var Order = class Order {
 		this.synced = cloneOrder(next);
 		this.notify();
 	}
+	/** Installed `@fire-spark/payments-*` adapters (provider + method). */
+	setPaymentAdapters(adapters) {
+		this.payments.setAdapters(adapters);
+	}
+	/** Template modal/sheet the adapters use to talk to the customer. */
+	setPaymentUI(ui) {
+		this.payments.setUI(ui);
+	}
+	/** Persistent device storage (terminal keys, last batch close). */
+	setPaymentStorage(storage) {
+		this.payments.setStorage(storage);
+	}
+	/** Environment, collect point and this device's `payment_settings`. */
+	setPaymentOptions(options) {
+		this.payments.setOptions(options);
+	}
+	/** Merchant payments with an adapter installed and configured here. */
+	getPaymentOptions(payments) {
+		return this.payments.available(payments);
+	}
+	/** Device fields still missing for `payment` on this device. */
+	getMissingPaymentFields(payment) {
+		return this.payments.missingFields(payment);
+	}
+	/** Order total minus PAID (and confirm-after-inject) intents. */
+	getRemainingAmount() {
+		return this.payments.remaining();
+	}
+	/** Places the order if needed and charges `payment` (all or part). */
+	pay(payment, options) {
+		return this.payments.pay(payment, options);
+	}
+	/** 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();
+	}
+	/** Terminal admin operation (init, test, closeBatch, status, extra). */
+	runPaymentTerminal(payment, key) {
+		return this.payments.runTerminal(payment, key);
+	}
 	/** Applies lines/redeem, replaying redemption steps and totals. */
 	commitLines(patch) {
 		const lines = patch.lines ?? this.draft.lines;
@@ -3746,20 +5510,27 @@ const childrenOf = (lines, parentUid) => {
 	children.sort((a, b) => a.id.localeCompare(b.id));
 	return children;
 };
-const matchModifier = (parent, childId, lookup) => {
-	for (const groupId of parent.pricing.modifier_group_ids) if (lookup.modifierGroupsById[groupId]?.modifier_ids.includes(childId)) return true;
-	return false;
-};
 const collectUnmatchedModifiers = (lines, lookup, parentProductId, parentUid, out) => {
 	const parent = lookup.productsById[parentProductId];
 	if (!parent) return;
 	for (const child of lines) {
 		if (child.parent_uid !== parentUid) continue;
 		if (child.type === "FEE") continue;
-		if (!matchModifier(parent, child.id, lookup)) {
+		const childProduct = lookup.productsById[child.id];
+		if (childProduct && isVariantBase(childProduct)) {
+			pushLineIssue(out, child.uid, { code: "VARIANT_BASE_NOT_ORDERABLE" });
+			continue;
+		}
+		const match = matchModifierLine(lookup, parent, child.id);
+		if (!match) {
 			pushLineIssue(out, child.uid, { code: "MODIFIER_NOT_FOUND" });
 			continue;
 		}
+		const base = lookup.productsById[match.modifierId];
+		if (match.selection && childProduct && base && !resolvesFromBase(lookup, base, childProduct)) {
+			pushLineIssue(out, child.uid, { code: "VARIANT_NOT_OFFERED" });
+			continue;
+		}
 		collectUnmatchedModifiers(lines, lookup, child.id, child.uid, out);
 	}
 };
@@ -3969,6 +5740,11 @@ const validateProductRoot = (root, lines, lookup, locale, out) => {
 		pushLineIssue(out, root.uid, { code: "PRODUCT_NOT_FOUND" });
 		return;
 	}
+	if (isVariantBase(product)) {
+		pushLineIssue(out, root.uid, { code: "VARIANT_BASE_NOT_ORDERABLE" });
+		return;
+	}
+	if ((product.pricing.variants ?? []).length > 0 && !isOfferedVariant(lookup, product)) pushLineIssue(out, root.uid, { code: "VARIANT_NOT_OFFERED" });
 	const status = product.availability.status;
 	if (status === "HIDDEN") pushLineIssue(out, root.uid, { code: "HIDDEN" });
 	if (status === "OUT_OF_STOCK") pushLineIssue(out, root.uid, { code: "OUT_OF_STOCK" });
@@ -4203,6 +5979,12 @@ const issuesForTree = (lines, rootUid, lineIssues) => {
 	}
 	return issues;
 };
+const UNRECOVERABLE = /* @__PURE__ */ new Set([
+	"PRODUCT_NOT_FOUND",
+	"HIDDEN",
+	"VARIANT_BASE_NOT_ORDERABLE",
+	"VARIANT_NOT_OFFERED"
+]);
 const collectOrderLineDiffs = (input) => {
 	const locale = input.locale ?? "en_us";
 	const roots = input.lines.filter((line) => {
@@ -4215,9 +5997,7 @@ const collectOrderLineDiffs = (input) => {
 		if (issues.length === 0) continue;
 		const treeUids = descendantUids(input.lines, root.uid);
 		const previous = input.lines.filter((line) => treeUids.has(line.uid));
-		const missing = issues.some((issue) => {
-			return issue.code === "PRODUCT_NOT_FOUND" || issue.code === "HIDDEN";
-		});
+		const missing = issues.some((issue) => UNRECOVERABLE.has(issue.code));
 		const product = lookup?.productsById[root.id];
 		if (missing || !product || !lookup) {
 			diffs.push({
@@ -4249,6 +6029,201 @@ const collectOrderLineDiffs = (input) => {
 	return diffs;
 };
 //#endregion
+//#region src/logs/serializeError.ts
+const UNKNOWN_MESSAGE = "Unknown error";
+const MAX_CAUSE_DEPTH = 3;
+const safeStringify = (value) => {
+	try {
+		const json = JSON.stringify(value);
+		return json === void 0 ? String(value) : json;
+	} catch {
+		return String(value);
+	}
+};
+const messageOf = (value) => {
+	if (value instanceof Error) return value.message || value.name;
+	if (typeof value === "string") return value;
+	if (value && typeof value === "object" && "message" in value) {
+		const message = value.message;
+		if (typeof message === "string") return message;
+	}
+	if (value === void 0) return "";
+	return safeStringify(value);
+};
+/** `TypeError: boom ← caused by: Error: socket closed` style chain. */
+const describeCause = (cause, depth = 0) => {
+	if (cause instanceof Error) {
+		const head = `${cause.name}: ${cause.message}`;
+		const inner = cause.cause;
+		if (inner === void 0 || depth >= MAX_CAUSE_DEPTH) return head;
+		return `${head} ← caused by: ${describeCause(inner, depth + 1)}`;
+	}
+	return messageOf(cause);
+};
+const nameOf = (value) => {
+	if (value instanceof Error) return value.name;
+	if (value && typeof value === "object" && "name" in value) {
+		const name = value.name;
+		if (typeof name === "string") return name;
+	}
+	return null;
+};
+const stackOf = (value) => {
+	if (value && typeof value === "object" && "stack" in value) {
+		const stack = value.stack;
+		if (typeof stack === "string" && stack) return stack;
+	}
+	return null;
+};
+const causeOf = (value) => {
+	if (!value || typeof value !== "object" || !("cause" in value)) return null;
+	const cause = value.cause;
+	if (cause === void 0 || cause === null) return null;
+	return describeCause(cause) || null;
+};
+/** Accepts anything a `catch` can receive. */
+const serializeError = (value) => {
+	const message = truncate(messageOf(value).trim() || UNKNOWN_MESSAGE, LOG_LIMITS.message);
+	const name = nameOf(value);
+	const stack = stackOf(value);
+	const cause = causeOf(value);
+	const e1 = { name: name ? truncate(name, LOG_LIMITS.errorName) : null };
+	const e2 = { stack: stack ? truncate(stack, LOG_LIMITS.stack) : null };
+	const e3 = { cause: cause ? truncate(cause, LOG_LIMITS.cause) : null };
+	return {
+		message,
+		error: {
+			...e1,
+			...e2,
+			...e3
+		}
+	};
+};
+//#endregion
+//#region src/logs/log.ts
+const LOGS_PATH = "/api/storefront/v1/logs";
+const POS_LOGS_PATH = "/api/storefront/v1/pos/logs";
+const FLUSH_DELAY_MS = 500;
+let queue = [];
+let timer = null;
+const optionalText = (value, max) => {
+	const trimmed = value?.trim();
+	if (!trimmed) return null;
+	return truncate(trimmed, max);
+};
+const buildEntry = (level, message, options, error) => {
+	const text = typeof message === "string" ? message.trim() : "";
+	if (!text) return null;
+	const b1 = {
+		level,
+		message: truncate(text, LOG_LIMITS.message)
+	};
+	const b2 = { alias: optionalText(options.alias, LOG_LIMITS.alias) };
+	const b3 = { detail: optionalText(options.detail, LOG_LIMITS.detail) };
+	const b4 = { status: optionalText(options.status, LOG_LIMITS.status) };
+	const b5 = {
+		error: error ?? null,
+		occurred_at: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	return {
+		...b1,
+		...b2,
+		...b3,
+		...b4,
+		...getLogContext(),
+		...b5
+	};
+};
+const isAuthConfigured = () => {
+	try {
+		getBaseUrl();
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** Browsers cap keepalive bodies at 64 KB; bigger batches send normally. */
+const postInit = (body) => {
+	return {
+		method: "POST",
+		body,
+		keepalive: body.length < LOG_LIMITS.keepaliveBytes
+	};
+};
+const sendPos = async (device, logs) => {
+	const fetchImpl = device.http.fetchImpl ?? fetch;
+	const url = `${resolveBaseUrl(device.http.baseUrl)}${POS_LOGS_PATH}`;
+	const { device_uid, device_secret } = device;
+	const body = JSON.stringify({
+		device_uid,
+		device_secret,
+		logs
+	});
+	const headers = { "Content-Type": "application/json" };
+	return (await fetchImpl(url, {
+		...postInit(body),
+		headers
+	})).ok;
+};
+const sendBatch = async (logs) => {
+	try {
+		const device = getPosLogDevice();
+		if (device) return await sendPos(device, logs);
+		if (!isAuthConfigured()) return false;
+		await storefrontJson(LOGS_PATH, postInit(JSON.stringify({ logs })));
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** Sends queued logs now; resolves once every batch has been attempted. */
+const flushLogs = async () => {
+	if (timer) clearTimeout(timer);
+	timer = null;
+	const pending = queue;
+	queue = [];
+	const jobs = [];
+	for (let i = 0; i < pending.length; i += LOG_LIMITS.batch) {
+		const chunk = pending.slice(i, i + LOG_LIMITS.batch);
+		const entries = chunk.map((item) => item.entry);
+		const job = sendBatch(entries).then((sent) => {
+			for (const item of chunk) item.resolve(sent);
+		});
+		jobs.push(job);
+	}
+	await Promise.all(jobs);
+};
+const enqueue = (entry) => {
+	return new Promise((resolve) => {
+		queue.push({
+			entry,
+			resolve
+		});
+		if (queue.length >= LOG_LIMITS.batch) {
+			flushLogs();
+			return;
+		}
+		if (!timer) timer = setTimeout(() => void flushLogs(), FLUSH_DELAY_MS);
+	});
+};
+/**
+* Reports a log to the merchant dashboard with the SDK's current context
+* (channel, fulfillment, store, brand, device). Never throws; resolves to
+* `false` when the log could not be delivered.
+*/
+const log = (level, message, options = {}) => {
+	const entry = buildEntry(level, message, options);
+	if (!entry) return Promise.resolve(false);
+	return enqueue(entry);
+};
+/** `log("error", …)` with message, name, stack and cause read from `error`. */
+const logError = (error, options = {}) => {
+	const { message, error: info } = serializeError(error);
+	const entry = buildEntry("error", message, options, info);
+	if (!entry) return Promise.resolve(false);
+	return enqueue(entry);
+};
+//#endregion
 //#region src/rules/assert.ts
 const assert = (value, message) => {
 	if (value) return;
@@ -4362,7 +6337,8 @@ const MULTI_CUSTOM_TYPES = [
 	"Fulfillments",
 	"Stores",
 	"Channels",
-	"Brands"
+	"Brands",
+	"Payments"
 ];
 const isMultiCustomType = (type) => {
 	return MULTI_CUSTOM_TYPES.includes(type);
@@ -5248,6 +7224,10 @@ var RulesEngine = class {
 		throw new Error(msg);
 	};
 	assertCustom = (condition) => {
+		if (condition.type === "Payment" || condition.type === "Payments") {
+			const payment = this.getDependency("payment", condition.type);
+			return matchCustom(condition, payment.id);
+		}
 		const order = this.getDependency("order", condition.type);
 		return assertCustom(condition, order);
 	};
@@ -5539,4 +7519,316 @@ const paymentMatchesClientConditions = (conditions, order, options) => {
 	return Boolean(engine.matchOrConditions(groups).match);
 };
 //#endregion
-export { DEFAULT_RECOMMENDATION_TYPES, Order, OrderSyncPendingError, OrderValidationError, RecurringDateCron, RulesEngine, StorefrontHttpError, addLines, auth, buildCustomerSnapshot, collectOrderLineDiffs, countCartProducts, createSession, currentNodes, defaultConditionError, flattenMenuCategories, fromOrderLines, genId, genOrderId, getScheduleWindow, indexMenu, isCheckoutFieldFilled, isDeviceNotLinked, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isStorefrontNotFound, listMenusStream, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, resolveCheckout, services, storefrontJson, toOrderLines, validateOrderAgainstMenu, visitedStates };
+//#region src/card/card.ts
+const DEFAULT_GAPS = [
+	4,
+	8,
+	12,
+	16
+];
+const spec = (s) => s;
+/** Detection order matters: narrower prefixes first. */
+const CARD_BRANDS = [
+	spec({
+		brand: "amex",
+		label: "American Express",
+		pattern: /^3[47]/,
+		lengths: [15],
+		gaps: [4, 10],
+		cvcLengths: [4]
+	}),
+	spec({
+		brand: "diners",
+		label: "Diners Club",
+		pattern: /^3(?:0[0-59]|[689])/,
+		lengths: [
+			14,
+			16,
+			19
+		],
+		gaps: [4, 10],
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "jcb",
+		label: "JCB",
+		pattern: /^35(?:2[89]|[3-8])/,
+		lengths: [
+			16,
+			17,
+			18,
+			19
+		],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "visa",
+		label: "Visa",
+		pattern: /^4/,
+		lengths: [
+			13,
+			16,
+			19
+		],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "mastercard",
+		label: "Mastercard",
+		pattern: /^(?:5[1-5]|222[1-9]|22[3-9]|2[3-6]|27[01]|2720)/,
+		lengths: [16],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "discover",
+		label: "Discover",
+		pattern: /^(?:6011|64[4-9]|65)/,
+		lengths: [
+			16,
+			17,
+			18,
+			19
+		],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	}),
+	spec({
+		brand: "unionpay",
+		label: "UnionPay",
+		pattern: /^62/,
+		lengths: [
+			16,
+			17,
+			18,
+			19
+		],
+		gaps: DEFAULT_GAPS,
+		cvcLengths: [3]
+	})
+];
+const UNKNOWN_SPEC = {
+	brand: "unknown",
+	label: "",
+	pattern: /^$/,
+	lengths: [
+		12,
+		13,
+		14,
+		15,
+		16,
+		17,
+		18,
+		19
+	],
+	gaps: DEFAULT_GAPS,
+	cvcLengths: [3, 4]
+};
+const last = (values) => values[values.length - 1] ?? 0;
+const cardDigits = (value) => value.replace(/\D/g, "");
+/** Mod-10 checksum. Expects digits only (non-digits are ignored). */
+const luhnCheck = (value) => {
+	const digits = cardDigits(value);
+	if (!digits) return false;
+	let sum = 0;
+	for (let i = 0; i < digits.length; i++) {
+		let digit = Number(digits[digits.length - 1 - i]);
+		if (i % 2 === 1) {
+			digit *= 2;
+			if (digit > 9) digit -= 9;
+		}
+		sum += digit;
+	}
+	return sum % 10 === 0;
+};
+const cardBrandSpec = (brand) => {
+	return CARD_BRANDS.find((item) => item.brand === brand) ?? UNKNOWN_SPEC;
+};
+/** Brand from the typed prefix; `unknown` until the prefix is unambiguous. */
+const detectCardBrand = (value) => {
+	const digits = cardDigits(value);
+	if (!digits) return "unknown";
+	return CARD_BRANDS.find((item) => item.pattern.test(digits))?.brand ?? "unknown";
+};
+const toPaymentCardBrand = (brand) => {
+	if (brand === "jcb" || brand === "unionpay" || brand === "unknown") return "other";
+	return brand;
+};
+const cardNumberMaxLength = (brand) => {
+	return last(cardBrandSpec(brand).lengths);
+};
+/** Space positions for a PAN of `length` digits (Diners 14 → 4-6-4). */
+const cardNumberGaps = (brand, length) => {
+	if (brand === "diners" && length > 14) return DEFAULT_GAPS;
+	return cardBrandSpec(brand).gaps;
+};
+/** Digits only, capped to the brand max length, grouped with spaces. */
+const formatCardNumber = (value) => {
+	const raw = cardDigits(value);
+	const brand = detectCardBrand(raw);
+	const digits = raw.slice(0, cardNumberMaxLength(brand));
+	const gaps = cardNumberGaps(brand, digits.length);
+	let out = "";
+	for (let i = 0; i < digits.length; i++) {
+		if (i > 0 && gaps.includes(i)) out += " ";
+		out += digits[i];
+	}
+	return out;
+};
+/** Caret index in `formatted` right after its `digitCount`-th digit. */
+const caretAfterDigits = (formatted, digitCount) => {
+	if (digitCount <= 0) return 0;
+	let seen = 0;
+	for (let i = 0; i < formatted.length; i++) {
+		if (/\d/.test(formatted[i] ?? "")) seen += 1;
+		if (seen === digitCount) return i + 1;
+	}
+	return formatted.length;
+};
+const validateCardNumber = (value) => {
+	const digits = cardDigits(value);
+	if (!digits) return "required";
+	const { lengths } = cardBrandSpec(detectCardBrand(digits));
+	if (digits.length < (lengths[0] ?? 0)) return "incomplete";
+	if (!lengths.includes(digits.length)) return "incomplete";
+	if (!luhnCheck(digits)) return "invalid";
+	return null;
+};
+/** Ready to move focus on: a valid length for the brand that passes Luhn. */
+const isCardNumberComplete = (value) => {
+	const digits = cardDigits(value);
+	const brand = detectCardBrand(digits);
+	if (brand === "unknown") return digits.length === cardNumberMaxLength(brand) && luhnCheck(digits);
+	return validateCardNumber(digits) === null;
+};
+/** Full-length PAN that fails Luhn — safe to flag while the user types. */
+const isCardNumberDefinitelyInvalid = (value) => {
+	const digits = cardDigits(value);
+	const max = cardNumberMaxLength(detectCardBrand(digits));
+	return digits.length === max && !luhnCheck(digits);
+};
+const SEPARATED_EXPIRY = /^(\d{1,2})\s*[/\-.\s]\s*(\d*)$/;
+const shortYear = (year) => {
+	if (year.length >= 4) return year.slice(2, 4);
+	return year.slice(0, 2);
+};
+const joinExpiry = (month, year) => {
+	if (!year) return month;
+	return `${month}/${year}`;
+};
+/**
+* `MM/YY` as the user types or pastes: `4` → `04`, `13` → `01/3`,
+* `12/2030` → `12/30`. The slash only appears once a year digit exists so
+* backspace never gets stuck.
+*/
+const formatExpiry = (value) => {
+	const raw = value.trim();
+	const separated = SEPARATED_EXPIRY.exec(raw);
+	if (separated) {
+		const [, monthPart = "", yearPart = ""] = separated;
+		const month = monthPart.length === 1 && monthPart !== "0" ? `0${monthPart}` : monthPart;
+		return joinExpiry(month, shortYear(yearPart));
+	}
+	const all = cardDigits(raw);
+	const digits = all.length === 6 ? `${all.slice(0, 2)}${all.slice(4)}` : all;
+	const first = digits[0];
+	if (!first) return "";
+	if (Number(first) > 1) return joinExpiry(`0${first}`, digits.slice(1, 3));
+	if (digits.length === 1) return digits;
+	const month = digits.slice(0, 2);
+	if (Number(month) > 12) return joinExpiry(`0${first}`, digits.slice(1, 3));
+	return joinExpiry(month, digits.slice(2, 4));
+};
+const parseExpiry = (value) => {
+	const match = /^(\d{2})\/(\d{2})$/.exec(value.trim());
+	if (!match) return null;
+	return {
+		month: Number(match[1]),
+		year: 2e3 + Number(match[2])
+	};
+};
+const isExpiryComplete = (value) => {
+	return /^\d{2}\/\d{2}$/.test(value.trim());
+};
+const MAX_EXPIRY_YEARS = 20;
+const validateExpiry = (value, now = /* @__PURE__ */ new Date()) => {
+	if (!value.trim()) return "required";
+	const parsed = parseExpiry(value);
+	if (!parsed) return "incomplete";
+	const { month, year } = parsed;
+	if (month < 1 || month > 12) return "invalid_month";
+	const currentYear = now.getFullYear();
+	const currentMonth = now.getMonth() + 1;
+	if (year < currentYear) return "expired";
+	if (year === currentYear && month < currentMonth) return "expired";
+	if (year > currentYear + MAX_EXPIRY_YEARS) return "too_far";
+	return null;
+};
+const cvcMaxLength = (brand) => {
+	return last(cardBrandSpec(brand).cvcLengths);
+};
+const formatCvc = (value, brand) => {
+	return cardDigits(value).slice(0, cvcMaxLength(brand));
+};
+const validateCvc = (value, brand) => {
+	const digits = cardDigits(value);
+	if (!digits) return "required";
+	if (!cardBrandSpec(brand).cvcLengths.includes(digits.length)) return "incomplete";
+	return null;
+};
+const isCvcComplete = (value, brand) => {
+	return cardDigits(value).length === cvcMaxLength(brand);
+};
+const CARDHOLDER_CHARS = /^[\p{L}\p{M}][\p{L}\p{M}'’. -]*$/u;
+const CARDHOLDER_MAX = 100;
+const normalizeCardholderName = (value) => {
+	return value.trim().replace(/\s+/g, " ");
+};
+const validateCardholderName = (value) => {
+	const name = normalizeCardholderName(value);
+	if (!name) return "required";
+	if (!CARDHOLDER_CHARS.test(name)) return "invalid_chars";
+	if (name.replace(/[^\p{L}]/gu, "").length < 2) return "too_short";
+	if (name.length > CARDHOLDER_MAX) return "too_long";
+	return null;
+};
+const previewLength = (brand) => {
+	if (brand === "amex") return 15;
+	if (brand === "diners") return 14;
+	return 16;
+};
+/**
+* Digit slots for a card preview, grouped like the formatted number. Middle
+* digits are masked as `•`; first and last groups stay readable.
+*/
+const cardPreviewGroups = (value) => {
+	const raw = cardDigits(value);
+	const brand = detectCardBrand(raw);
+	const digits = raw.slice(0, cardNumberMaxLength(brand));
+	const total = Math.max(previewLength(brand), digits.length);
+	const gaps = cardNumberGaps(brand, total);
+	const groups = [];
+	let group = [];
+	for (let i = 0; i < total; i++) {
+		if (i > 0 && gaps.includes(i)) {
+			groups.push(group);
+			group = [];
+		}
+		const digit = digits[i];
+		const masked = i >= 4 && i < total - 4;
+		if (digit === void 0) group.push({
+			char: "",
+			filled: false
+		});
+		else group.push({
+			char: masked ? "•" : digit,
+			filled: true
+		});
+	}
+	groups.push(group);
+	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, visitedStates };