@fire-spark/core 0.0.1 → 0.0.3

package/dist/index.js

@@ -27,10 +27,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 +92,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 +121,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 +866,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 +913,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 +948,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 +1004,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 +1111,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 +1121,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 +1136,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 +1173,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 +1197,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 +1407,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 +1484,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,11 +1493,139 @@ const indexMenu = (menu) => {
 	return {
 		productsById,
 		modifierGroupsById,
+		variantGroupsById,
 		categoriesById,
 		recommendationsById
 	};
 };
 //#endregion
+//#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 = () => {
@@ -1209,62 +1799,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 +1859,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);
@@ -1921,8 +2478,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
@@ -1978,6 +2535,83 @@ const services = {
 		isKioskUnauthorized
 	}
 };
+const DISALLOWED = /[^A-Za-z0-9]/g;
+const ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+const BYTE_LIMIT = 252;
+const toLiteral = (value, fallback) => {
+	const trimmed = (value ?? "").trim();
+	const source = trimmed === "" ? fallback : trimmed;
+	if (source === void 0) throw new Error("Id literal must not be empty");
+	const cleaned = source.replace(DISALLOWED, "");
+	if (cleaned === "") throw new Error(`Id literal has no alphanumeric characters: "${source}"`);
+	return cleaned.slice(0, 32);
+};
+const randomChars = (length) => {
+	const c = globalThis.crypto;
+	if (typeof c?.getRandomValues !== "function") throw new Error("crypto.getRandomValues is required");
+	let out = "";
+	const bytes = new Uint8Array(length * 2);
+	while (out.length < length) {
+		c.getRandomValues(bytes);
+		for (const byte of bytes) {
+			if (byte >= BYTE_LIMIT) continue;
+			out += ALPHABET[byte % 36];
+			if (out.length === length) break;
+		}
+	}
+	return out;
+};
+const assertShape = (parts) => {
+	if (!parts.some((part) => part.kind === "hash")) throw new Error("Id requires a random hash part");
+	const first = parts[0];
+	const last = parts[parts.length - 1];
+	if (first?.kind === "separator" || last?.kind === "separator") throw new Error("Id must not start or end with a separator");
+	parts.forEach((part, index) => {
+		if (part.kind !== "separator") return;
+		if (parts[index - 1]?.kind !== "separator") return;
+		throw new Error("Id must not contain consecutive separators");
+	});
+};
+const render = (part) => {
+	if (part.kind === "literal") return part.value;
+	if (part.kind === "separator") return "-";
+	return randomChars(part.length);
+};
+const builder = (parts) => {
+	return {
+		literal: (value, fallback) => {
+			const literal = {
+				kind: "literal",
+				value: toLiteral(value, fallback)
+			};
+			return builder([...parts, literal]);
+		},
+		separator: () => builder([...parts, { kind: "separator" }]),
+		hash: (length = 12) => {
+			if (!Number.isInteger(length) || length < 12) throw new Error(`Id hash must be an integer ≥ 12, got ${length}`);
+			return builder([...parts, {
+				kind: "hash",
+				length
+			}]);
+		},
+		build: () => {
+			assertShape(parts);
+			const id = parts.map(render).join("");
+			if (id.length > 64) throw new Error(`Id must be ≤ 64 characters`);
+			return id;
+		}
+	};
+};
+/**
+* Safe id builder: `genId().literal("ord").separator().hash(12).build()`.
+* Literals are cleaned to `[A-Za-z0-9]`; `-` is the only separator and a
+* random hash of at least 12 characters is required.
+*/
+const genId = () => builder([]);
+/** `ord-<store>-<hash>`; `nostore` when the store id is blank. */
+const genOrderId = (storeId) => {
+	return genId().literal("ord").separator().literal(storeId, "nostore").separator().hash().build();
+};
 //#endregion
 //#region src/order/retry.ts
 const defaultSleep = (ms) => {
@@ -2037,6 +2671,8 @@ const createFlushController = (runtime) => {
 		const b5 = { customer: order.customer };
 		const b6 = { payment_intents: order.payment_intents };
 		const b7 = { payment_status: order.payment_status };
+		const b8 = { redeem: order.redeem };
+		const b9 = { redemption_steps: order.redemption_steps };
 		return {
 			...b1,
 			...b2,
@@ -2044,7 +2680,9 @@ const createFlushController = (runtime) => {
 			...b4,
 			...b5,
 			...b6,
-			...b7
+			...b7,
+			...b8,
+			...b9
 		};
 	};
 	const insertBody = (order) => {
@@ -2068,6 +2706,8 @@ const createFlushController = (runtime) => {
 		};
 		const b7 = { payment_intents: order.payment_intents };
 		const b8 = { payment_status: order.payment_status };
+		const b9 = { redeem: order.redeem };
+		const b10 = { redemption_steps: order.redemption_steps };
 		return {
 			...b1,
 			...b2,
@@ -2076,7 +2716,9 @@ const createFlushController = (runtime) => {
 			...b5,
 			...b6,
 			...b7,
-			...b8
+			...b8,
+			...b9,
+			...b10
 		};
 	};
 	const flushNow = () => {
@@ -2564,6 +3206,227 @@ const emptyTotals = (currency = "USD") => {
 	};
 };
 //#endregion
+//#region src/order/redemptions.ts
+const ORDER_KEY = "ORDER";
+/** Same rules as `vOrders.redeem()`; throws on invalid input. */
+const buildRedeem = (input) => {
+	const { reward_id, quantity, discount_rate, discount_amount } = input;
+	const { expires_at } = input;
+	if (!reward_id.trim()) throw new Error("Redeem requires reward_id");
+	if (!Number.isInteger(quantity) || quantity < 1) throw new Error("Redeem quantity must be an integer ≥ 1");
+	if (discount_rate === void 0 && discount_amount === void 0) throw new Error("Redeem requires discount_rate or discount_amount");
+	const rate = discount_rate ?? 0;
+	if (!(rate >= 0 && rate <= 1)) throw new Error("Redeem discount_rate must be between 0 and 1");
+	if (discount_amount !== void 0 && !(discount_amount > 0)) throw new Error("Redeem discount_amount must be > 0");
+	if (expires_at !== void 0 && Number.isNaN(Date.parse(expires_at))) throw new Error("Redeem expires_at must be an ISO datetime");
+	const redeem = {
+		reward_id,
+		quantity
+	};
+	if (discount_rate !== void 0) redeem.discount_rate = discount_rate;
+	if (discount_amount !== void 0) redeem.discount_amount = discount_amount;
+	if (expires_at !== void 0) redeem.expires_at = expires_at;
+	return redeem;
+};
+/**
+* Takes `quantity` units of `reward_id` off the latest entries first, so the
+* earlier redeems keep their step position. Entries that reach 0 are removed.
+*/
+const subtractRedeem = (items, reward_id, quantity) => {
+	if (!Number.isInteger(quantity) || quantity < 1) throw new Error("Redeem quantity must be an integer ≥ 1");
+	let pending = quantity;
+	const kept = [];
+	for (let i = items.length - 1; i >= 0; i--) {
+		const item = items[i];
+		if (pending === 0 || item.reward_id !== reward_id) {
+			kept.unshift(item);
+			continue;
+		}
+		const taken = Math.min(item.quantity, pending);
+		pending -= taken;
+		const rest = item.quantity - taken;
+		if (rest > 0) kept.unshift({
+			...item,
+			quantity: rest
+		});
+	}
+	return kept;
+};
+const redemptionTargetKey = (target) => {
+	if (target.target === "ORDER") return ORDER_KEY;
+	return `LINE:${target.target_id ?? ""}`;
+};
+/** Only root lines own redeems; child-line redeems are never applied. */
+const redeemPools = (lines, redeem) => {
+	const pools = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const items = line.redeem ?? [];
+		if (line.parent_uid != null || items.length === 0) continue;
+		const target = {
+			target: "LINE",
+			target_id: line.uid
+		};
+		const pool = items.map((item) => ({
+			...target,
+			redeem: item
+		}));
+		pools.set(redemptionTargetKey(target), pool);
+	}
+	const order = { target: "ORDER" };
+	const pool = redeem.map((item) => ({
+		...order,
+		redeem: item
+	}));
+	pools.set(ORDER_KEY, pool);
+	return pools;
+};
+/**
+* Pairs the k-th step of a target with the k-th redeem of that target, in
+* step order. Steps without a matching redeem are dropped; redeems without a
+* step are appended (lines first, then order).
+*/
+const sequenceRedeems = (lines, redeem, steps) => {
+	const pools = redeemPools(lines, redeem);
+	const cursors = /* @__PURE__ */ new Map();
+	const sequence = [];
+	for (const step of steps) {
+		const key = redemptionTargetKey(step);
+		const at = cursors.get(key) ?? 0;
+		const next = pools.get(key)?.[at];
+		if (!next || next.redeem.reward_id !== step.reward_id) continue;
+		cursors.set(key, at + 1);
+		sequence.push(next);
+	}
+	for (const [key, pool] of pools) sequence.push(...pool.slice(cursors.get(key) ?? 0));
+	return sequence;
+};
+const minBig = (a, b) => {
+	return a.lt(b) ? a : b;
+};
+const left = (run) => {
+	return run.base.minus(run.discount);
+};
+const rateOf = (discount, base) => {
+	if (base.lte(0)) return 0;
+	return minBig(discount.div(base), new Big(1)).toNumber();
+};
+const snapshot = (run) => {
+	const b1 = {
+		value: left(run).toNumber(),
+		quantity: run.quantity
+	};
+	const b2 = { discount_amount: run.discount.toNumber() };
+	const b3 = { discount_rate: rateOf(run.discount, run.base) };
+	return {
+		...b1,
+		...b2,
+		...b3
+	};
+};
+/**
+* Rate compounds once per reward unit over the remaining value; amount is
+* per unit. With both, the rate discount is capped at `amount × quantity`.
+*/
+const redeemDiscount = (redeem, remaining) => {
+	const { quantity, discount_rate, discount_amount } = redeem;
+	let cap = null;
+	if (discount_amount !== void 0) cap = new Big(discount_amount).times(quantity);
+	if (discount_rate === void 0) return cap ?? new Big(0);
+	const kept = new Big(1).minus(discount_rate).pow(quantity);
+	const byRate = remaining.times(new Big(1).minus(kept));
+	return cap ? minBig(byRate, cap) : byRate;
+};
+const runningFor = (base, quantity) => {
+	return {
+		base: new Big(base),
+		discount: new Big(0),
+		quantity
+	};
+};
+/**
+* Replays every redeem in persisted step order over the root lines' group
+* totals. A discount never exceeds what is left on its target or the order.
+*/
+const computeRedemptionSteps = (lines, redeem, steps) => {
+	const sequence = sequenceRedeems(lines, redeem, steps);
+	if (sequence.length === 0) return [];
+	const roots = lines.filter((line) => line.parent_uid == null);
+	let orderBase = new Big(0);
+	const lineRuns = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		orderBase = orderBase.plus(root.group_total);
+		lineRuns.set(root.uid, runningFor(root.group_total, root.quantity));
+	}
+	const order = runningFor(orderBase, 1);
+	return sequence.map((item) => {
+		const line = item.target_id ? lineRuns.get(item.target_id) : void 0;
+		const before = snapshot(order);
+		const targetBefore = line ? snapshot(line) : void 0;
+		const orderLeft = left(order);
+		const targetLeft = line ? left(line) : orderLeft;
+		const raw = redeemDiscount(item.redeem, targetLeft);
+		const discount = minBig(minBig(raw, targetLeft), orderLeft);
+		order.discount = order.discount.plus(discount);
+		if (line) line.discount = line.discount.plus(discount);
+		const action = discount.gt(0) ? "UPDATE" : "READ";
+		const { reward_id, quantity } = item.redeem;
+		const b1 = {
+			reward_id,
+			reward_quantity: quantity,
+			target: item.target
+		};
+		const b2 = item.target_id ? { target_id: item.target_id } : {};
+		const b3 = {
+			action,
+			discount_amount: discount.toNumber()
+		};
+		const b4 = {
+			before,
+			after: snapshot(order)
+		};
+		let b5 = {};
+		if (line) b5 = {
+			target_before: targetBefore,
+			target_after: snapshot(line)
+		};
+		return {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5
+		};
+	});
+};
+/** Subtract redemption discounts from line-based order totals. */
+const applyRedemptionTotals = (totals, steps) => {
+	if (steps.length === 0) return totals;
+	let redeemed = new Big(0);
+	for (const step of steps) redeemed = redeemed.plus(step.discount_amount);
+	const discountTotal = new Big(totals.discount_total).plus(redeemed);
+	const subtotal = new Big(totals.subtotal);
+	const discount_rate = rateOf(discountTotal, subtotal);
+	const discount_total = discountTotal.toNumber();
+	const total = new Big(totals.total).minus(redeemed).toNumber();
+	return {
+		...totals,
+		discount_rate,
+		discount_total,
+		total
+	};
+};
+/** Steps + totals for a set of lines and redeems, keeping step order. */
+const recomputeRedemptions = (input) => {
+	const { lines, redeem, currency } = input;
+	const steps = input.redemption_steps;
+	const redemption_steps = computeRedemptionSteps(lines, redeem, steps);
+	const lineTotals = recomputeTotals(lines, currency);
+	return {
+		redemption_steps,
+		totals: applyRedemptionTotals(lineTotals, redemption_steps)
+	};
+};
+//#endregion
 //#region src/order/Order.ts
 const cloneOrder = (order) => {
 	return structuredClone(order);
@@ -2585,7 +3448,7 @@ const optionalBrandId = (value) => {
 const buildInsertFromOptions = (options) => {
 	if (!options.scope) throw new Error("Order requires scope when fromOrderId is omitted");
 	if (!options.customer) throw new Error("Order requires customer when fromOrderId is omitted");
-	const orderId = options.orderId ?? `ord-${randomUUID().slice(0, 8)}`;
+	const orderId = options.orderId ?? genOrderId(options.scope.store_id);
 	const brand_id = optionalBrandId(options.scope.brand_id);
 	const customer = buildCustomerSnapshot(options.customer);
 	const is_anonymous = options.isAnonymous ?? false;
@@ -2606,7 +3469,8 @@ const buildInsertFromOptions = (options) => {
 	};
 	const b5 = {
 		totals: emptyTotals(),
-		metadata: {}
+		metadata: {},
+		redemption_steps: []
 	};
 	return {
 		...b1,
@@ -2617,8 +3481,8 @@ const buildInsertFromOptions = (options) => {
 	};
 };
 const buildInsertFromSource = (options, source) => {
-	const orderId = options.orderId ?? `ord-${randomUUID().slice(0, 8)}`;
 	const store_id = options.scope?.store_id ?? source.store_id;
+	const orderId = options.orderId ?? genOrderId(store_id);
 	const channel_id = options.scope?.channel_id ?? source.channel_id;
 	const fulfillment_id = options.scope?.fulfillment_id ?? source.fulfillment_id;
 	let brand_id = optionalBrandId(source.brand_id);
@@ -2627,7 +3491,13 @@ const buildInsertFromSource = (options, source) => {
 	if (options.customer) customer = buildCustomerSnapshot(options.customer);
 	const lines = structuredClone(source.lines);
 	const is_anonymous = options.isAnonymous ?? source.is_anonymous;
-	const totals = recomputeTotals(lines, source.totals.currency);
+	const redeem = structuredClone(source.redeem ?? []);
+	const { redemption_steps, totals } = recomputeRedemptions({
+		lines,
+		redeem,
+		redemption_steps: source.redemption_steps ?? [],
+		currency: source.totals.currency
+	});
 	const b1 = {
 		id: orderId,
 		store_id,
@@ -2638,7 +3508,6 @@ const buildInsertFromSource = (options, source) => {
 		brand_id,
 		is_anonymous
 	};
-	const redeem = source.redeem ?? [];
 	const b3 = {
 		customer,
 		lines,
@@ -2649,13 +3518,14 @@ const buildInsertFromSource = (options, source) => {
 	return {
 		...b1,
 		...b2,
-		...b3
+		...b3,
+		redemption_steps
 	};
 };
 const toRedeem = (items) => {
 	return (items ?? []).map((item) => ({
 		...item,
-		amount: item.amount ?? 1
+		quantity: item.quantity ?? 1
 	}));
 };
 /** Local draft until the first mutating flush POSTs to the API. */
@@ -2708,7 +3578,10 @@ const buildLocalDraft = (insert) => {
 		totals,
 		metadata
 	};
-	const b6 = { payment_status };
+	const b6 = {
+		payment_status,
+		redemption_steps: insert.redemption_steps ?? []
+	};
 	const b7 = {
 		fulfillment_status: "IDLE",
 		status: "OPEN"
@@ -2924,54 +3797,89 @@ var Order = class Order {
 	}
 	addLine(lines) {
 		if (this.deleted) return;
-		const nextLines = addLines(this.draft.lines, lines);
-		this.draft = {
-			...this.draft,
-			lines: nextLines,
-			totals: recomputeTotals(nextLines, this.draft.totals.currency)
-		};
-		this.scheduleAfterMutate();
+		this.commitLines({ lines: addLines(this.draft.lines, lines) });
 	}
 	subtractLine(lineUid, quantity = 1) {
 		if (this.deleted) return;
-		const nextLines = subtractLine(this.draft.lines, lineUid, quantity);
-		this.draft = {
-			...this.draft,
-			lines: nextLines,
-			totals: recomputeTotals(nextLines, this.draft.totals.currency)
-		};
-		this.scheduleAfterMutate();
+		const p = [
+			this.draft.lines,
+			lineUid,
+			quantity
+		];
+		this.commitLines({ lines: subtractLine(...p) });
 	}
 	removeLine(lineUid) {
 		if (this.deleted) return;
-		const nextLines = removeLine(this.draft.lines, lineUid);
-		this.draft = {
-			...this.draft,
-			lines: nextLines,
-			totals: recomputeTotals(nextLines, this.draft.totals.currency)
-		};
-		this.scheduleAfterMutate();
+		this.commitLines({ lines: removeLine(this.draft.lines, lineUid) });
 	}
 	replaceLine(lineUid, lines) {
 		if (this.deleted) return;
-		const nextLines = replaceLine(this.draft.lines, lineUid, lines);
-		this.draft = {
-			...this.draft,
-			lines: nextLines,
-			totals: recomputeTotals(nextLines, this.draft.totals.currency)
-		};
-		this.scheduleAfterMutate();
+		const p = [
+			this.draft.lines,
+			lineUid,
+			lines
+		];
+		this.commitLines({ lines: replaceLine(...p) });
 	}
 	emptyOrder() {
 		if (this.deleted) return;
-		const nextLines = emptyLines();
-		this.draft = {
-			...this.draft,
-			lines: nextLines,
-			redeem: [],
-			totals: recomputeTotals(nextLines, this.draft.totals.currency)
-		};
-		this.scheduleAfterMutate();
+		this.commitLines({
+			lines: emptyLines(),
+			redeem: []
+		});
+	}
+	/**
+	* Appends a redeem to `line_uid` (root line) or to the order. Steps keep
+	* the order in which redeems were applied.
+	*/
+	applyRedeem(input) {
+		if (this.deleted) return;
+		const { line_uid, ...rest } = input;
+		const redeem = buildRedeem(rest);
+		if (line_uid === void 0) {
+			this.commitLines({ redeem: [...this.draft.redeem ?? [], redeem] });
+			return;
+		}
+		const line = this.draft.lines.find((item) => item.uid === line_uid);
+		if (!line || line.parent_uid != null || line.type === "FEE") throw new Error(`Redeem requires a root product line, got ${line_uid}`);
+		const lines = this.draft.lines.map((item) => {
+			if (item.uid !== line_uid) return item;
+			return {
+				...item,
+				redeem: [...item.redeem ?? [], redeem]
+			};
+		});
+		this.commitLines({ lines });
+	}
+	/**
+	* Removes `quantity` units of `reward_id` from `line_uid` or the order,
+	* latest applied first. Removing more units than applied clears them all.
+	*/
+	removeRedeem(input) {
+		if (this.deleted) return;
+		const { reward_id, quantity, line_uid } = input;
+		if (line_uid === void 0) {
+			const p = [
+				this.draft.redeem ?? [],
+				reward_id,
+				quantity
+			];
+			this.commitLines({ redeem: subtractRedeem(...p) });
+			return;
+		}
+		const lines = this.draft.lines.map((item) => {
+			if (item.uid !== line_uid) return item;
+			const p = [
+				item.redeem ?? [],
+				reward_id,
+				quantity
+			];
+			return {
+				...item,
+				redeem: subtractRedeem(...p)
+			};
+		});
+		this.commitLines({ lines });
 	}
 	setScope(scope) {
 		if (this.deleted) return;
@@ -3068,7 +3976,11 @@ var Order = class Order {
 			lines: draft.lines,
 			redeem: draft.redeem ?? []
 		};
-		const b5 = { totals: draft.totals };
+		const steps = draft.redemption_steps ?? [];
+		const b5 = {
+			totals: draft.totals,
+			redemption_steps: steps
+		};
 		const body = {
 			...b1,
 			...b2,
@@ -3092,6 +4004,25 @@ var Order = class Order {
 		this.synced = cloneOrder(next);
 		this.notify();
 	}
+	/** Applies lines/redeem, replaying redemption steps and totals. */
+	commitLines(patch) {
+		const lines = patch.lines ?? this.draft.lines;
+		const redeem = patch.redeem ?? this.draft.redeem ?? [];
+		const { redemption_steps, totals } = recomputeRedemptions({
+			lines,
+			redeem,
+			redemption_steps: this.draft.redemption_steps ?? [],
+			currency: this.draft.totals.currency
+		});
+		this.draft = {
+			...this.draft,
+			lines,
+			redeem,
+			redemption_steps,
+			totals
+		};
+		this.scheduleAfterMutate();
+	}
 	scheduleAfterMutate() {
 		this.flush.markDirtyDuringFlight();
 		this.notify();
@@ -3372,20 +4303,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);
 	}
 };
@@ -3595,6 +4533,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" });
@@ -3611,6 +4554,152 @@ const validateProductRoot = (root, lines, lookup, locale, out) => {
 	}
 	compareTrees(lines, expected, root.uid, expectedRoot.uid, out);
 };
+const isExpired = (redeem, now) => {
+	if (redeem.expires_at === void 0) return false;
+	return Date.parse(redeem.expires_at) <= now;
+};
+const expiredIssues = (redeem, now) => {
+	const issues = [];
+	redeem.forEach((item, index) => {
+		if (!isExpired(item, now)) return;
+		const field = `redeem.${index}.expires_at`;
+		issues.push({
+			code: "REDEEM_EXPIRED",
+			field,
+			actual: item.expires_at
+		});
+	});
+	return issues;
+};
+const redeemSignature = (items) => {
+	return items.map((item) => `${item.reward_id}:${item.quantity}`).join(",");
+};
+const stepSignature = (steps) => {
+	return steps.map((step) => `${step.reward_id}:${step.reward_quantity}`).join(",");
+};
+/** Every target's redeems must have one step each, in the same order. */
+const checkRedemptionTargets = (lines, redeem, steps, issues, lineIssues) => {
+	const byTarget = /* @__PURE__ */ new Map();
+	for (const step of steps) {
+		const key = redemptionTargetKey(step);
+		byTarget.set(key, [...byTarget.get(key) ?? [], step]);
+	}
+	const check = (key, items) => {
+		const targetSteps = byTarget.get(key) ?? [];
+		byTarget.delete(key);
+		const expected = redeemSignature(items);
+		const actual = stepSignature(targetSteps);
+		if (expected === actual) return null;
+		return {
+			code: "REDEMPTION_STEPS_MISMATCH",
+			field: "redemption_steps",
+			expected,
+			actual
+		};
+	};
+	const orderIssue = check(redemptionTargetKey({ target: "ORDER" }), redeem);
+	if (orderIssue) issues.push(orderIssue);
+	for (const line of lines) {
+		const lineIssue = check(redemptionTargetKey({
+			target: "LINE",
+			target_id: line.uid
+		}), line.redeem ?? []);
+		if (lineIssue) pushLineIssue(lineIssues, line.uid, lineIssue);
+	}
+	for (const orphan of byTarget.values()) {
+		const b1 = { code: "REDEMPTION_STEPS_MISMATCH" };
+		const b2 = {
+			field: "redemption_steps.target_id",
+			expected: ""
+		};
+		issues.push({
+			...b1,
+			...b2,
+			actual: stepSignature(orphan)
+		});
+	}
+};
+const STATE_FIELDS = [
+	"value",
+	"quantity",
+	"discount_amount",
+	"discount_rate"
+];
+const STATE_KEYS = [
+	"before",
+	"after",
+	"target_before",
+	"target_after"
+];
+const flattenState = (prefix, state, out) => {
+	for (const field of STATE_FIELDS) out[`${prefix}.${field}`] = state ? bigStr(state[field]) : "";
+};
+const flattenStep = (step) => {
+	const b1 = { reward_id: step.reward_id };
+	const b2 = { reward_quantity: String(step.reward_quantity) };
+	const b3 = {
+		target: step.target,
+		target_id: step.target_id ?? ""
+	};
+	const b4 = { action: step.action };
+	const b5 = { discount_amount: bigStr(step.discount_amount) };
+	const out = {
+		...b1,
+		...b2,
+		...b3,
+		...b4,
+		...b5
+	};
+	for (const key of STATE_KEYS) flattenState(key, step[key], out);
+	return out;
+};
+/** Replayed steps must equal the submitted ones field by field. */
+const compareRedemptionSteps = (submitted, expected, issues) => {
+	if (submitted.length !== expected.length) {
+		const b1 = { code: "REDEMPTION_MISMATCH" };
+		const b2 = { field: "redemption_steps" };
+		const b3 = { expected: String(expected.length) };
+		issues.push({
+			...b1,
+			...b2,
+			...b3,
+			actual: String(submitted.length)
+		});
+		return;
+	}
+	submitted.forEach((step, index) => {
+		const actual = flattenStep(step);
+		const wanted = flattenStep(expected[index]);
+		for (const field of Object.keys(wanted)) {
+			if (actual[field] === wanted[field]) continue;
+			const b1 = { code: "REDEMPTION_MISMATCH" };
+			const b2 = { field: `redemption_steps.${index}.${field}` };
+			const b3 = {
+				expected: wanted[field],
+				actual: actual[field]
+			};
+			issues.push({
+				...b1,
+				...b2,
+				...b3
+			});
+		}
+	});
+};
+const validateRedemptions = (input, issues, lineIssues) => {
+	const redeem = input.redeem ?? [];
+	const steps = input.redemptionSteps ?? [];
+	const now = input.now ?? Date.now();
+	issues.push(...expiredIssues(redeem, now));
+	for (const line of input.lines) {
+		const expired = expiredIssues(line.redeem ?? [], now);
+		for (const issue of expired) pushLineIssue(lineIssues, line.uid, issue);
+	}
+	checkRedemptionTargets(input.lines, redeem, steps, issues, lineIssues);
+	const expected = computeRedemptionSteps(input.lines, redeem, steps);
+	compareRedemptionSteps(steps, expected, issues);
+	return expected;
+};
 /** Compare cart lines/totals against a fresh menu (exact Big.js equality). */
 const validateOrderAgainstMenu = (input) => {
 	const locale = input.locale ?? "en_us";
@@ -3641,7 +4730,8 @@ const validateOrderAgainstMenu = (input) => {
 	}
 	checkRootProductQuantities(roots, lookup, lineIssues);
 	if (input.expectedFeeLines) compareExpectedFeeLines(input.lines, input.expectedFeeLines, lineIssues);
-	const expectedTotals = recomputeTotals(input.lines, input.totals.currency);
+	const expectedSteps = validateRedemptions(input, issues, lineIssues);
+	const expectedTotals = applyRedemptionTotals(recomputeTotals(input.lines, input.totals.currency), expectedSteps);
 	for (const field of TOTALS_FIELDS) {
 		if (bigEq(input.totals[field], expectedTotals[field])) continue;
 		issues.push({
@@ -3682,6 +4772,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) => {
@@ -3694,9 +4790,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({
@@ -5018,4 +6112,4 @@ 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, getScheduleWindow, indexMenu, isCheckoutFieldFilled, isDeviceNotLinked, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isStorefrontNotFound, listMenusStream, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, paymentMatchesClientConditions, recomputeTotals, resolveCheckout, services, storefrontJson, toOrderLines, validateOrderAgainstMenu, visitedStates };
+export { DEFAULT_RECOMMENDATION_TYPES, Order, OrderSyncPendingError, OrderValidationError, RecurringDateCron, RulesEngine, StorefrontHttpError, addLines, auth, buildCustomerSnapshot, collectOrderLineDiffs, computeStartingPrice, countCartProducts, createSession, currentNodes, defaultConditionError, flattenMenuCategories, fromOrderLines, genId, genOrderId, getScheduleWindow, indexMenu, isCheckoutFieldFilled, isDeviceNotLinked, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isStorefrontNotFound, isVariantBase, listMenusStream, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, resolveCheckout, services, storefrontJson, toOrderLines, validateOrderAgainstMenu, visitedStates };