@fire-spark/core 0.11.1 → 0.12.0

package/dist/index.js

@@ -1649,11 +1649,11 @@ const randomUUID = () => {
 };
 //#endregion
 //#region src/productCustomization/toOrderLines.ts
-const displayName = (text, locale) => {
+const displayName$1 = (text, locale) => {
 	if (text[locale]) return text[locale];
 	return Object.values(text)[0] ?? "";
 };
-const applyUnitMoney = (config) => {
+const applyUnitMoney$1 = (config) => {
 	const qty = new Big(config.quantity);
 	const unitDiscount = config.unitSubtotal.times(config.discountRate);
 	const net = config.unitSubtotal.minus(unitDiscount);
@@ -1732,7 +1732,7 @@ const buildLine = (args) => {
 		...b2,
 		...b3
 	};
-	const money = applyUnitMoney(moneyArgs);
+	const money = applyUnitMoney$1(moneyArgs);
 	const imageUrl = args.product.image_url ?? void 0;
 	const imagePatch = imageUrl ? { image_url: imageUrl } : {};
 	const catalog = lineCatalogFields(args.product);
@@ -1820,7 +1820,7 @@ const appendModifierLine = (modifier, groupId, parent, locale) => {
 	const unitSubtotal = new Big(modifier.linePrice).div(modifier.quantity);
 	const l1 = {
 		product,
-		name: displayName(product.name, locale),
+		name: displayName$1(product.name, locale),
 		quantity: modifier.quantity,
 		unitSubtotal
 	};
@@ -1844,7 +1844,7 @@ const appendModifierLine = (modifier, groupId, parent, locale) => {
 const toOrderLines = (root, locale) => {
 	if (root.quantity <= 0) return [];
 	if (isVariantBase(root.data)) return [];
-	const name = displayName(root.data.name, locale);
+	const name = displayName$1(root.data.name, locale);
 	const unitSubtotal = new Big(root.data.pricing.price);
 	const t1 = {
 		product: root.data,
@@ -6603,6 +6603,608 @@ const milestoneSteps = (workflow, currentNodeIds) => {
 	};
 };
 //#endregion
+//#region src/order/placeCartLines.ts
+const selectionKey = (line, kidsOf, cache) => {
+	const cached = cache.get(line.uid);
+	if (cached) return cached;
+	const nested = (kidsOf.get(line.uid) ?? []).map((child) => {
+		return selectionKey(child, kidsOf, cache);
+	});
+	nested.sort((left, right) => left.localeCompare(right));
+	const key = `${line.id}x${line.quantity}(${nested.join(",")})`;
+	cache.set(line.uid, key);
+	return key;
+};
+const parentGroups = (lookup, product) => {
+	return product.pricing.modifier_group_ids.flatMap((groupId) => {
+		const group = lookup.modifierGroupsById[groupId];
+		return group ? [group] : [];
+	});
+};
+const buildSlots = (lookup, groups) => {
+	const slots = [];
+	for (const group of groups) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const modifierId of group.modifier_ids) {
+			if (seen.has(modifierId)) continue;
+			seen.add(modifierId);
+			const product = lookup.productsById[modifierId];
+			const entry = product ? resolvePricingModifier(product, group.id) : null;
+			const modifierMax = entry?.maximum_quantity ?? group.maximum_quantity;
+			const row = {
+				group,
+				modifierId,
+				modifierMin: entry?.minimum_quantity ?? 0
+			};
+			const counts = {
+				modifierMax,
+				instances: 0,
+				next: 2
+			};
+			slots.push({
+				...row,
+				...counts
+			});
+		}
+	}
+	return slots;
+};
+const listingsFor = (lookup, groups, childId) => {
+	const direct = [];
+	for (const group of groups) {
+		if (!group.modifier_ids.includes(childId)) continue;
+		direct.push({
+			group,
+			modifierId: childId
+		});
+	}
+	if (direct.length > 0) return direct;
+	const child = lookup.productsById[childId];
+	const viaBase = [];
+	for (const entry of child?.pricing.variants ?? []) {
+		const base = lookup.productsById[entry.product_id];
+		if (!child || !base) continue;
+		if (!selectionForVariant(lookup, base, child)) continue;
+		for (const group of groups) {
+			if (!group.modifier_ids.includes(base.id)) continue;
+			viaBase.push({
+				group,
+				modifierId: base.id
+			});
+		}
+	}
+	return viaBase;
+};
+const slotKey = (groupId, modifierId) => {
+	return `${groupId}/${modifierId}`;
+};
+/** Same product id more than once under one parent, at any depth. */
+const hasRepeatedProductSibling = (lines, rootUid) => {
+	const kidsOf = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		if (line.parent_uid == null) continue;
+		const list = kidsOf.get(line.parent_uid) ?? [];
+		list.push(line);
+		kidsOf.set(line.parent_uid, list);
+	}
+	const walk = (uid) => {
+		const seen = /* @__PURE__ */ new Set();
+		for (const child of kidsOf.get(uid) ?? []) {
+			if (seen.has(child.id)) return true;
+			seen.add(child.id);
+			if (walk(child.uid)) return true;
+		}
+		return false;
+	};
+	return walk(rootUid);
+};
+const noteRules = (state, broken) => {
+	if (broken) state.rulesBroken = true;
+};
+/** Search steps per parent. Far above any real menu. A cart that needs more
+* is rejected: a partial search never accepts anything. */
+const SEARCH_BUDGET = 4096;
+const OWN_MONEY = [
+	"unit_subtotal",
+	"subtotal",
+	"unit_discount",
+	"discount_total",
+	"unit_tax_total",
+	"tax_total",
+	"unit_total",
+	"total",
+	"discount_rate"
+];
+const emptyUsage = () => {
+	return {
+		bySlot: /* @__PURE__ */ new Map(),
+		byGroup: /* @__PURE__ */ new Map()
+	};
+};
+const addUsage = (usage, slot, quantity) => {
+	const own = usage.bySlot.get(slot) ?? 0;
+	usage.bySlot.set(slot, own + quantity);
+	const group = usage.byGroup.get(slot.group.id) ?? 0;
+	usage.byGroup.set(slot.group.id, group + quantity);
+};
+const hasRoom = (usage, slot, quantity) => {
+	const own = usage.bySlot.get(slot) ?? 0;
+	if ((usage.byGroup.get(slot.group.id) ?? 0) + quantity > slot.group.maximum_quantity) return false;
+	return own + quantity <= slot.modifierMax;
+};
+/** Every instance counts: usage is the sum over all sibling lines. A slot's
+* own minimum binds once the slot is used, as in the customization session.
+* An unused slot owes nothing; the group minimum is what requires a pick. */
+const limitsBroken = (groups, slots, usage) => {
+	for (const group of groups) {
+		const used = usage.byGroup.get(group.id) ?? 0;
+		if (used > group.maximum_quantity) return true;
+		if (used < group.minimum_quantity) return true;
+	}
+	for (const slot of slots) {
+		const used = usage.bySlot.get(slot) ?? 0;
+		if (used > slot.modifierMax) return true;
+		if (used > 0 && used < slot.modifierMin) return true;
+	}
+	return false;
+};
+const claimKey = (line) => {
+	const subtotal = new Big(line.unit_subtotal).toString();
+	if (line.tax_rate == null) return `${subtotal}|null`;
+	return `${subtotal}|${new Big(line.tax_rate).toString()}`;
+};
+const sameOwnMoney = (line, money) => {
+	for (const field of OWN_MONEY) if (!new Big(line[field]).eq(money[field])) return false;
+	if (line.tax_rate == null) return false;
+	return new Big(line.tax_rate).eq(money.tax_rate);
+};
+/** True when the line's own money is exactly what the menu yields for this
+* slot: the slot's price and tax, with 0 to `quantity` charged units
+* (charge_above shares free units between siblings). It only narrows which
+* slots a line may take. Nothing from the cart is ever copied into the
+* expected tree: the final comparison is still exact. */
+const slotYieldsLine = (lookup, line, ordered, slot) => {
+	const quantity = line.quantity;
+	if (quantity <= 0) return false;
+	if (quantity > slot.modifierMax) return false;
+	if (quantity > slot.group.maximum_quantity) return false;
+	const listed = lookup.productsById[slot.modifierId] ?? ordered;
+	const pricing = modifierUnitPricing(listed, ordered, slot.group.id);
+	const free = (resolvePricingModifier(listed, slot.group.id)?.charge_above_quantity ?? 0) + (slot.group.charge_above_quantity ?? 0);
+	const unit = new Big(pricing.price);
+	const config = {
+		quantity,
+		taxRate: pricing.taxRate
+	};
+	const inclusive = { taxInclusive: pricing.isTaxInclusive };
+	const fewest = Math.max(0, quantity - free);
+	for (let charged = fewest; charged <= quantity; charged++) {
+		const unitSubtotal = unit.times(charged).div(quantity);
+		const money = applyUnitMoney({
+			...config,
+			...inclusive,
+			unitSubtotal
+		});
+		if (sameOwnMoney(line, money)) return true;
+	}
+	return false;
+};
+/** Slots the line may take: those whose menu price it matches, else every
+* listed slot (the comparison then reports the price it cannot match). */
+const optionsFor = (lookup, line, ordered, listed) => {
+	if (listed.length < 2) return listed;
+	const yielding = listed.filter((slot) => {
+		return slotYieldsLine(lookup, line, ordered, slot);
+	});
+	if (yielding.length > 0) return yielding;
+	return listed;
+};
+/** Depth-first assignment of sibling lines to slots, in a fixed order, within
+* capacity, until every group and modifier limit holds. Twins (same shape and
+* same claimed price) are interchangeable, so they are forced into
+* non-decreasing option order. At most SEARCH_BUDGET steps of O(slots). */
+const searchAssignment = (plans, groups, slots) => {
+	const total = plans.length;
+	const usage = emptyUsage();
+	const chosen = [];
+	const picked = [];
+	const cursor = [0];
+	let depth = 0;
+	let steps = 0;
+	while (depth >= 0) {
+		steps += 1;
+		if (steps > SEARCH_BUDGET) return null;
+		if (depth === total) {
+			if (!limitsBroken(groups, slots, usage)) return chosen;
+			depth -= 1;
+			addUsage(usage, chosen[depth], -plans[depth].line.quantity);
+			continue;
+		}
+		const plan = plans[depth];
+		const quantity = plan.line.quantity;
+		let found = -1;
+		for (let next = cursor[depth]; next < plan.options.length; next++) {
+			if (!hasRoom(usage, plan.options[next], quantity)) continue;
+			found = next;
+			break;
+		}
+		if (found < 0) {
+			depth -= 1;
+			if (depth < 0) break;
+			addUsage(usage, chosen[depth], -plans[depth].line.quantity);
+			continue;
+		}
+		cursor[depth] = found + 1;
+		picked[depth] = found;
+		chosen[depth] = plan.options[found];
+		addUsage(usage, chosen[depth], quantity);
+		depth += 1;
+		cursor[depth] = plans[depth]?.twin === true ? picked[depth - 1] : 0;
+	}
+	return null;
+};
+/** Used when no assignment satisfies every limit: first slot with room, so the
+* repaired tree and the broken-rules flag still come out deterministic. */
+const greedyAssignment = (plans) => {
+	const usage = emptyUsage();
+	const chosen = [];
+	let overCapacity = false;
+	for (const plan of plans) {
+		const quantity = plan.line.quantity;
+		const fits = (slot) => hasRoom(usage, slot, quantity);
+		let slot = plan.options.find(fits) ?? plan.listed.find(fits);
+		if (!slot) {
+			slot = plan.listed[0];
+			overCapacity = true;
+		}
+		addUsage(usage, slot, quantity);
+		chosen.push(slot);
+	}
+	return {
+		chosen,
+		overCapacity
+	};
+};
+const planKids = (lookup, groups, byKey, kids, prefix, state) => {
+	const plans = [];
+	let previous = "";
+	for (const child of kids) {
+		if (pathVisits(prefix, child.id)) continue;
+		const ordered = lookup.productsById[child.id];
+		const listings = listingsFor(lookup, groups, child.id);
+		if (!ordered || listings.length === 0) continue;
+		const listed = [];
+		for (const item of listings) {
+			const slot = byKey.get(slotKey(item.group.id, item.modifierId));
+			if (slot) listed.push(slot);
+		}
+		if (listed.length === 0) continue;
+		const signature = `${selectionKey(child, state.childrenByParent, state.keyCache)}|${claimKey(child)}`;
+		const options = optionsFor(lookup, child, ordered, listed);
+		const twin = signature === previous;
+		plans.push({
+			line: child,
+			ordered,
+			listed,
+			options,
+			twin
+		});
+		previous = signature;
+	}
+	return plans;
+};
+const placeChildren = (lookup, parent, parentLine, prefix, state) => {
+	const groups = parentGroups(lookup, parent);
+	const slots = buildSlots(lookup, groups);
+	const byKey = /* @__PURE__ */ new Map();
+	for (const slot of slots) byKey.set(slotKey(slot.group.id, slot.modifierId), slot);
+	const kids = (state.childrenByParent.get(parentLine.uid) ?? []).slice();
+	kids.sort((left, right) => {
+		const a = selectionKey(left, state.childrenByParent, state.keyCache);
+		const b = selectionKey(right, state.childrenByParent, state.keyCache);
+		const byShape = a.localeCompare(b);
+		if (byShape !== 0) return byShape;
+		return claimKey(left).localeCompare(claimKey(right));
+	});
+	const plans = planKids(lookup, groups, byKey, kids, prefix, state);
+	let assignment = [];
+	if (plans.length > 0) assignment = searchAssignment(plans, groups, slots);
+	if (!assignment) {
+		const fallback = greedyAssignment(plans);
+		assignment = fallback.chosen;
+		if (fallback.overCapacity) state.overCapacity = true;
+	}
+	const usage = emptyUsage();
+	const placed = [];
+	for (let index = 0; index < plans.length; index++) {
+		const plan = plans[index];
+		const chosen = assignment[index];
+		const child = plan.line;
+		const ordered = plan.ordered;
+		const base = `${`${prefix}/group/${chosen.group.id}`}/modifier/${chosen.modifierId}`;
+		let path = base;
+		if (chosen.instances > 0) {
+			path = `${base}/instance/${chosen.next}`;
+			chosen.next += 1;
+		}
+		chosen.instances += 1;
+		addUsage(usage, chosen, child.quantity);
+		state.paths[path] = child.quantity;
+		const listed = lookup.productsById[chosen.modifierId] ?? ordered;
+		const pricing = modifierUnitPricing(listed, ordered, chosen.group.id);
+		const n1 = {
+			product: ordered,
+			quantity: child.quantity,
+			path
+		};
+		const n2 = {
+			children: [],
+			listed,
+			group: chosen.group
+		};
+		const n3 = {
+			unitPrice: new Big(0),
+			taxRate: pricing.taxRate
+		};
+		const n4 = { taxInclusive: pricing.isTaxInclusive };
+		const node = {
+			...n1,
+			...n2,
+			...n3,
+			...n4
+		};
+		node.children = placeChildren(lookup, ordered, child, path, state);
+		placed.push(node);
+	}
+	noteRules(state, limitsBroken(groups, slots, usage));
+	billGroups(placed);
+	return placed;
+};
+const billGroups = (nodes) => {
+	const byGroup = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		if (!node.group) continue;
+		const list = byGroup.get(node.group.id) ?? [];
+		list.push(node);
+		byGroup.set(node.group.id, list);
+	}
+	for (const list of byGroup.values()) {
+		const group = list[0]?.group;
+		if (group) billGroup(group, list);
+	}
+};
+/** Menu order, then instance order. One modifier's free units are shared,
+* so a second sibling line is not free just because it is its own line. */
+const billGroup = (group, nodes) => {
+	const groupChargeAbove = group.charge_above_quantity ?? 0;
+	let chargedCount = 0;
+	const consumed = /* @__PURE__ */ new Map();
+	const ordered = [];
+	for (const modifierId of group.modifier_ids) for (const node of nodes) if (node.listed?.id === modifierId) ordered.push(node);
+	for (const node of ordered) {
+		if (node.quantity <= 0 || !node.listed || !node.group) continue;
+		const entry = resolvePricingModifier(node.listed, node.group.id);
+		const unit = new Big(modifierUnitPricing(...[
+			node.listed,
+			node.product,
+			node.group.id
+		]).price);
+		const allowance0 = entry?.charge_above_quantity ?? 0;
+		const id = node.listed.id;
+		const taken = consumed.get(id) ?? 0;
+		const allowance = Math.max(0, allowance0 - taken);
+		let remaining = Math.max(0, node.quantity - allowance);
+		consumed.set(id, taken + node.quantity);
+		let linePrice = new Big(0);
+		while (remaining > 0) {
+			if (chargedCount >= groupChargeAbove) linePrice = linePrice.plus(unit);
+			chargedCount += 1;
+			remaining -= 1;
+		}
+		node.unitPrice = node.quantity > 0 ? linePrice.div(node.quantity) : unit;
+	}
+};
+const applyUnitMoney = (config) => {
+	const qty = new Big(config.quantity);
+	const net = config.unitSubtotal;
+	let unitTax = net.times(config.taxRate);
+	let unitTotal = net.plus(unitTax);
+	if (config.taxInclusive) {
+		const divisor = new Big(1).plus(config.taxRate);
+		unitTax = net.times(config.taxRate).div(divisor);
+		unitTotal = net;
+	}
+	const r1 = {
+		tax_rate: config.taxRate,
+		discount_rate: 0
+	};
+	const r2 = { unit_subtotal: config.unitSubtotal.toNumber() };
+	const r3 = {
+		unit_discount: 0,
+		unit_tax_total: unitTax.toNumber()
+	};
+	const r4 = { unit_total: unitTotal.toNumber() };
+	const r5 = { subtotal: config.unitSubtotal.times(qty).toNumber() };
+	const r6 = {
+		discount_total: 0,
+		tax_total: unitTax.times(qty).toNumber()
+	};
+	const r7 = { total: unitTotal.times(qty).toNumber() };
+	return {
+		...r1,
+		...r2,
+		...r3,
+		...r4,
+		...r5,
+		...r6,
+		...r7
+	};
+};
+const emptyGroup = () => {
+	const g1 = {
+		unit_group_subtotal: 0,
+		unit_group_discount: 0
+	};
+	const g2 = {
+		unit_group_tax_total: 0,
+		unit_group_total: 0
+	};
+	const g3 = {
+		group_subtotal: 0,
+		group_discount: 0
+	};
+	const g4 = {
+		group_tax_total: 0,
+		group_total: 0
+	};
+	return {
+		...g1,
+		...g2,
+		...g3,
+		...g4
+	};
+};
+const displayName = (text, locale) => {
+	if (text[locale]) return text[locale];
+	return Object.values(text)[0] ?? "";
+};
+const emit = (node, parentUid, parentId, locale, out) => {
+	const mIn1 = {
+		unitSubtotal: node.unitPrice,
+		quantity: node.quantity
+	};
+	const mIn2 = {
+		taxRate: node.taxRate,
+		taxInclusive: node.taxInclusive
+	};
+	const money = applyUnitMoney({
+		...mIn1,
+		...mIn2
+	});
+	const imageUrl = node.product.image_url ?? void 0;
+	const imagePatch = imageUrl ? { image_url: imageUrl } : {};
+	const catalog = {
+		metadata: { ...node.product.metadata ?? {} },
+		bundled_items: [...node.product.bundled_items ?? []]
+	};
+	const r1 = {
+		type: "PRODUCT",
+		uid: randomUUID()
+	};
+	const r2 = {
+		id: node.product.id,
+		parent_uid: parentUid,
+		parent_id: parentId
+	};
+	const r3 = {
+		name: displayName(node.product.name, locale),
+		quantity: node.quantity
+	};
+	const r4 = {
+		redeem: [],
+		...imagePatch,
+		...catalog,
+		...money
+	};
+	const line = {
+		...r1,
+		...r2,
+		...r3,
+		...r4,
+		...emptyGroup()
+	};
+	out.push(line);
+	for (const child of node.children) emit(child, line.uid, line.id, locale, out);
+	let sub = new Big(line.subtotal);
+	let tax = new Big(line.tax_total);
+	let tot = new Big(line.total);
+	let childSub = new Big(0);
+	let childTax = new Big(0);
+	let childTot = new Big(0);
+	for (const child of out) {
+		if (child.parent_uid !== line.uid) continue;
+		childSub = childSub.plus(child.group_subtotal);
+		childTax = childTax.plus(child.group_tax_total);
+		childTot = childTot.plus(child.group_total);
+	}
+	const qty = new Big(line.quantity);
+	sub = sub.plus(childSub.times(qty));
+	tax = tax.plus(childTax.times(qty));
+	tot = tot.plus(childTot.times(qty));
+	line.group_subtotal = sub.toNumber();
+	line.group_tax_total = tax.toNumber();
+	line.group_total = tot.toNumber();
+	line.group_discount = 0;
+	line.unit_group_subtotal = sub.div(qty).toNumber();
+	line.unit_group_tax_total = tax.div(qty).toNumber();
+	line.unit_group_total = tot.div(qty).toNumber();
+	line.unit_group_discount = 0;
+};
+const rootNode = (lookup, root, state) => {
+	const product = lookup.productsById[root.id];
+	if (!product) return null;
+	const max = product.pricing.maximum_quantity;
+	const min = product.pricing.minimum_quantity;
+	noteRules(state, root.quantity > max || root.quantity < min);
+	const path = `/${product.id}`;
+	state.paths[path] = root.quantity;
+	const children = placeChildren(lookup, product, root, path, state);
+	const r1 = {
+		product,
+		quantity: root.quantity,
+		path,
+		children
+	};
+	const r2 = {
+		listed: null,
+		group: null
+	};
+	const r3 = { unitPrice: new Big(product.pricing.price) };
+	const r4 = { taxRate: product.pricing.tax_rate };
+	const r5 = { taxInclusive: product.pricing.is_tax_inclusive };
+	return {
+		...r1,
+		...r2,
+		...r3,
+		...r4,
+		...r5
+	};
+};
+/** Place cart lines on menu slots and price them from the menu.
+* The tree is built from product id, parent, and quantity. A line's claimed
+* own price is read for one purpose: to rank which listed slots it may take
+* (see slotYieldsLine). The expected money is always the menu's for the
+* chosen slot, so a claim the menu cannot yield stays a mismatch.
+* A quantity above 1 stays one line. Extra sibling lines reuse a slot
+* only while its max still has room, at `/instance/2`, `/instance/3`, ….
+* Indices are assigned here. A forged index in the cart is not an input. */
+const placeCartLines = (root, lines, lookup, locale) => {
+	const childrenByParent = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		if (line.parent_uid == null) continue;
+		const list = childrenByParent.get(line.parent_uid) ?? [];
+		list.push(line);
+		childrenByParent.set(line.parent_uid, list);
+	}
+	const state = {
+		paths: {},
+		overCapacity: false,
+		rulesBroken: false,
+		childrenByParent,
+		keyCache: /* @__PURE__ */ new Map()
+	};
+	const node = rootNode(lookup, root, state);
+	const out = [];
+	if (node) emit(node, null, null, locale, out);
+	if (state.overCapacity) state.rulesBroken = true;
+	return {
+		paths: state.paths,
+		overCapacity: state.overCapacity,
+		rulesBroken: state.rulesBroken,
+		lines: out
+	};
+};
+//#endregion
 //#region src/order/validate.ts
 const PRICE_FIELDS = [
 	"unit_subtotal",
@@ -6661,11 +7263,34 @@ const rateStr = (n) => {
 	if (n == null) return "null";
 	return bigStr(n);
 };
+const structureKey = (lines, line) => {
+	const nested = lines.filter((child) => child.parent_uid === line.uid).map((child) => structureKey(lines, child));
+	nested.sort((left, right) => left.localeCompare(right));
+	return `${line.id}x${line.quantity}(${nested.join(",")})`;
+};
+/** Sorted by id as before. Only same-id siblings are told apart further:
+* by nested shape, then unit price, so each pairs with its own expectation. */
 const childrenOf = (lines, parentUid) => {
 	const children = lines.filter((line) => {
 		return line.parent_uid === parentUid;
 	});
-	children.sort((a, b) => a.id.localeCompare(b.id));
+	const shapes = /* @__PURE__ */ new Map();
+	const shapeOf = (line) => {
+		const cached = shapes.get(line.uid);
+		if (cached !== void 0) return cached;
+		const shape = structureKey(lines, line);
+		shapes.set(line.uid, shape);
+		return shape;
+	};
+	children.sort((a, b) => {
+		const byId = a.id.localeCompare(b.id);
+		if (byId !== 0) return byId;
+		const byShape = shapeOf(a).localeCompare(shapeOf(b));
+		if (byShape !== 0) return byShape;
+		const bySubtotal = new Big(a.unit_subtotal).cmp(b.unit_subtotal);
+		if (bySubtotal !== 0) return bySubtotal;
+		return new Big(a.unit_tax_total).cmp(b.unit_tax_total);
+	});
 	return children;
 };
 const collectUnmatchedModifiers = (lines, lookup, parentProductId, parentUid, out) => {
@@ -6908,10 +7533,17 @@ const validateProductRoot = (root, lines, lookup, locale, out) => {
 	if (status === "OUT_OF_STOCK") pushLineIssue(out, root.uid, { code: "OUT_OF_STOCK" });
 	if (!isOnSchedule(product.availability.schedules)) pushLineIssue(out, root.uid, { code: "OUTSIDE_HOURS" });
 	collectUnmatchedModifiers(lines, lookup, root.id, root.uid, out);
-	const snapshot = fromOrderLines(root, lines, lookup);
-	const session = createSession(lookup, root.id, { snapshot });
-	if (session.validate() !== "VALID") pushLineIssue(out, root.uid, { code: "MODIFIER_RULES_INVALID" });
-	const expected = toOrderLines(session.root, locale);
+	let expected;
+	if (hasRepeatedProductSibling(lines, root.uid)) {
+		const placed = placeCartLines(root, lines, lookup, locale);
+		if (placed.rulesBroken) pushLineIssue(out, root.uid, { code: "MODIFIER_RULES_INVALID" });
+		expected = placed.lines;
+	} else {
+		const snapshot = fromOrderLines(root, lines, lookup);
+		const session = createSession(lookup, root.id, { snapshot });
+		if (session.validate() !== "VALID") pushLineIssue(out, root.uid, { code: "MODIFIER_RULES_INVALID" });
+		expected = toOrderLines(session.root, locale);
+	}
 	const expectedRoot = expected.find((line) => line.parent_uid == null);
 	if (!expectedRoot) {
 		pushLineIssue(out, root.uid, { code: "STRUCTURE_MISMATCH" });
@@ -7234,6 +7866,17 @@ const collectOrderLineDiffs = (input) => {
 			continue;
 		}
 		try {
+			if (hasRepeatedProductSibling(input.lines, root.uid)) {
+				const placed = placeCartLines(root, input.lines, lookup, locale);
+				const next = placed.rulesBroken ? null : placed.lines;
+				diffs.push({
+					uid: root.uid,
+					previous,
+					next,
+					issues
+				});
+				continue;
+			}
 			const snapshot = fromOrderLines(root, input.lines, lookup);
 			const next = toOrderLines(createSession(lookup, root.id, { snapshot }).root, locale);
 			diffs.push({
@@ -7800,16 +8443,6 @@ const countCartProducts = (lines, includeModifiers) => {
 		return line.type === "PRODUCT" || line.type == null;
 	}).reduce((sum, line) => sum + line.quantity, 0);
 };
-const getLineTagValues = (lines, tag) => {
-	if (!tag) return [];
-	const values = [];
-	for (const line of lines ?? []) {
-		const value = line.tags?.[tag];
-		if (typeof value === "undefined") continue;
-		values.push(value);
-	}
-	return values;
-};
 //#endregion
 //#region src/rules/absoluteDateMatcher.ts
 var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
@@ -8414,6 +9047,72 @@ const matchRelativeDateOperator = (condition, matcher, referenceDate) => {
 	}
 };
 //#endregion
+//#region src/rules/tagMatcher.ts
+const NEGATED_TO_POSITIVE = {
+	"not equal to": "equal to",
+	"is not": "is"
+};
+const SET_OPERATORS = [
+	"is any of",
+	"is all of",
+	"is none of"
+];
+const isComparable = (kind, value) => {
+	if (kind === "string") return typeof value === "string";
+	if (kind === "boolean") return typeof value === "boolean";
+	return typeof value === "number";
+};
+const normalize = (value, caseInsensitive) => {
+	if (typeof value === "string" && caseInsensitive) return value.toLowerCase();
+	return value;
+};
+const matchSet = (condition, kind, elements) => {
+	const { operator, value } = condition;
+	if (!Array.isArray(value)) throw new Error("Invalid tag set value");
+	const caseInsensitive = getCaseInsensitive(condition);
+	const wanted = new Set(value.map((item) => normalize(item, caseInsensitive)));
+	const present = new Set(elements.map((item) => normalize(item, caseInsensitive)));
+	const hasAny = elements.length > 0;
+	switch (operator) {
+		case "is any of": return [...present].some((item) => wanted.has(item));
+		case "is all of": return [...wanted].every((item) => present.has(item));
+		case "is none of": return !hasAny || ![...present].some((item) => wanted.has(item));
+		default: throw new Error(`Operator ${operator} not supported in ${kind} tags`);
+	}
+};
+/**
+* Evaluates one line's tag value against a tag condition.
+*
+* - Scalars use the primitive's matcher unchanged. A value of another type
+*   never matches.
+* - Lists use "any element matches" for positive operators and "no element
+*   matches the positive form" for negated ones. An empty list matches
+*   negated operators and set operator "is none of", never the others.
+* - Set operators treat a scalar as a one-element set.
+*/
+const matchTagLine = (condition, kind, raw, matchScalar) => {
+	const { operator } = condition;
+	const isList = Array.isArray(raw);
+	const items = isList ? raw : [raw];
+	const comparable = items.filter((item) => isComparable(kind, item));
+	if (SET_OPERATORS.includes(operator)) {
+		if (kind === "boolean" || kind === "currency") return false;
+		if (items.length > 0 && comparable.length === 0) return false;
+		return matchSet(condition, kind, comparable);
+	}
+	const match = matchScalar;
+	if (!isList) return comparable.length > 0 ? match(condition, raw) : false;
+	const positive = NEGATED_TO_POSITIVE[operator];
+	if (items.length === 0) return typeof positive === "string";
+	if (comparable.length === 0) return false;
+	if (typeof positive === "undefined") return comparable.some((item) => match(condition, item));
+	const positiveCondition = {
+		...condition,
+		operator: positive
+	};
+	return !comparable.some((item) => match(positiveCondition, item));
+};
+//#endregion
 //#region src/rules/RulesEngine.ts
 var RulesEngine = class {
 	order;
@@ -8450,20 +9149,20 @@ var RulesEngine = class {
 		if (!("tag" in condition) || !condition.tag) throw new Error("Invalid tag");
 		return condition.tag;
 	};
-	matchOrderProductTag = (condition, match) => {
+	matchOrderProductTag = (condition, kind, matchScalar) => {
 		const order = this.getDependency("order", condition.type);
 		const tag = this.getProductTag(condition);
-		const values = getLineTagValues(order.lines, tag);
-		for (const value of values) if (match(value)) return true;
+		for (const line of order.lines ?? []) {
+			const raw = line.tags?.[tag];
+			if (typeof raw === "undefined") continue;
+			if (matchTagLine(condition, kind, raw, matchScalar)) return true;
+		}
 		return false;
 	};
 	assertString = (condition) => {
 		const { primitive, type } = condition;
 		assert(primitive === "string", primitiveError("string"));
-		if (type === "Order includes product with tag") return this.matchOrderProductTag(condition, (value) => {
-			if (typeof value !== "string") return false;
-			return orderIncludesProductWithTag(condition, value);
-		});
+		if (type === "Order includes product with tag") return this.matchOrderProductTag(condition, "string", orderIncludesProductWithTag);
 		if (type === "Request path") {
 			const monitoring = this.getDependency("monitoring", type);
 			return requestPath(condition, monitoring.path);
@@ -8489,10 +9188,7 @@ var RulesEngine = class {
 			const line = getLineByProductId(order.lines, productId);
 			return orderIncludesProduct(condition, line?.quantity);
 		}
-		if (type === "Order includes product with tag") return this.matchOrderProductTag(condition, (value) => {
-			if (typeof value !== "number") return false;
-			return orderIncludesProductWithTag$1(condition, value);
-		});
+		if (type === "Order includes product with tag") return this.matchOrderProductTag(condition, "number", orderIncludesProductWithTag$1);
 		if (type === "Accumulated events") {
 			const monitoring = this.getDependency("monitoring", type);
 			const window = windowMinutes(condition);
@@ -8525,10 +9221,7 @@ var RulesEngine = class {
 			const isAnonymous = this.getDependency("customer", type).is_anonymous;
 			return isAnonymousCustomer(condition, isAnonymous);
 		}
-		if (type === "Order includes product with tag") return this.matchOrderProductTag(condition, (value) => {
-			if (typeof value !== "boolean") return false;
-			return orderIncludesProductWithTag$3(condition, value);
-		});
+		if (type === "Order includes product with tag") return this.matchOrderProductTag(condition, "boolean", orderIncludesProductWithTag$3);
 		if (type === "Payment is mixed") {
 			const payment = this.getDependency("payment", type);
 			return paymentIsMixed(condition, payment.is_mixed);
@@ -8546,10 +9239,7 @@ var RulesEngine = class {
 			const order = this.getDependency("order", type);
 			return orderTotal(condition, order.total);
 		}
-		if (type === "Order includes product with tag") return this.matchOrderProductTag(condition, (value) => {
-			if (typeof value !== "number") return false;
-			return orderIncludesProductWithTag$2(condition, value);
-		});
+		if (type === "Order includes product with tag") return this.matchOrderProductTag(condition, "currency", orderIncludesProductWithTag$2);
 		throw new Error(`Condition ${type} not supported in currency matcher`);
 	};
 	assertEnum = (condition) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fire-spark/core",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Fire Spark headless SDK",
   "type": "module",
   "sideEffects": false,
@@ -20,8 +20,8 @@
     "big.js": "6.2.1",
     "dayjs": "1.11.9",
     "@types/big.js": "6.2.2",
-    "@fire-spark/payments": "^0.11.1",
-    "@fire-spark/types": "^0.11.1"
+    "@fire-spark/payments": "^0.12.0",
+    "@fire-spark/types": "^0.12.0"
   },
   "devDependencies": {
     "tsdown": "^0.22.14",