@fire-spark/core 0.0.2 → 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
@@ -3746,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);
 	}
 };
@@ -3969,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" });
@@ -4203,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) => {
@@ -4215,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({
@@ -5539,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, 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 };
+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 };