@fire-spark/core 0.0.1

package/dist/index.js

@@ -0,0 +1,5021 @@
+import advancedFormat from "dayjs/plugin/advancedFormat.js";
+import isBetween from "dayjs/plugin/isBetween.js";
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter.js";
+import timezone from "dayjs/plugin/timezone.js";
+import utc from "dayjs/plugin/utc.js";
+import weekOfYear from "dayjs/plugin/weekOfYear.js";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region src/productCustomization/catalog.utils.ts
+const resolvePricingModifier = (product, groupId) => {
+	return product.pricing.modifiers.find((modifier) => modifier.modifier_group_id === groupId);
+};
+const inferControlType = (pricingModifier, group) => {
+	if (pricingModifier?.display_type) return pricingModifier.display_type;
+	const gMin = group.minimum_quantity;
+	const gMax = group.maximum_quantity;
+	const modifierMax = pricingModifier?.maximum_quantity;
+	if (gMin === 1 && gMax === 1) return "RADIO";
+	if (gMin === 0 && gMax === 1) return "CHECKBOX";
+	if (modifierMax === void 0 || modifierMax > 1) return "QUANTITY";
+	return "CHECKBOX";
+};
+const billableQuantity = (quantity, chargeAbove) => {
+	return Math.max(0, quantity - (chargeAbove ?? 0));
+};
+const pushUnique = (list, id) => {
+	if (!list.includes(id)) list.push(id);
+};
+const collectModifierIdsByGroupId = (products) => {
+	const byGroup = /* @__PURE__ */ new Map();
+	for (const product of products) for (const entry of product.pricing.modifiers ?? []) {
+		const groupId = entry.modifier_group_id;
+		let list = byGroup.get(groupId);
+		if (!list) {
+			list = [];
+			byGroup.set(groupId, list);
+		}
+		pushUnique(list, product.id);
+	}
+	return byGroup;
+};
+const collectReferencedGroupIds = (products) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const product of products) for (const groupId of product.pricing.modifier_group_ids ?? []) ids.add(groupId);
+	return ids;
+};
+const inferGroupFromProducts = (groupId, modifierIds, products) => {
+	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);
+		if (!entry) continue;
+		minimum_quantity = Math.max(minimum_quantity, entry.minimum_quantity ?? 0);
+		maximum_quantity = Math.max(maximum_quantity, entry.maximum_quantity ?? 1);
+		if (entry.charge_above_quantity != null) charge_above_quantity = entry.charge_above_quantity;
+	}
+	return {
+		id: groupId,
+		title: { en_us: groupId },
+		description: null,
+		display_type: "LIST",
+		modifier_ids: modifierIds,
+		minimum_quantity,
+		maximum_quantity,
+		charge_above_quantity,
+		metadata: {}
+	};
+};
+/** Fill lookup gaps when modifier products exist but group rows were trimmed. */
+const resolveModifierGroupsForLookup = (products, modifierGroups) => {
+	const byId = new Map(modifierGroups.map((group) => [group.id, group]));
+	const idsByGroup = collectModifierIdsByGroupId(products);
+	const referenced = collectReferencedGroupIds(products);
+	const needed = /* @__PURE__ */ new Set([...referenced, ...idsByGroup.keys()]);
+	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));
+	}
+	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));
+};
+const clampProductQuantity = (quantity, min, max) => {
+	return Math.min(max, Math.max(min, Math.max(0, Math.floor(quantity))));
+};
+//#endregion
+//#region ../../node_modules/.pnpm/big.js@6.2.1/node_modules/big.js/big.mjs
+/************************************** EDITABLE DEFAULTS *****************************************/
+var DP = 20;
+var RM = 1;
+var MAX_DP = 1e6;
+var MAX_POWER = 1e6;
+var NE = -7;
+var PE = 21;
+var STRICT = false;
+var NAME = "[big.js] ";
+var INVALID = NAME + "Invalid ";
+var INVALID_DP = INVALID + "decimal places";
+var INVALID_RM = INVALID + "rounding mode";
+var DIV_BY_ZERO = NAME + "Division by zero";
+var P = {};
+var UNDEFINED = void 0;
+var NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+function _Big_() {
+	function Big(n) {
+		var x = this;
+		if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);
+		if (n instanceof Big) {
+			x.s = n.s;
+			x.e = n.e;
+			x.c = n.c.slice();
+		} else {
+			if (typeof n !== "string") {
+				if (Big.strict === true && typeof n !== "bigint") throw TypeError(INVALID + "value");
+				n = n === 0 && 1 / n < 0 ? "-0" : String(n);
+			}
+			parse(x, n);
+		}
+		x.constructor = Big;
+	}
+	Big.prototype = P;
+	Big.DP = DP;
+	Big.RM = RM;
+	Big.NE = NE;
+	Big.PE = PE;
+	Big.strict = STRICT;
+	Big.roundDown = 0;
+	Big.roundHalfUp = 1;
+	Big.roundHalfEven = 2;
+	Big.roundUp = 3;
+	return Big;
+}
+function parse(x, n) {
+	var e, i, nl;
+	if (!NUMERIC.test(n)) throw Error(INVALID + "number");
+	x.s = n.charAt(0) == "-" ? (n = n.slice(1), -1) : 1;
+	if ((e = n.indexOf(".")) > -1) n = n.replace(".", "");
+	if ((i = n.search(/e/i)) > 0) {
+		if (e < 0) e = i;
+		e += +n.slice(i + 1);
+		n = n.substring(0, i);
+	} else if (e < 0) e = n.length;
+	nl = n.length;
+	for (i = 0; i < nl && n.charAt(i) == "0";) ++i;
+	if (i == nl) x.c = [x.e = 0];
+	else {
+		for (; nl > 0 && n.charAt(--nl) == "0";);
+		x.e = e - i - 1;
+		x.c = [];
+		for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);
+	}
+	return x;
+}
+function round(x, sd, rm, more) {
+	var xc = x.c;
+	if (rm === UNDEFINED) rm = x.constructor.RM;
+	if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) throw Error(INVALID_RM);
+	if (sd < 1) {
+		more = rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 || rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED)));
+		xc.length = 1;
+		if (more) {
+			x.e = x.e - sd + 1;
+			xc[0] = 1;
+		} else xc[0] = x.e = 0;
+	} else if (sd < xc.length) {
+		more = rm === 1 && xc[sd] >= 5 || rm === 2 && (xc[sd] > 5 || xc[sd] === 5 && (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) || rm === 3 && (more || !!xc[0]);
+		xc.length = sd;
+		if (more) for (; ++xc[--sd] > 9;) {
+			xc[sd] = 0;
+			if (sd === 0) {
+				++x.e;
+				xc.unshift(1);
+				break;
+			}
+		}
+		for (sd = xc.length; !xc[--sd];) xc.pop();
+	}
+	return x;
+}
+function stringify(x, doExponential, isNonzero) {
+	var e = x.e, s = x.c.join(""), n = s.length;
+	if (doExponential) s = s.charAt(0) + (n > 1 ? "." + s.slice(1) : "") + (e < 0 ? "e" : "e+") + e;
+	else if (e < 0) {
+		for (; ++e;) s = "0" + s;
+		s = "0." + s;
+	} else if (e > 0) {
+		if (++e > n) for (e -= n; e--;) s += "0";
+		else if (e < n) s = s.slice(0, e) + "." + s.slice(e);
+	} else if (n > 1) s = s.charAt(0) + "." + s.slice(1);
+	return x.s < 0 && isNonzero ? "-" + s : s;
+}
+P.abs = function() {
+	var x = new this.constructor(this);
+	x.s = 1;
+	return x;
+};
+P.cmp = function(y) {
+	var isneg, x = this, xc = x.c, yc = (y = new x.constructor(y)).c, i = x.s, j = y.s, k = x.e, l = y.e;
+	if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;
+	if (i != j) return i;
+	isneg = i < 0;
+	if (k != l) return k > l ^ isneg ? 1 : -1;
+	j = (k = xc.length) < (l = yc.length) ? k : l;
+	for (i = -1; ++i < j;) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
+	return k == l ? 0 : k > l ^ isneg ? 1 : -1;
+};
+P.div = function(y) {
+	var x = this, Big = x.constructor, a = x.c, b = (y = new Big(y)).c, k = x.s == y.s ? 1 : -1, dp = Big.DP;
+	if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);
+	if (!b[0]) throw Error(DIV_BY_ZERO);
+	if (!a[0]) {
+		y.s = k;
+		y.c = [y.e = 0];
+		return y;
+	}
+	var bl, bt, n, cmp, ri, bz = b.slice(), ai = bl = b.length, al = a.length, r = a.slice(0, bl), rl = r.length, q = y, qc = q.c = [], qi = 0, p = dp + (q.e = x.e - y.e) + 1;
+	q.s = k;
+	k = p < 0 ? 0 : p;
+	bz.unshift(0);
+	for (; rl++ < bl;) r.push(0);
+	do {
+		for (n = 0; n < 10; n++) {
+			if (bl != (rl = r.length)) cmp = bl > rl ? 1 : -1;
+			else for (ri = -1, cmp = 0; ++ri < bl;) if (b[ri] != r[ri]) {
+				cmp = b[ri] > r[ri] ? 1 : -1;
+				break;
+			}
+			if (cmp < 0) {
+				for (bt = rl == bl ? b : bz; rl;) {
+					if (r[--rl] < bt[rl]) {
+						ri = rl;
+						for (; ri && !r[--ri];) r[ri] = 9;
+						--r[ri];
+						r[rl] += 10;
+					}
+					r[rl] -= bt[rl];
+				}
+				for (; !r[0];) r.shift();
+			} else break;
+		}
+		qc[qi++] = cmp ? n : ++n;
+		if (r[0] && cmp) r[rl] = a[ai] || 0;
+		else r = [a[ai]];
+	} while ((ai++ < al || r[0] !== UNDEFINED) && k--);
+	if (!qc[0] && qi != 1) {
+		qc.shift();
+		q.e--;
+		p--;
+	}
+	if (qi > p) round(q, p, Big.RM, r[0] !== UNDEFINED);
+	return q;
+};
+P.eq = function(y) {
+	return this.cmp(y) === 0;
+};
+P.gt = function(y) {
+	return this.cmp(y) > 0;
+};
+P.gte = function(y) {
+	return this.cmp(y) > -1;
+};
+P.lt = function(y) {
+	return this.cmp(y) < 0;
+};
+P.lte = function(y) {
+	return this.cmp(y) < 1;
+};
+P.minus = P.sub = function(y) {
+	var i, j, t, xlty, x = this, Big = x.constructor, a = x.s, b = (y = new Big(y)).s;
+	if (a != b) {
+		y.s = -b;
+		return x.plus(y);
+	}
+	var xc = x.c.slice(), xe = x.e, yc = y.c, ye = y.e;
+	if (!xc[0] || !yc[0]) {
+		if (yc[0]) y.s = -b;
+		else if (xc[0]) y = new Big(x);
+		else y.s = 1;
+		return y;
+	}
+	if (a = xe - ye) {
+		if (xlty = a < 0) {
+			a = -a;
+			t = xc;
+		} else {
+			ye = xe;
+			t = yc;
+		}
+		t.reverse();
+		for (b = a; b--;) t.push(0);
+		t.reverse();
+	} else {
+		j = ((xlty = xc.length < yc.length) ? xc : yc).length;
+		for (a = b = 0; b < j; b++) if (xc[b] != yc[b]) {
+			xlty = xc[b] < yc[b];
+			break;
+		}
+	}
+	if (xlty) {
+		t = xc;
+		xc = yc;
+		yc = t;
+		y.s = -y.s;
+	}
+	if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;
+	for (b = i; j > a;) {
+		if (xc[--j] < yc[j]) {
+			for (i = j; i && !xc[--i];) xc[i] = 9;
+			--xc[i];
+			xc[j] += 10;
+		}
+		xc[j] -= yc[j];
+	}
+	for (; xc[--b] === 0;) xc.pop();
+	for (; xc[0] === 0;) {
+		xc.shift();
+		--ye;
+	}
+	if (!xc[0]) {
+		y.s = 1;
+		xc = [ye = 0];
+	}
+	y.c = xc;
+	y.e = ye;
+	return y;
+};
+P.mod = function(y) {
+	var ygtx, x = this, Big = x.constructor, a = x.s, b = (y = new Big(y)).s;
+	if (!y.c[0]) throw Error(DIV_BY_ZERO);
+	x.s = y.s = 1;
+	ygtx = y.cmp(x) == 1;
+	x.s = a;
+	y.s = b;
+	if (ygtx) return new Big(x);
+	a = Big.DP;
+	b = Big.RM;
+	Big.DP = Big.RM = 0;
+	x = x.div(y);
+	Big.DP = a;
+	Big.RM = b;
+	return this.minus(x.times(y));
+};
+P.neg = function() {
+	var x = new this.constructor(this);
+	x.s = -x.s;
+	return x;
+};
+P.plus = P.add = function(y) {
+	var e, k, t, x = this, Big = x.constructor;
+	y = new Big(y);
+	if (x.s != y.s) {
+		y.s = -y.s;
+		return x.minus(y);
+	}
+	var xe = x.e, xc = x.c, ye = y.e, yc = y.c;
+	if (!xc[0] || !yc[0]) {
+		if (!yc[0]) if (xc[0]) y = new Big(x);
+		else y.s = x.s;
+		return y;
+	}
+	xc = xc.slice();
+	if (e = xe - ye) {
+		if (e > 0) {
+			ye = xe;
+			t = yc;
+		} else {
+			e = -e;
+			t = xc;
+		}
+		t.reverse();
+		for (; e--;) t.push(0);
+		t.reverse();
+	}
+	if (xc.length - yc.length < 0) {
+		t = yc;
+		yc = xc;
+		xc = t;
+	}
+	e = yc.length;
+	for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;
+	if (k) {
+		xc.unshift(k);
+		++ye;
+	}
+	for (e = xc.length; xc[--e] === 0;) xc.pop();
+	y.c = xc;
+	y.e = ye;
+	return y;
+};
+P.pow = function(n) {
+	var x = this, one = new x.constructor("1"), y = one, isneg = n < 0;
+	if (n !== ~~n || n < -1e6 || n > MAX_POWER) throw Error(INVALID + "exponent");
+	if (isneg) n = -n;
+	for (;;) {
+		if (n & 1) y = y.times(x);
+		n >>= 1;
+		if (!n) break;
+		x = x.times(x);
+	}
+	return isneg ? one.div(y) : y;
+};
+P.prec = function(sd, rm) {
+	if (sd !== ~~sd || sd < 1 || sd > MAX_DP) throw Error(INVALID + "precision");
+	return round(new this.constructor(this), sd, rm);
+};
+P.round = function(dp, rm) {
+	if (dp === UNDEFINED) dp = 0;
+	else if (dp !== ~~dp || dp < -1e6 || dp > MAX_DP) throw Error(INVALID_DP);
+	return round(new this.constructor(this), dp + this.e + 1, rm);
+};
+P.sqrt = function() {
+	var r, c, t, x = this, Big = x.constructor, s = x.s, e = x.e, half = new Big("0.5");
+	if (!x.c[0]) return new Big(x);
+	if (s < 0) throw Error(NAME + "No square root");
+	s = Math.sqrt(x + "");
+	if (s === 0 || s === Infinity) {
+		c = x.c.join("");
+		if (!(c.length + e & 1)) c += "0";
+		s = Math.sqrt(c);
+		e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
+		r = new Big((s == Infinity ? "5e" : (s = s.toExponential()).slice(0, s.indexOf("e") + 1)) + e);
+	} else r = new Big(s + "");
+	e = r.e + (Big.DP += 4);
+	do {
+		t = r;
+		r = half.times(t.plus(x.div(t)));
+	} while (t.c.slice(0, e).join("") !== r.c.slice(0, e).join(""));
+	return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);
+};
+P.times = P.mul = function(y) {
+	var c, x = this, Big = x.constructor, xc = x.c, yc = (y = new Big(y)).c, a = xc.length, b = yc.length, i = x.e, j = y.e;
+	y.s = x.s == y.s ? 1 : -1;
+	if (!xc[0] || !yc[0]) {
+		y.c = [y.e = 0];
+		return y;
+	}
+	y.e = i + j;
+	if (a < b) {
+		c = xc;
+		xc = yc;
+		yc = c;
+		j = a;
+		a = b;
+		b = j;
+	}
+	for (c = new Array(j = a + b); j--;) c[j] = 0;
+	for (i = b; i--;) {
+		b = 0;
+		for (j = a + i; j > i;) {
+			b = c[j] + yc[i] * xc[j - i - 1] + b;
+			c[j--] = b % 10;
+			b = b / 10 | 0;
+		}
+		c[j] = b;
+	}
+	if (b) ++y.e;
+	else c.shift();
+	for (i = c.length; !c[--i];) c.pop();
+	y.c = c;
+	return y;
+};
+P.toExponential = function(dp, rm) {
+	var x = this, n = x.c[0];
+	if (dp !== UNDEFINED) {
+		if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);
+		x = round(new x.constructor(x), ++dp, rm);
+		for (; x.c.length < dp;) x.c.push(0);
+	}
+	return stringify(x, true, !!n);
+};
+P.toFixed = function(dp, rm) {
+	var x = this, n = x.c[0];
+	if (dp !== UNDEFINED) {
+		if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);
+		x = round(new x.constructor(x), dp + x.e + 1, rm);
+		for (dp = dp + x.e + 1; x.c.length < dp;) x.c.push(0);
+	}
+	return stringify(x, false, !!n);
+};
+P[Symbol.for("nodejs.util.inspect.custom")] = P.toJSON = P.toString = function() {
+	var x = this, Big = x.constructor;
+	return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);
+};
+P.toNumber = function() {
+	var n = Number(stringify(this, true, true));
+	if (this.constructor.strict === true && !this.eq(n.toString())) throw Error(NAME + "Imprecise conversion");
+	return n;
+};
+P.toPrecision = function(sd, rm) {
+	var x = this, Big = x.constructor, n = x.c[0];
+	if (sd !== UNDEFINED) {
+		if (sd !== ~~sd || sd < 1 || sd > MAX_DP) throw Error(INVALID + "precision");
+		x = round(new Big(x), sd, rm);
+		for (; x.c.length < sd;) x.c.push(0);
+	}
+	return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);
+};
+P.valueOf = function() {
+	var x = this, Big = x.constructor;
+	if (Big.strict === true) throw Error(NAME + "valueOf disallowed");
+	return stringify(x, x.e <= Big.NE || x.e >= Big.PE, true);
+};
+var Big = _Big_();
+//#endregion
+//#region src/productCustomization/pricing.ts
+const forEachBillableUnit = (group, modifiers, onUnit) => {
+	const groupChargeAbove = group.charge_above_quantity ?? 0;
+	let chargedCount = 0;
+	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 modifierChargeAbove = pricingModifier?.charge_above_quantity ?? 0;
+		let remaining = billableQuantity(modifier.quantity, modifierChargeAbove);
+		while (remaining > 0) {
+			onUnit(modifier, unit, chargedCount >= groupChargeAbove);
+			chargedCount += 1;
+			remaining -= 1;
+		}
+	}
+};
+const computeGroupModifierLinePrices = (group, modifiers) => {
+	const lineByPath = /* @__PURE__ */ new Map();
+	for (const modifier of modifiers) lineByPath.set(modifier.path, new Big(0));
+	forEachBillableUnit(group, modifiers, (modifier, unit, isCharged) => {
+		if (!isCharged) return;
+		lineByPath.set(modifier.path, lineByPath.get(modifier.path).plus(unit));
+	});
+	for (const modifier of modifiers) modifier.linePrice = lineByPath.get(modifier.path)?.toNumber() ?? 0;
+};
+const computeGroupModifiersPrice = (group, modifiers) => {
+	let total = new Big(0);
+	forEachBillableUnit(group, modifiers, (_modifier, unit, isCharged) => {
+		if (isCharged) total = total.plus(unit);
+	});
+	for (const modifier of modifiers) {
+		if (!modifier.product) continue;
+		if (modifier.quantity <= 0) continue;
+		const scaled = new Big(computeProductModifiersPrice(modifier.product)).times(modifier.quantity);
+		total = total.plus(scaled);
+	}
+	return total.toNumber();
+};
+const computeProductModifiersPrice = (product) => {
+	let total = new Big(0);
+	for (const group of product.groups) total = total.plus(computeGroupModifiersPrice(group.data, group.modifiers));
+	return total.toNumber();
+};
+const computeTotalPrice = (product) => {
+	const unit = new Big(product.data.pricing.price);
+	const mods = computeProductModifiersPrice(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) => {
+	product.quantity = getQuantity(store, product.path);
+	for (const group of product.groups) {
+		for (const modifier of group.modifiers) {
+			refreshModifierFields(modifier, group, store);
+			if (modifier.product) {
+				modifier.product.quantity = modifier.quantity;
+				refreshProductTree(modifier.product, store);
+			}
+		}
+		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);
+			}
+		}
+	}
+};
+//#endregion
+//#region src/productCustomization/validation.ts
+const finalize = (status, soft) => {
+	if (soft && status === "INVALID") return "INCOMPLETE";
+	return status;
+};
+const validateModifier = (modifier, options) => {
+	const soft = options?.soft ?? false;
+	const { quantity, min, max } = modifier;
+	let status;
+	if (quantity === 0) status = min > 0 ? "INCOMPLETE" : "IDLE";
+	else if (quantity > max) status = "INVALID";
+	else if (quantity < min) status = "INCOMPLETE";
+	else status = "VALID";
+	if (quantity > 0 && modifier.product) {
+		const nestedStatus = validateProduct(modifier.product, options);
+		if (nestedStatus === "INVALID") status = "INVALID";
+		else if (status === "VALID" && nestedStatus !== "VALID") status = "INCOMPLETE";
+	}
+	return finalize(status, soft);
+};
+const validateGroup = (group, options) => {
+	const soft = options?.soft ?? false;
+	const { selectedQuantity, min, max, modifiers } = group;
+	if (selectedQuantity > max) return finalize("INVALID", soft);
+	let hasInvalid = false;
+	let hasIncomplete = false;
+	for (const modifier of modifiers) {
+		modifier.status = validateModifier(modifier, options);
+		if (modifier.status === "INVALID") hasInvalid = true;
+		if (modifier.quantity > 0 && modifier.status !== "VALID") hasIncomplete = true;
+	}
+	if (hasInvalid) return finalize("INVALID", soft);
+	if (selectedQuantity < min) return "INCOMPLETE";
+	if (selectedQuantity === 0 && min === 0) return "VALID";
+	if (hasIncomplete) return "INCOMPLETE";
+	return "VALID";
+};
+const validateProduct = (product, options) => {
+	const soft = options?.soft ?? false;
+	const { quantity, min, max, groups } = product;
+	if (quantity === 0) {
+		product.status = min > 0 ? "INCOMPLETE" : "IDLE";
+		return product.status;
+	}
+	let hasInvalid = false;
+	let hasIncomplete = false;
+	for (const group of groups) {
+		group.selectedQuantity = group.modifiers.reduce((sum, modifier) => {
+			return sum + modifier.quantity;
+		}, 0);
+		group.status = validateGroup(group, options);
+		if (group.status === "INVALID") hasInvalid = true;
+		if (group.status !== "VALID") hasIncomplete = true;
+	}
+	if (quantity > max) {
+		product.status = finalize("INVALID", soft);
+		return product.status;
+	}
+	if (quantity < min) {
+		product.status = "INCOMPLETE";
+		return product.status;
+	}
+	if (hasInvalid) {
+		product.status = finalize("INVALID", soft);
+		return product.status;
+	}
+	if (hasIncomplete) {
+		product.status = "INCOMPLETE";
+		return product.status;
+	}
+	product.status = "VALID";
+	return product.status;
+};
+const runAfterChange = (runtime) => {
+	refreshProductTree(runtime.root, runtime.store);
+	validateProduct(runtime.root, { soft: true });
+	runtime.listeners.forEach((listener) => listener());
+};
+//#endregion
+//#region src/productCustomization/createCtx.ts
+const createModifierCtx = (runtime, productCtx, group, modifierProduct, modifierPath) => {
+	const pricingModifier = resolvePricingModifier(...[modifierProduct, group.data.id]);
+	const type = inferControlType(pricingModifier, group.data);
+	const modifier = {
+		path: modifierPath,
+		min: pricingModifier?.minimum_quantity ?? 0,
+		max: pricingModifier?.maximum_quantity ?? group.data.maximum_quantity,
+		quantity: 0,
+		required: (pricingModifier?.minimum_quantity ?? 0) > 0,
+		status: "IDLE",
+		data: modifierProduct,
+		type,
+		product: null,
+		linePrice: 0,
+		onChange: () => {}
+	};
+	modifier.onChange = (quantity) => {
+		const next = clampModifierQuantity(...[
+			type,
+			quantity,
+			modifier.min,
+			modifier.max
+		]);
+		if (type === "RADIO" && next > 0) for (const sibling of group.modifiers) {
+			if (sibling.path === modifier.path) continue;
+			setQuantity(runtime.store, sibling.path, 0);
+			clearSubtree(runtime.store, sibling.path);
+		}
+		if (next <= 0) {
+			clearSubtree(runtime.store, modifierPath);
+			setQuantity(runtime.store, modifierPath, 0);
+		} else setQuantity(runtime.store, modifierPath, next);
+		runAfterChange(runtime);
+	};
+	if (modifierProduct.pricing.modifier_group_ids.length > 0) modifier.product = createProductCtx(...[
+		runtime,
+		modifierProduct,
+		modifierPath,
+		false
+	]);
+	return modifier;
+};
+const createModifierGroupCtx = (runtime, productCtx, group, productPath) => {
+	const groupPath = `${productPath}/group/${group.id}`;
+	const groupCtx = {
+		path: groupPath,
+		min: group.minimum_quantity,
+		max: group.maximum_quantity,
+		required: group.minimum_quantity > 0,
+		status: "IDLE",
+		data: group,
+		display: group.display_type ?? "LIST",
+		selectedQuantity: 0,
+		modifiers: []
+	};
+	for (const modifierId of group.modifier_ids) {
+		const modifierProduct = runtime.lookup.productsById[modifierId];
+		if (!modifierProduct) continue;
+		const modifierPath = `${groupPath}/modifier/${modifierId}`;
+		const args1 = [
+			runtime,
+			productCtx,
+			groupCtx
+		];
+		const args2 = [modifierProduct, modifierPath];
+		const ctx = createModifierCtx(...args1, ...args2);
+		groupCtx.modifiers.push(ctx);
+	}
+	return groupCtx;
+};
+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,
+		status: "IDLE",
+		data: product,
+		groups: [],
+		onChange: () => {},
+		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);
+	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.reset = (options) => {
+		clearSubtree(runtime.store, path);
+		if (options?.force) {
+			if (isRoot) applyCatalogDefaults(runtime.store, runtime.lookup, product, 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);
+		}
+		runAfterChange(runtime);
+	};
+	return productCtx;
+};
+//#endregion
+//#region src/productCustomization/createSession.ts
+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 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 listeners = /* @__PURE__ */ new Set();
+	const runtime = {
+		lookup,
+		store,
+		listeners,
+		root: null
+	};
+	runtime.root = createProductCtx(runtime, product, rootPath, true);
+	refreshProductTree(runtime.root, runtime.store);
+	validateProduct(runtime.root);
+	return {
+		root: runtime.root,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		snapshot: () => {
+			return {
+				productId,
+				quantities: cloneQuantities(store.quantities)
+			};
+		},
+		totalPrice: () => {
+			refreshProductTree(runtime.root, runtime.store);
+			return computeTotalPrice(runtime.root);
+		},
+		validate: (options) => {
+			refreshProductTree(runtime.root, runtime.store);
+			const status = validateProduct(runtime.root, options);
+			runtime.listeners.forEach((listener) => listener());
+			return status;
+		},
+		reset: (options) => runtime.root.reset(options)
+	};
+};
+//#endregion
+//#region src/productCustomization/flattenCategories.ts
+const nestMenuCategories = (sections) => {
+	const roots = [];
+	const stack = [];
+	for (const section of sections) {
+		while (stack.length > 0) {
+			const top = stack[stack.length - 1];
+			if (top && top.origin < section.depth) break;
+			stack.pop();
+		}
+		const b1 = {
+			category: section.category,
+			depth: stack.length
+		};
+		const b2 = {
+			instanceId: section.instanceId,
+			children: []
+		};
+		const node = {
+			...b1,
+			...b2
+		};
+		const parent = stack[stack.length - 1];
+		if (parent) parent.node.children.push(node);
+		else roots.push(node);
+		stack.push({
+			origin: section.depth,
+			node
+		});
+	}
+	return roots;
+};
+const flattenMenuCategories = (categories, categoriesById, options) => {
+	const inputIds = new Set(categories.map((category) => category.id));
+	const nestedInInput = /* @__PURE__ */ new Set();
+	for (const category of categories) for (const item of category.items) {
+		if (item.type === "PRODUCT") continue;
+		if (item.id === category.id) continue;
+		if (inputIds.has(item.id)) nestedInInput.add(item.id);
+	}
+	const sections = [];
+	const include = options?.include;
+	const walk = (category, ancestry) => {
+		if (ancestry.includes(category.id)) return;
+		if (include && !include(category)) return;
+		const path = [...ancestry, category.id];
+		const instanceId = path.join("/");
+		sections.push({
+			category,
+			depth: ancestry.length,
+			instanceId
+		});
+		for (const item of category.items) {
+			if (item.type === "PRODUCT") continue;
+			if (item.id === category.id) continue;
+			const child = categoriesById.get(item.id);
+			if (child) walk(child, path);
+		}
+	};
+	for (const category of categories) {
+		if (nestedInInput.has(category.id)) continue;
+		walk(category, []);
+	}
+	return sections;
+};
+//#endregion
+//#region src/productCustomization/fromOrderLines.ts
+/**
+* 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];
+		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);
+		}
+	};
+	walk(root.id, root.uid, `/${root.id}`);
+	return {
+		productId: root.id,
+		quantities
+	};
+};
+//#endregion
+//#region src/productCustomization/menu.ts
+const indexMenu = (menu) => {
+	const productsById = {};
+	for (const product of menu.products) productsById[product.id] = product;
+	const modifierGroupsById = {};
+	const modifierGroups = resolveModifierGroupsForLookup(...[menu.products, menu.modifier_groups]);
+	for (const group of modifierGroups) modifierGroupsById[group.id] = group;
+	const categoriesById = {};
+	for (const category of menu.categories) categoriesById[category.id] = category;
+	const recommendationsById = {};
+	for (const recommendation of menu.recommendations ?? []) recommendationsById[recommendation.id] = recommendation;
+	return {
+		productsById,
+		modifierGroupsById,
+		categoriesById,
+		recommendationsById
+	};
+};
+//#endregion
+//#region src/shared/randomUUID.ts
+/** UUID v4 — works when `crypto.randomUUID` is missing (React Native / Hermes). */
+const randomUUID = () => {
+	const c = globalThis.crypto;
+	if (typeof c?.randomUUID === "function") return c.randomUUID();
+	if (typeof c?.getRandomValues !== "function") throw new Error("crypto.getRandomValues is required");
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	c.getRandomValues(bytes);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const toHex = (b) => b.toString(16).padStart(2, "0");
+	const hex = Array.from(bytes, toHex).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+};
+//#endregion
+//#region src/productCustomization/toOrderLines.ts
+const displayName = (text, locale) => {
+	if (text[locale]) return text[locale];
+	return Object.values(text)[0] ?? "";
+};
+const applyUnitMoney = (config) => {
+	const qty = new Big(config.quantity);
+	const unitDiscount = config.unitSubtotal.times(config.discountRate);
+	const net = config.unitSubtotal.minus(unitDiscount);
+	let unitTax = net.times(config.taxRate);
+	let unitTotal = net.plus(unitTax);
+	if (config.isTaxInclusive) {
+		const divisor = new Big(1).plus(config.taxRate);
+		unitTax = net.times(config.taxRate).div(divisor);
+		unitTotal = net;
+	}
+	const r1 = { tax_rate: config.taxRate };
+	const r2 = { discount_rate: config.discountRate };
+	const r3 = { unit_subtotal: config.unitSubtotal.toNumber() };
+	const r4 = { unit_discount: unitDiscount.toNumber() };
+	const r5 = { unit_tax_total: unitTax.toNumber() };
+	const r6 = { unit_total: unitTotal.toNumber() };
+	const r7 = { subtotal: config.unitSubtotal.times(qty).toNumber() };
+	const r8 = { discount_total: unitDiscount.times(qty).toNumber() };
+	const r9 = { tax_total: unitTax.times(qty).toNumber() };
+	const r10 = { total: unitTotal.times(qty).toNumber() };
+	return {
+		...r1,
+		...r2,
+		...r3,
+		...r4,
+		...r5,
+		...r6,
+		...r7,
+		...r8,
+		...r9,
+		...r10
+	};
+};
+const emptyGroupMoney = () => {
+	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 lineCatalogFields = (product) => {
+	return {
+		metadata: { ...product.metadata ?? {} },
+		bundled_items: [...product.bundled_items ?? []]
+	};
+};
+const buildLine = (args) => {
+	const b1 = {
+		unitSubtotal: args.unitSubtotal,
+		quantity: args.quantity
+	};
+	const b2 = {
+		taxRate: args.taxRate,
+		discountRate: 0
+	};
+	const b3 = { isTaxInclusive: args.isTaxInclusive };
+	const moneyArgs = {
+		...b1,
+		...b2,
+		...b3
+	};
+	const money = applyUnitMoney(moneyArgs);
+	const imageUrl = args.product.image_url ?? void 0;
+	const imagePatch = imageUrl ? { image_url: imageUrl } : {};
+	const catalog = lineCatalogFields(args.product);
+	const groupMoney = emptyGroupMoney();
+	const r1 = {
+		type: "PRODUCT",
+		uid: randomUUID()
+	};
+	const r2 = {
+		id: args.product.id,
+		parent_uid: args.parent_uid
+	};
+	const r3 = {
+		parent_id: args.parent_id,
+		name: args.name
+	};
+	const r4 = {
+		...imagePatch,
+		...catalog
+	};
+	const r5 = {
+		quantity: args.quantity,
+		redeem: [],
+		...money
+	};
+	const r6 = {
+		...groupMoney,
+		children: []
+	};
+	return {
+		...r1,
+		...r2,
+		...r3,
+		...r4,
+		...r5,
+		...r6
+	};
+};
+const finalizeGroupMoney = (node) => {
+	for (const child of node.children) finalizeGroupMoney(child);
+	let groupSubtotal = new Big(node.subtotal);
+	let groupDiscount = new Big(node.discount_total);
+	let groupTax = new Big(node.tax_total);
+	let groupTotal = new Big(node.total);
+	let childSubtotal = new Big(0);
+	let childDiscount = new Big(0);
+	let childTax = new Big(0);
+	let childTotal = new Big(0);
+	for (const child of node.children) {
+		childSubtotal = childSubtotal.plus(child.group_subtotal);
+		childDiscount = childDiscount.plus(child.group_discount);
+		childTax = childTax.plus(child.group_tax_total);
+		childTotal = childTotal.plus(child.group_total);
+	}
+	const qty = new Big(node.quantity);
+	groupSubtotal = groupSubtotal.plus(childSubtotal.times(qty));
+	groupDiscount = groupDiscount.plus(childDiscount.times(qty));
+	groupTax = groupTax.plus(childTax.times(qty));
+	groupTotal = groupTotal.plus(childTotal.times(qty));
+	node.group_subtotal = groupSubtotal.toNumber();
+	node.group_discount = groupDiscount.toNumber();
+	node.group_tax_total = groupTax.toNumber();
+	node.unit_group_subtotal = groupSubtotal.div(qty).toNumber();
+	node.unit_group_discount = groupDiscount.div(qty).toNumber();
+	node.unit_group_tax_total = groupTax.div(qty).toNumber();
+	node.group_total = groupTotal.toNumber();
+	node.unit_group_total = groupTotal.div(qty).toNumber();
+};
+const flatten = (node, out) => {
+	const { children, ...line } = node;
+	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
+			});
+		}
+	}
+};
+/** Flatten a customized product tree into priced OrderLine rows. */
+const toOrderLines = (root, locale) => {
+	if (root.quantity <= 0) return [];
+	const name = displayName(root.data.name, locale);
+	const unitSubtotal = new Big(root.data.pricing.price);
+	const t1 = {
+		product: root.data,
+		name,
+		quantity: root.quantity
+	};
+	const t2 = {
+		unitSubtotal,
+		taxRate: root.data.pricing.tax_rate
+	};
+	const t3 = { isTaxInclusive: root.data.pricing.is_tax_inclusive };
+	const t4 = {
+		parent_uid: null,
+		parent_id: null
+	};
+	const rootLine = buildLine({
+		...t1,
+		...t2,
+		...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
+		});
+	}
+	finalizeGroupMoney(rootLine);
+	const lines = [];
+	flatten(rootLine, lines);
+	return lines;
+};
+//#endregion
+//#region src/shared/baseUrl.ts
+const DEFAULT_BASE_URL = "https://firespark.cloud";
+const resolveBaseUrl = (baseUrl) => {
+	return (baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+};
+//#endregion
+//#region src/auth/exchange.ts
+const exchangeSubjectToken = async (subjectToken, options = {}) => {
+	const base = resolveBaseUrl(options.baseUrl);
+	const response = await (options.fetchImpl ?? fetch)(`${base}/api/storefront/v1/oauth/exchange`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
+			subject_token: subjectToken,
+			subject_token_type: "urn:ietf:params:oauth:token-type:id_token"
+		})
+	});
+	if (!response.ok) {
+		const message = await response.text();
+		throw new Error(message || `Token exchange failed (${response.status})`);
+	}
+	const json = await response.json();
+	if (!json.data?.access_token) throw new Error("Token exchange response missing access_token");
+	return json.data;
+};
+//#endregion
+//#region src/auth/auth.ts
+const DEFAULT_TOKEN_SKEW_MS = 3e4;
+let state = null;
+const configure = (options) => {
+	state = {
+		getSubjectToken: options.getSubjectToken ?? null,
+		getDirectToken: options.getAccessToken ?? null,
+		baseUrl: resolveBaseUrl(options.baseUrl),
+		fetchImpl: options.fetchImpl ?? fetch,
+		tokenSkewMs: options.tokenSkewMs ?? DEFAULT_TOKEN_SKEW_MS,
+		accessToken: null,
+		expiresAt: 0
+	};
+};
+const getBaseUrl = () => {
+	if (!state) throw new Error("auth.configure() must be called before getBaseUrl()");
+	return state.baseUrl;
+};
+const clear = () => {
+	if (!state) return;
+	state.accessToken = null;
+	state.expiresAt = 0;
+};
+const issueToken = async (current) => {
+	if (current.getDirectToken) return current.getDirectToken();
+	if (!current.getSubjectToken) throw new Error("auth.configure() needs getSubjectToken or getAccessToken");
+	return exchangeSubjectToken(await current.getSubjectToken(), {
+		baseUrl: current.baseUrl,
+		fetchImpl: current.fetchImpl
+	});
+};
+const getAccessToken = async () => {
+	if (!state) throw new Error("auth.configure() must be called before getAccessToken()");
+	const now = Date.now();
+	if (state.accessToken && state.expiresAt > now + state.tokenSkewMs) return state.accessToken;
+	const issued = await issueToken(state);
+	state.accessToken = issued.access_token;
+	state.expiresAt = now + issued.expires_in * 1e3;
+	return state.accessToken;
+};
+//#endregion
+//#region src/auth/index.ts
+const auth = {
+	configure,
+	getAccessToken,
+	getBaseUrl,
+	clear,
+	exchangeSubjectToken,
+	resolveBaseUrl
+};
+//#endregion
+//#region src/order/customer.ts
+const splitName = (name) => {
+	const parts = name.trim().split(/\s+/).filter(Boolean);
+	const first_name = parts[0] ?? name;
+	return {
+		first_name,
+		last_name: parts.length > 1 ? parts.slice(1).join(" ") : first_name,
+		display_name: name
+	};
+};
+/** Builds the order `customer` snapshot sent on create/update. */
+const buildCustomerSnapshot = (source) => {
+	const names = splitName(source.name);
+	return { customer_info: {
+		display_name: names.display_name,
+		first_name: names.first_name,
+		last_name: names.last_name,
+		email: source.email ?? "unknown@example.com",
+		phone: source.phone ?? "+10000000000"
+	} };
+};
+//#endregion
+//#region src/services/http.ts
+var StorefrontHttpError = class extends Error {
+	status;
+	code;
+	constructor(message, status, code) {
+		super(message);
+		this.name = "StorefrontHttpError";
+		this.status = status;
+		this.code = code;
+	}
+};
+const isStorefrontNotFound = (error) => {
+	return error instanceof StorefrontHttpError && error.status === 404;
+};
+const httpBaseUrl = (options) => {
+	if (options.baseUrl) return resolveBaseUrl(options.baseUrl);
+	try {
+		return auth.getBaseUrl();
+	} catch {
+		return resolveBaseUrl();
+	}
+};
+const resolveAccessToken = async (options) => {
+	if (options.accessToken) return options.accessToken;
+	return auth.getAccessToken();
+};
+const withAuthRetry = async (options, run) => {
+	const response = await run(await resolveAccessToken(options));
+	if (response.status !== 401 || options.accessToken) return response;
+	auth.clear();
+	return run(await resolveAccessToken(options));
+};
+/** Low-level storefront fetch. Prefer typed services over calling this directly. */
+const storefrontRequest = async (path, init = {}, options = {}) => {
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const url = `${httpBaseUrl(options)}${path.startsWith("/") ? path : `/${path}`}`;
+	return withAuthRetry(options, (accessToken) => {
+		const headers = new Headers(init.headers);
+		headers.set("Authorization", `Bearer ${accessToken}`);
+		if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+		const signal = options.signal ?? init.signal;
+		const req = {
+			...init,
+			headers,
+			signal
+		};
+		return fetchImpl(url, req);
+	});
+};
+const storefrontJson = async (path, init = {}, options = {}) => {
+	const response = await storefrontRequest(path, init, options);
+	if (!response.ok) throw new StorefrontHttpError(await response.text() || response.statusText, response.status);
+	const json = await response.json();
+	if (json.data === void 0) throw new Error("Storefront response missing data");
+	return json.data;
+};
+const storefrontVoid = async (path, init = {}, options = {}) => {
+	const response = await storefrontRequest(path, init, options);
+	if (!response.ok) throw new StorefrontHttpError(await response.text() || response.statusText, response.status);
+};
+const parseNdjsonDataLine = (line) => {
+	const trimmed = line.trim();
+	if (!trimmed) return null;
+	const json = JSON.parse(trimmed);
+	if (json.data === void 0) throw new Error("Storefront response missing data");
+	return json.data;
+};
+const readNdjsonLines = async function* (body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (value) buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) yield line;
+			if (done) {
+				if (buffer) yield buffer;
+				break;
+			}
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+	}
+};
+/** Parse an NDJSON storefront body and yield each `{ data }` payload. */
+const storefrontNdjson = async function* (path, init = {}, options = {}) {
+	const response = await storefrontRequest(path, init, options);
+	if (!response.ok) throw new StorefrontHttpError(await response.text() || response.statusText, response.status);
+	if (response.body) {
+		for await (const line of readNdjsonLines(response.body)) {
+			const data = parseNdjsonDataLine(line);
+			if (data !== null) yield data;
+		}
+		return;
+	}
+	const text = await response.text();
+	for (const line of text.split("\n")) {
+		const data = parseNdjsonDataLine(line);
+		if (data !== null) yield data;
+	}
+};
+//#endregion
+//#region src/services/preferences.ts
+const preferencesQuery = (scope) => {
+	const params = new URLSearchParams();
+	if (scope.fulfillment_id) params.set("fulfillment_id", scope.fulfillment_id);
+	if (scope.store_id) params.set("store_id", scope.store_id);
+	if (scope.channel_id) params.set("channel_id", scope.channel_id);
+	if (scope.brand_id) params.set("brand_id", scope.brand_id);
+	const query = params.toString();
+	const path = "/api/storefront/v1/preferences";
+	return query ? `${path}?${query}` : path;
+};
+const getPreferences = (scope = {}, options) => {
+	return storefrontJson(...[
+		preferencesQuery(scope),
+		{},
+		options
+	]);
+};
+//#endregion
+//#region src/services/availability.ts
+const getAvailability = async (scope = {}, options) => {
+	return (await getPreferences(scope, options)).availability;
+};
+//#endregion
+//#region src/services/cms.ts
+const cmsBlockPath = (name) => {
+	return `/api/storefront/v1/cms/blocks/${encodeURIComponent(name)}`;
+};
+const getCmsBlock = (name, options) => {
+	return storefrontJson(cmsBlockPath(name), {}, options);
+};
+//#endregion
+//#region src/services/customers.ts
+const customerPath = (id) => {
+	return `/api/storefront/v1/customers/${encodeURIComponent(id)}`;
+};
+const getCustomer = (id, options) => {
+	return storefrontJson(customerPath(id), {}, options);
+};
+const createCustomer = (body, options) => {
+	return storefrontJson("/api/storefront/v1/customers", {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+};
+const identifyAnonymousCustomer = (id, body, options) => {
+	return storefrontJson(`${customerPath(id)}/identify/anonymous`, {
+		method: "PATCH",
+		body: JSON.stringify(body)
+	}, options);
+};
+const updateCustomer = (id, body, options) => {
+	return storefrontJson(customerPath(id), {
+		method: "PATCH",
+		body: JSON.stringify(body)
+	}, options);
+};
+const deleteCustomer = (id, options) => {
+	return storefrontVoid(customerPath(id), { method: "DELETE" }, options);
+};
+//#endregion
+//#region src/services/fulfillment.ts
+const fulfillmentPath = (id) => {
+	const base = "/api/storefront/v1/fulfillment";
+	if (!id) return base;
+	return `${base}/${encodeURIComponent(id)}`;
+};
+const withChannelQuery = (path, input = {}) => {
+	const params = new URLSearchParams();
+	if (input.channel_id) params.set("channel_id", input.channel_id);
+	const query = params.toString();
+	if (!query) return path;
+	return `${path}?${query}`;
+};
+const listFulfillment = (input = {}, options) => {
+	return storefrontJson(withChannelQuery(fulfillmentPath(), input), {}, options);
+};
+const getFulfillment = (id, input = {}, options) => {
+	return storefrontJson(withChannelQuery(fulfillmentPath(id), input), {}, options);
+};
+//#endregion
+//#region src/services/kiosk.ts
+const kioskUrl = (path, options) => {
+	const override = options?.baseUrl;
+	const base = override ? resolveBaseUrl(override) : resolveBaseUrl();
+	if (!path.startsWith("/")) return `${base}/${path}`;
+	return `${base}${path}`;
+};
+const kioskFetch = async (path, init, options) => {
+	const fetchImpl = options?.fetchImpl ?? fetch;
+	const headers = new Headers(init.headers);
+	if (init.body && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+	const signal = options?.signal ?? init.signal;
+	const req = {
+		...init,
+		headers,
+		signal
+	};
+	return fetchImpl(kioskUrl(path, options), req);
+};
+const readError = async (response) => {
+	const text = await response.text();
+	try {
+		return JSON.parse(text);
+	} catch {
+		return { error: text || response.statusText };
+	}
+};
+const isDeviceNotLinked = (error) => {
+	if (!(error instanceof StorefrontHttpError)) return false;
+	if (error.code === "DEVICE_NOT_LINKED") return true;
+	if (error.status !== 404) return false;
+	return error.message.includes("DEVICE_NOT_LINKED");
+};
+const isKioskUnauthorized = (error) => {
+	return error instanceof StorefrontHttpError && error.status === 401;
+};
+const throwKioskError = (body, status) => {
+	throw new StorefrontHttpError(body.error ?? "Request failed", status, body.code);
+};
+const getKioskConfig = async (input, options) => {
+	const path = "/api/storefront/v1/kiosk/devices/link";
+	const init = {
+		method: "POST",
+		body: JSON.stringify(input)
+	};
+	const response = await kioskFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwKioskError(body, response.status);
+	}
+	return (await response.json()).data;
+};
+const postKioskHeartbeat = async (input, options) => {
+	const path = "/api/storefront/v1/kiosk/devices/me";
+	const init = {
+		method: "POST",
+		body: JSON.stringify(input)
+	};
+	const response = await kioskFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwKioskError(body, response.status);
+	}
+	return await response.json();
+};
+const postKioskHealthSamples = async (input, options) => {
+	const path = "/api/storefront/v1/kiosk/devices/me/health";
+	const init = {
+		method: "POST",
+		body: JSON.stringify(input)
+	};
+	const response = await kioskFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwKioskError(body, response.status);
+	}
+	return await response.json();
+};
+const patchKioskOverrides = async (input, options) => {
+	const path = "/api/storefront/v1/kiosk/devices/me";
+	const init = {
+		method: "PATCH",
+		body: JSON.stringify(input)
+	};
+	const response = await kioskFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwKioskError(body, response.status);
+	}
+	return (await response.json()).data;
+};
+const unlinkKioskSelf = async (input, options) => {
+	const path = "/api/storefront/v1/kiosk/devices/me";
+	const init = {
+		method: "DELETE",
+		body: JSON.stringify(input)
+	};
+	const response = await kioskFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwKioskError(body, response.status);
+	}
+	return (await response.json()).data;
+};
+/** 403 wrong or expired code, 429 too many tries for the current code. */
+const verifyKioskAdminCode = async (input, options) => {
+	const path = "/api/storefront/v1/kiosk/devices/me/admin-code";
+	const init = {
+		method: "POST",
+		body: JSON.stringify(input)
+	};
+	const response = await kioskFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwKioskError(body, response.status);
+	}
+	return (await response.json()).data;
+};
+const isKioskAdminCodeInvalid = (error) => {
+	return error instanceof StorefrontHttpError && error.status === 403;
+};
+const isKioskAdminCodeLocked = (error) => {
+	return error instanceof StorefrontHttpError && error.status === 429;
+};
+const fetchKioskRealtimeToken = async (input, options) => {
+	const path = "/api/storefront/v1/kiosk/realtime/token";
+	const init = {
+		method: "POST",
+		body: JSON.stringify(input)
+	};
+	const response = await kioskFetch(path, init, options);
+	if (!response.ok) {
+		const body = await readError(response);
+		throwKioskError(body, response.status);
+	}
+	return (await response.json()).data;
+};
+//#endregion
+//#region src/services/menus.ts
+const menuQuery = (scope, stream) => {
+	const params = new URLSearchParams();
+	if (scope.fulfillment_id) params.set("fulfillment_id", scope.fulfillment_id);
+	if (scope.store_id) params.set("store_id", scope.store_id);
+	if (scope.channel_id) params.set("channel_id", scope.channel_id);
+	if (scope.brand_id) params.set("brand_id", scope.brand_id);
+	if (stream?.streaming) params.set("streaming", "true");
+	if (stream?.category_limit != null) params.set("category_limit", String(stream.category_limit));
+	if (stream?.product_limit != null) params.set("product_limit", String(stream.product_limit));
+	const query = params.toString();
+	return `/api/storefront/v1/menus${query ? `?${query}` : ""}`;
+};
+const listMenus = (scope = {}, options) => {
+	return storefrontJson(menuQuery(scope), {}, options);
+};
+const listMenusStream = (scope = {}, options = {}) => {
+	const { category_limit, product_limit, ...http } = options;
+	return storefrontNdjson(menuQuery(scope, {
+		streaming: true,
+		category_limit,
+		product_limit
+	}), {}, http);
+};
+//#endregion
+//#region src/order/OrderValidationError.ts
+var OrderValidationError = class extends Error {
+	issues;
+	lines;
+	constructor(issues, lines) {
+		super("Order validation failed");
+		this.name = "OrderValidationError";
+		this.issues = issues;
+		this.lines = lines;
+	}
+};
+const isOrderValidationError = (error) => {
+	return error instanceof OrderValidationError;
+};
+//#endregion
+//#region src/services/orders.ts
+const orderPath = (id) => {
+	const base = "/api/storefront/v1/orders";
+	if (!id) return base;
+	return `${base}/${encodeURIComponent(id)}`;
+};
+const listQuery = (input = {}) => {
+	const params = new URLSearchParams();
+	if (input.store_id) params.set("store_id", input.store_id);
+	if (input.channel_id) params.set("channel_id", input.channel_id);
+	if (input.fulfillment_id) params.set("fulfillment_id", input.fulfillment_id);
+	if (input.brand_id) params.set("brand_id", input.brand_id);
+	if (input.status) params.set("status", input.status);
+	if (input.limit != null) params.set("limit", String(input.limit));
+	if (input.cursor) params.set("cursor", input.cursor);
+	const query = params.toString();
+	if (!query) return orderPath();
+	return `${orderPath()}?${query}`;
+};
+const listOrders = (input = {}, options) => {
+	return storefrontJson(listQuery(input), {}, options);
+};
+const createOrder = (body, options) => {
+	return storefrontJson(orderPath(), {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+};
+const getOrder = (id, options) => {
+	return storefrontJson(orderPath(id), {}, options);
+};
+const placeOrder = (id, body = {}, options) => {
+	const init = {
+		method: "POST",
+		body: JSON.stringify(body)
+	};
+	return storefrontJson(...[
+		`${orderPath(id)}/place`,
+		init,
+		options
+	]);
+};
+const getOrderFulfillment = (id, options) => {
+	return storefrontJson(...[
+		`${orderPath(id)}/fulfillment`,
+		{},
+		options
+	]);
+};
+const LIST_FULFILLMENT_LIMIT = 20;
+const listOrderFulfillments = async (ids, options) => {
+	if (ids.length === 0) return [];
+	const unique = [...new Set(ids)];
+	const pages = [];
+	for (let i = 0; i < unique.length; i += LIST_FULFILLMENT_LIMIT) pages.push(unique.slice(i, i + LIST_FULFILLMENT_LIMIT));
+	return (await Promise.all(pages.map((page) => {
+		const params = new URLSearchParams();
+		params.set("ids", page.join(","));
+		return storefrontJson(`${orderPath()}/fulfillments?${params.toString()}`, {}, options);
+	}))).flat();
+};
+const updateOrder = (id, body, options) => {
+	return storefrontJson(orderPath(id), {
+		method: "PATCH",
+		body: JSON.stringify(body)
+	}, options);
+};
+const cancelOrder = (id, options) => {
+	return storefrontJson(`${orderPath(id)}/cancel`, { method: "POST" }, options);
+};
+const refundOrder = (id, options) => {
+	return storefrontJson(`${orderPath(id)}/refund`, { method: "POST" }, options);
+};
+const reorderOrder = (id, body = {}, options) => {
+	return storefrontJson(`${orderPath(id)}/reorder`, {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+};
+const parseValidationDetails = (body) => {
+	if (!body || typeof body !== "object") return null;
+	const details = body.details;
+	if (!details || typeof details !== "object") return null;
+	const record = details;
+	if (!Array.isArray(record.issues) || !record.lines) return null;
+	return {
+		issues: record.issues,
+		lines: record.lines
+	};
+};
+const validateOrder = async (body, options) => {
+	const response = await storefrontRequest(orderPath("validate"), {
+		method: "POST",
+		body: JSON.stringify(body)
+	}, options);
+	if (response.ok) {
+		const json = await response.json();
+		if (json.data === void 0) throw new Error("Storefront response missing data");
+		return json.data;
+	}
+	let parsed = null;
+	const text = await response.text();
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		parsed = null;
+	}
+	if (response.status === 422) {
+		const details = parseValidationDetails(parsed);
+		if (details) throw new OrderValidationError(details.issues, details.lines);
+	}
+	throw new StorefrontHttpError(text || response.statusText, response.status);
+};
+//#endregion
+//#region src/services/payments.ts
+const listPayments = (input, options) => {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(input)) if (value) params.set(key, value);
+	return storefrontJson(`/api/storefront/v1/payments?${params.toString()}`, {}, options);
+};
+//#endregion
+//#region src/services/stores.ts
+const storesPath = (suffix) => {
+	const base = "/api/storefront/v1/stores";
+	if (!suffix) return base;
+	return `${base}/${suffix}`;
+};
+const withQuery = (path, entries) => {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(entries)) {
+		if (value === void 0 || value === null || value === "") continue;
+		params.set(key, String(value));
+	}
+	const query = params.toString();
+	if (!query) return path;
+	return `${path}?${query}`;
+};
+/** Active stores of the merchant/env in the access token (one page). */
+const listStores = (input = {}, options) => {
+	return storefrontJson(withQuery(storesPath(), { ...input }), {}, options);
+};
+const listNearbyStores = (input, options) => {
+	const query = {
+		...input,
+		limit: input.limit ?? 20
+	};
+	return storefrontJson(withQuery(storesPath("nearby"), query), {}, options);
+};
+const getStore = (id, options) => {
+	return storefrontJson(storesPath(encodeURIComponent(id)), {}, options);
+};
+//#endregion
+//#region src/services/index.ts
+const services = {
+	preferences: { get: getPreferences },
+	availability: { get: getAvailability },
+	cms: { getBlock: getCmsBlock },
+	customers: {
+		get: getCustomer,
+		post: createCustomer,
+		patch: updateCustomer,
+		delete: deleteCustomer,
+		identifyAnonymous: identifyAnonymousCustomer
+	},
+	fulfillment: {
+		list: listFulfillment,
+		get: getFulfillment
+	},
+	menus: {
+		get: listMenus,
+		stream: listMenusStream
+	},
+	orders: {
+		list: listOrders,
+		post: createOrder,
+		get: getOrder,
+		patch: updateOrder,
+		cancel: cancelOrder,
+		refund: refundOrder,
+		reorder: reorderOrder,
+		validate: validateOrder,
+		place: placeOrder,
+		getFulfillment: getOrderFulfillment,
+		listFulfillments: listOrderFulfillments
+	},
+	payments: { list: listPayments },
+	stores: {
+		list: listStores,
+		nearby: listNearbyStores,
+		get: getStore
+	},
+	kiosk: {
+		getConfig: getKioskConfig,
+		heartbeat: postKioskHeartbeat,
+		postHealthSamples: postKioskHealthSamples,
+		patchOverrides: patchKioskOverrides,
+		realtimeToken: fetchKioskRealtimeToken,
+		unlink: unlinkKioskSelf,
+		verifyAdminCode: verifyKioskAdminCode,
+		isAdminCodeInvalid: isKioskAdminCodeInvalid,
+		isAdminCodeLocked: isKioskAdminCodeLocked,
+		isDeviceNotLinked,
+		isKioskUnauthorized
+	}
+};
+//#endregion
+//#region src/order/retry.ts
+const defaultSleep = (ms) => {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+};
+/** 1 attempt + `extraAttempts` retries with exponential backoff. */
+const withExponentialRetry = async (run, options = {}) => {
+	const extraAttempts = options.extraAttempts ?? 3;
+	const baseDelayMs = options.baseDelayMs ?? 100;
+	const sleep = options.sleep ?? defaultSleep;
+	let lastError;
+	for (let attempt = 0; attempt <= extraAttempts; attempt += 1) try {
+		return await run();
+	} catch (error) {
+		lastError = error;
+		if (attempt === extraAttempts) break;
+		await sleep(baseDelayMs * 2 ** attempt);
+	}
+	throw lastError;
+};
+//#endregion
+//#region src/order/flush.ts
+var OrderSyncPendingError = class extends Error {
+	constructor() {
+		super("Order changes are not synced yet");
+		this.name = "OrderSyncPendingError";
+	}
+};
+const createFlushController = (runtime) => {
+	let timer = null;
+	let inFlight = false;
+	let dirtyDuringFlight = false;
+	let current = null;
+	let pending = false;
+	const cancel = () => {
+		if (timer) clearTimeout(timer);
+		timer = null;
+		dirtyDuringFlight = false;
+		pending = false;
+	};
+	const patchBody = (order) => {
+		const b1 = {
+			store_id: order.store_id,
+			channel_id: order.channel_id
+		};
+		const b2 = { fulfillment_id: order.fulfillment_id };
+		const b3 = {
+			brand_id: order.brand_id,
+			lines: order.lines
+		};
+		const b4 = {
+			totals: order.totals,
+			metadata: order.metadata
+		};
+		const b5 = { customer: order.customer };
+		const b6 = { payment_intents: order.payment_intents };
+		const b7 = { payment_status: order.payment_status };
+		return {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5,
+			...b6,
+			...b7
+		};
+	};
+	const insertBody = (order) => {
+		const b1 = {
+			id: order.id,
+			store_id: order.store_id
+		};
+		const b2 = { channel_id: order.channel_id };
+		const b3 = { fulfillment_id: order.fulfillment_id };
+		const b4 = {
+			brand_id: order.brand_id,
+			is_anonymous: order.is_anonymous
+		};
+		const b5 = {
+			customer: order.customer,
+			lines: order.lines
+		};
+		const b6 = {
+			totals: order.totals,
+			metadata: order.metadata
+		};
+		const b7 = { payment_intents: order.payment_intents };
+		const b8 = { payment_status: order.payment_status };
+		return {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5,
+			...b6,
+			...b7,
+			...b8
+		};
+	};
+	const flushNow = () => {
+		if (runtime.isDeleted()) return Promise.resolve();
+		if (inFlight) return current ?? Promise.resolve();
+		current = run().finally(() => {
+			current = null;
+		});
+		return current;
+	};
+	const drain = async () => {
+		for (;;) {
+			if (runtime.isDeleted()) return;
+			if (current) {
+				await current;
+				continue;
+			}
+			if (!timer) return;
+			clearTimeout(timer);
+			timer = null;
+			await flushNow();
+		}
+	};
+	const settle = async () => {
+		await drain();
+		if (!pending || runtime.isDeleted()) return;
+		await flushNow();
+		await drain();
+		if (pending) throw new OrderSyncPendingError();
+	};
+	const resume = async () => {
+		if (!pending) return;
+		await flushNow();
+	};
+	const run = async () => {
+		const batchBase = structuredClone(runtime.getSynced());
+		const payload = structuredClone(runtime.getDraft());
+		const wasPersisted = runtime.isPersisted();
+		inFlight = true;
+		dirtyDuringFlight = false;
+		try {
+			const updated = await withExponentialRetry(() => {
+				if (!wasPersisted) return services.orders.post(insertBody(payload), runtime.http);
+				const p1 = [
+					payload.id,
+					patchBody(payload),
+					runtime.http
+				];
+				return services.orders.patch(...p1);
+			}, { sleep: runtime.sleep });
+			pending = false;
+			runtime.setPersisted(true);
+			runtime.setSynced(updated);
+			const reusedOpen = !wasPersisted && updated.id !== payload.id;
+			const keepLocal = payload.lines.length > 0 || runtime.fresh === true;
+			if (dirtyDuringFlight || reusedOpen && keepLocal) {
+				const d1 = {
+					...runtime.getDraft(),
+					uid: updated.uid
+				};
+				const d2 = {
+					id: updated.id,
+					customer_id: updated.customer_id
+				};
+				runtime.setDraft({
+					...d1,
+					...d2
+				});
+				inFlight = false;
+				runtime.notify();
+				schedule();
+				return;
+			}
+			runtime.setDraft(updated);
+			inFlight = false;
+			runtime.notify();
+		} catch (error) {
+			if (!(error instanceof StorefrontHttpError)) {
+				pending = true;
+				dirtyDuringFlight = false;
+				inFlight = false;
+				runtime.notify();
+				return;
+			}
+			pending = false;
+			runtime.setDraft(batchBase);
+			runtime.setSynced(batchBase);
+			runtime.setPersisted(wasPersisted);
+			dirtyDuringFlight = false;
+			inFlight = false;
+			if (timer) clearTimeout(timer);
+			timer = null;
+			runtime.notify();
+		}
+	};
+	const schedule = () => {
+		if (runtime.isDeleted()) return;
+		if (inFlight) {
+			dirtyDuringFlight = true;
+			return;
+		}
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = null;
+			flushNow();
+		}, runtime.debounceMs);
+	};
+	const markDirtyDuringFlight = () => {
+		if (inFlight) dirtyDuringFlight = true;
+	};
+	return {
+		schedule,
+		markDirtyDuringFlight,
+		cancel,
+		flushNow,
+		settle,
+		resume,
+		getInFlight: () => inFlight,
+		getPending: () => pending
+	};
+};
+//#endregion
+//#region src/order/lineFingerprint.ts
+/** Stable fingerprint for a bare (unconfigured) product. */
+const bareProductFingerprint = (productId) => {
+	return `${productId}[]`;
+};
+/**
+* Stable fingerprint for a root line + its modifier tree (not just product id).
+* Root quantity is excluded so the same customization can merge across qty.
+*/
+const computeLineFingerprint = (root, lines) => {
+	const childKeys = (parentUid) => {
+		const keys = lines.filter((line) => {
+			return line.parent_uid === parentUid;
+		}).map((line) => {
+			return `${line.id}x${line.quantity}(${childKeys(line.uid)})`;
+		});
+		keys.sort((left, right) => left.localeCompare(right));
+		return keys.join(",");
+	};
+	return `${root.id}[${childKeys(root.uid)}]`;
+};
+//#endregion
+//#region src/order/lines.ts
+const removeSubtree = (lines, rootUid) => {
+	const drop = /* @__PURE__ */ new Set([rootUid]);
+	let grew = true;
+	while (grew) {
+		grew = false;
+		for (const line of lines) if (line.parent_uid && drop.has(line.parent_uid) && !drop.has(line.uid)) {
+			drop.add(line.uid);
+			grew = true;
+		}
+	}
+	return lines.filter((line) => !drop.has(line.uid));
+};
+const scaleLineQuantity = (line, nextQty) => {
+	const qty = new Big(nextQty);
+	const subtotal = new Big(line.unit_subtotal).times(qty).toNumber();
+	const discount_total = new Big(line.unit_discount).times(qty).toNumber();
+	const tax_total = new Big(line.unit_tax_total).times(qty).toNumber();
+	const total = new Big(line.unit_total).times(qty).toNumber();
+	const gSub = new Big(line.unit_group_subtotal).times(qty).toNumber();
+	const gDisc = new Big(line.unit_group_discount).times(qty).toNumber();
+	const gTax = new Big(line.unit_group_tax_total).times(qty).toNumber();
+	const gTot = new Big(line.unit_group_total).times(qty).toNumber();
+	const b1 = {
+		...line,
+		quantity: nextQty,
+		subtotal,
+		discount_total
+	};
+	const b2 = {
+		tax_total,
+		total,
+		group_subtotal: gSub,
+		group_discount: gDisc
+	};
+	const b3 = {
+		group_tax_total: gTax,
+		group_total: gTot
+	};
+	return {
+		...b1,
+		...b2,
+		...b3
+	};
+};
+const collectDescendantUids = (lines, rootUid) => {
+	const uids = /* @__PURE__ */ new Set([rootUid]);
+	let grew = true;
+	while (grew) {
+		grew = false;
+		for (const line of lines) if (line.parent_uid && uids.has(line.parent_uid) && !uids.has(line.uid)) {
+			uids.add(line.uid);
+			grew = true;
+		}
+	}
+	return uids;
+};
+/** Partition a flat batch into root trees (root first, then descendants). */
+const partitionTrees = (batch) => {
+	const roots = batch.filter((line) => line.parent_uid == null);
+	const trees = [];
+	for (const root of roots) {
+		const uids = collectDescendantUids(batch, root.uid);
+		trees.push(batch.filter((line) => uids.has(line.uid)));
+	}
+	return trees;
+};
+const addLines = (lines, incoming) => {
+	const batch = Array.isArray(incoming) ? incoming : [incoming];
+	let next = lines;
+	for (const tree of partitionTrees(batch)) {
+		const root = tree.find((line) => line.parent_uid == null);
+		if (!root) continue;
+		const fingerprint = computeLineFingerprint(root, tree);
+		const existingRoot = next.find((line) => {
+			if (line.parent_uid != null) return false;
+			return computeLineFingerprint(line, next) === fingerprint;
+		});
+		if (existingRoot) {
+			const mergedQty = existingRoot.quantity + root.quantity;
+			next = next.map((line) => {
+				if (line.uid !== existingRoot.uid) return line;
+				return scaleLineQuantity(line, mergedQty);
+			});
+			continue;
+		}
+		next = [...next, ...tree];
+	}
+	return next;
+};
+const removeLine = (lines, lineUid) => {
+	return removeSubtree(lines, lineUid);
+};
+const subtractLine = (lines, lineUid, quantity = 1) => {
+	const target = lines.find((line) => line.uid === lineUid);
+	if (!target) return lines;
+	const nextQty = target.quantity - quantity;
+	if (nextQty <= 0) return removeSubtree(lines, lineUid);
+	return lines.map((line) => {
+		if (line.uid !== lineUid) return line;
+		return scaleLineQuantity(line, nextQty);
+	});
+};
+/** Drop a root subtree, then add the replacement tree (may merge by fingerprint). */
+const replaceLine = (lines, lineUid, next) => {
+	return addLines(removeSubtree(lines, lineUid), next);
+};
+const emptyLines = () => {
+	return [];
+};
+//#endregion
+//#region src/schedule/schedule.ts
+const DAY_OF_WEEK = [
+	"sunday",
+	"monday",
+	"tuesday",
+	"wednesday",
+	"thursday",
+	"friday",
+	"saturday"
+];
+const timeToMinutes = (time) => {
+	const [hours = "0", minutes = "0"] = time.split(":");
+	return Number(hours) * 60 + Number(minutes);
+};
+const hasSpecificDates = (period) => {
+	return period.start_date != null && period.end_date != null;
+};
+const periodCoversDate = (period, now) => {
+	if (!hasSpecificDates(period)) return false;
+	const nowMs = now.getTime();
+	const startMs = Date.parse(period.start_date);
+	const endMs = Date.parse(period.end_date);
+	if (Number.isNaN(startMs) || Number.isNaN(endMs)) return false;
+	return startMs <= nowMs && nowMs <= endMs;
+};
+const timeMatches = (period, now) => {
+	if (!period.start_time || !period.end_time) return false;
+	const nowMinutes = now.getHours() * 60 + now.getMinutes();
+	const start = timeToMinutes(period.start_time);
+	const end = timeToMinutes(period.end_time);
+	return nowMinutes >= start && nowMinutes < end;
+};
+const isClosedAt = (period, now) => {
+	if (!period.closed) return false;
+	if (!period.start_time || !period.end_time) return true;
+	return timeMatches(period, now);
+};
+const isOpenAt = (period, now) => {
+	if (period.closed) return false;
+	return timeMatches(period, now);
+};
+const isPeriodsActiveAt = (periods, now) => {
+	return getOpenPeriodAt(periods, now) != null;
+};
+const getOpenPeriodAt = (periods, now) => {
+	if (periods.length === 0) return null;
+	const coveringSpecific = periods.filter((period) => {
+		return periodCoversDate(period, now);
+	});
+	const fallback = periods.filter((period) => !hasSpecificDates(period));
+	const specificOpens = coveringSpecific.filter((period) => !period.closed);
+	if (coveringSpecific.filter((period) => period.closed).some((period) => isClosedAt(period, now))) return null;
+	if (specificOpens.length > 0) return specificOpens.find((period) => isOpenAt(period, now)) ?? null;
+	if (fallback.some((period) => isClosedAt(period, now))) return null;
+	return fallback.filter((period) => !period.closed).find((period) => isOpenAt(period, now)) ?? null;
+};
+const atTimeOnDate = (day, time) => {
+	const [hours = "0", minutes = "0"] = time.split(":");
+	const next = new Date(day);
+	next.setHours(Number(hours), Number(minutes), 0, 0);
+	return next;
+};
+const isWithinPeriodDates = (period, instantMs) => {
+	if (!hasSpecificDates(period)) return true;
+	const startMs = Date.parse(period.start_date);
+	const endMs = Date.parse(period.end_date);
+	if (Number.isNaN(startMs) || Number.isNaN(endMs)) return false;
+	return startMs <= instantMs && instantMs <= endMs;
+};
+const dayPeriods = (schedule, instant) => {
+	const day = DAY_OF_WEEK[instant.getDay()];
+	if (!day) return [];
+	return schedule.find((row) => row.day_of_week === day)?.periods ?? [];
+};
+const getActiveUntil = (periods, now) => {
+	const open = getOpenPeriodAt(periods, now);
+	if (!open?.end_time) return null;
+	let untilMs = atTimeOnDate(now, open.end_time).getTime();
+	const openIsSpecific = hasSpecificDates(open);
+	for (const period of periods) {
+		if (!period.closed || !period.start_time) continue;
+		const closeMs = atTimeOnDate(now, period.start_time).getTime();
+		if (closeMs <= now.getTime() || closeMs >= untilMs) continue;
+		if (!isWithinPeriodDates(period, closeMs)) continue;
+		if (!hasSpecificDates(period) && openIsSpecific) continue;
+		untilMs = closeMs;
+	}
+	return new Date(untilMs);
+};
+const getNextStart = (schedule, now) => {
+	const nowMs = now.getTime();
+	let nextStartMs = null;
+	const consider = (candidate, periods) => {
+		const startMs = candidate.getTime();
+		if (startMs <= nowMs) return;
+		if (!isPeriodsActiveAt(periods, candidate)) return;
+		if (nextStartMs === null || startMs < nextStartMs) nextStartMs = startMs;
+	};
+	for (let dayOffset = 0; dayOffset < 8; dayOffset += 1) {
+		const candidateDate = new Date(now);
+		candidateDate.setDate(candidateDate.getDate() + dayOffset);
+		candidateDate.setSeconds(0, 0);
+		const periods = dayPeriods(schedule, candidateDate);
+		if (periods.length === 0) continue;
+		for (const period of periods) {
+			if (period.closed || !period.start_time) continue;
+			const start = atTimeOnDate(candidateDate, period.start_time);
+			if (!isWithinPeriodDates(period, start.getTime())) continue;
+			consider(start, periods);
+		}
+		for (const period of periods) {
+			if (!period.closed || !period.end_time) continue;
+			const reopen = atTimeOnDate(candidateDate, period.end_time);
+			if (!isWithinPeriodDates(period, reopen.getTime())) continue;
+			consider(reopen, periods);
+		}
+	}
+	return nextStartMs === null ? null : new Date(nextStartMs);
+};
+/** Whether `schedule` is in hours now, and until / next open. */
+const getScheduleWindow = (schedule, now = /* @__PURE__ */ new Date()) => {
+	if (schedule == null) return {
+		active: true,
+		until: null
+	};
+	const periods = dayPeriods(schedule, now);
+	if (isPeriodsActiveAt(periods, now)) return {
+		active: true,
+		until: getActiveUntil(periods, now)
+	};
+	return {
+		active: false,
+		next: getNextStart(schedule, now)
+	};
+};
+const isOnSchedule = (schedule, now) => {
+	return getScheduleWindow(schedule, now).active;
+};
+//#endregion
+//#region src/order/recommendations.ts
+const DEFAULT_RECOMMENDATION_TYPES = ["CROSS_SELL"];
+const linkedRecommendationIds = (pricing) => {
+	return [...pricing.recommendations_ids ?? [], ...(pricing.recommendations ?? []).map((link) => link.recommendation_id)];
+};
+const collectRecommendations = (config) => {
+	const { lines, lookup, quantity, types } = config;
+	if (quantity <= 0) return [];
+	const typeSet = new Set(types ?? DEFAULT_RECOMMENDATION_TYPES);
+	const roots = lines.filter((line) => line.parent_uid == null);
+	const fingerprints = roots.map((root) => computeLineFingerprint(root, lines));
+	const cartKeys = new Set(fingerprints);
+	const seenTargetIds = /* @__PURE__ */ new Set();
+	const products = [];
+	for (const root of roots) {
+		const source = lookup.productsById[root.id];
+		if (!source) continue;
+		for (const recommendationId of linkedRecommendationIds(source.pricing)) {
+			const recommendation = lookup.recommendationsById[recommendationId];
+			if (!recommendation || !typeSet.has(recommendation.type)) continue;
+			const targetId = recommendation.target_product_id;
+			if (seenTargetIds.has(targetId)) continue;
+			if (cartKeys.has(bareProductFingerprint(targetId))) continue;
+			const target = lookup.productsById[targetId];
+			if (!target || target.status !== "ACTIVE") continue;
+			if (!isOnSchedule(target.availability.schedules)) continue;
+			seenTargetIds.add(targetId);
+			products.push(target);
+			if (products.length >= quantity) return products;
+		}
+	}
+	return products;
+};
+//#endregion
+//#region src/order/totals.ts
+/** Sum root line group totals into order totals (Big.js). */
+const recomputeTotals = (lines, currency = "USD") => {
+	let subtotal = new Big(0);
+	let discountTotal = new Big(0);
+	let taxTotal = new Big(0);
+	let total = new Big(0);
+	for (const line of lines) {
+		if (line.parent_uid != null) continue;
+		subtotal = subtotal.plus(line.group_subtotal);
+		discountTotal = discountTotal.plus(line.group_discount);
+		taxTotal = taxTotal.plus(line.group_tax_total);
+		total = total.plus(line.group_total);
+	}
+	let taxRate = 0;
+	let discountRate = 0;
+	if (subtotal.gt(0)) {
+		taxRate = taxTotal.div(subtotal).toNumber();
+		discountRate = discountTotal.div(subtotal).toNumber();
+	}
+	const discount_total = discountTotal.toNumber();
+	const tax_total = taxTotal.toNumber();
+	const b1 = {
+		currency,
+		subtotal: subtotal.toNumber()
+	};
+	const b2 = {
+		discount_rate: discountRate,
+		discount_total
+	};
+	const b3 = {
+		tax_rate: taxRate,
+		tax_total,
+		total: total.toNumber()
+	};
+	return {
+		...b1,
+		...b2,
+		...b3
+	};
+};
+const emptyTotals = (currency = "USD") => {
+	const b1 = {
+		currency,
+		subtotal: 0,
+		discount_rate: 0,
+		discount_total: 0
+	};
+	const b2 = {
+		tax_rate: 0,
+		tax_total: 0,
+		total: 0
+	};
+	return {
+		...b1,
+		...b2
+	};
+};
+//#endregion
+//#region src/order/Order.ts
+const cloneOrder = (order) => {
+	return structuredClone(order);
+};
+const buildHttpOptions = (options) => {
+	return {
+		baseUrl: options.baseUrl,
+		accessToken: options.accessToken,
+		fetchImpl: options.fetchImpl
+	};
+};
+/** Empty / whitespace brand_id → omit (API rejects `""`). */
+const optionalBrandId = (value) => {
+	if (value == null) return void 0;
+	const trimmed = value.trim();
+	if (!trimmed) return void 0;
+	return trimmed;
+};
+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 brand_id = optionalBrandId(options.scope.brand_id);
+	const customer = buildCustomerSnapshot(options.customer);
+	const is_anonymous = options.isAnonymous ?? false;
+	const b1 = {
+		id: orderId,
+		store_id: options.scope.store_id
+	};
+	const b2 = { channel_id: options.scope.channel_id };
+	const b3 = {
+		fulfillment_id: options.scope.fulfillment_id,
+		brand_id
+	};
+	const b4 = {
+		is_anonymous,
+		customer,
+		lines: [],
+		redeem: []
+	};
+	const b5 = {
+		totals: emptyTotals(),
+		metadata: {}
+	};
+	return {
+		...b1,
+		...b2,
+		...b3,
+		...b4,
+		...b5
+	};
+};
+const buildInsertFromSource = (options, source) => {
+	const orderId = options.orderId ?? `ord-${randomUUID().slice(0, 8)}`;
+	const store_id = options.scope?.store_id ?? source.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);
+	if (options.scope?.brand_id !== void 0) brand_id = optionalBrandId(options.scope.brand_id);
+	let customer = source.customer;
+	if (options.customer) customer = buildCustomerSnapshot(options.customer);
+	const lines = structuredClone(source.lines);
+	const is_anonymous = options.isAnonymous ?? source.is_anonymous;
+	const totals = recomputeTotals(lines, source.totals.currency);
+	const b1 = {
+		id: orderId,
+		store_id,
+		channel_id
+	};
+	const b2 = {
+		fulfillment_id,
+		brand_id,
+		is_anonymous
+	};
+	const redeem = source.redeem ?? [];
+	const b3 = {
+		customer,
+		lines,
+		totals,
+		metadata: {},
+		redeem
+	};
+	return {
+		...b1,
+		...b2,
+		...b3
+	};
+};
+const toRedeem = (items) => {
+	return (items ?? []).map((item) => ({
+		...item,
+		amount: item.amount ?? 1
+	}));
+};
+/** Local draft until the first mutating flush POSTs to the API. */
+const buildLocalDraft = (insert) => {
+	const lines = (insert.lines ?? []).map((line) => {
+		const patch = {
+			metadata: line.metadata ?? {},
+			bundled_items: line.bundled_items ?? [],
+			redeem: toRedeem(line.redeem)
+		};
+		return {
+			...line,
+			...patch
+		};
+	});
+	const brand_id = insert.brand_id ?? null;
+	const is_anonymous = insert.is_anonymous ?? false;
+	const totals = insert.totals ?? emptyTotals();
+	const metadata = insert.metadata ?? {};
+	const payment_intents = (insert.payment_intents ?? []).map((intent) => {
+		const metadata = intent.metadata ?? {};
+		return {
+			...intent,
+			metadata
+		};
+	});
+	const payment_status = insert.payment_status ?? "IDLE";
+	const b1 = {
+		uid: randomUUID(),
+		id: insert.id,
+		brand_id
+	};
+	const b2 = {
+		store_id: insert.store_id,
+		channel_id: insert.channel_id
+	};
+	const b3 = {
+		customer_id: "",
+		fulfillment_id: insert.fulfillment_id
+	};
+	const redeem = toRedeem(insert.redeem);
+	const b4 = {
+		is_anonymous,
+		lines,
+		customer: insert.customer,
+		redeem
+	};
+	const b5 = {
+		payment_intents,
+		totals,
+		metadata
+	};
+	const b6 = { payment_status };
+	const b7 = {
+		fulfillment_status: "IDLE",
+		status: "OPEN"
+	};
+	const b8 = {
+		issued_at: null,
+		resolved_at: null
+	};
+	const p12 = {
+		...b1,
+		...b2
+	};
+	const p34 = {
+		...b3,
+		...b4
+	};
+	const p56 = {
+		...b5,
+		...b6
+	};
+	const p78 = {
+		...b7,
+		...b8
+	};
+	const p1234 = {
+		...p12,
+		...p34
+	};
+	const p5678 = {
+		...p56,
+		...p78
+	};
+	return {
+		...p1234,
+		...p5678
+	};
+};
+const sameBrand = (left, right) => {
+	return (optionalBrandId(left) ?? null) === (optionalBrandId(right) ?? null);
+};
+/** Newest OPEN order for customer + scope, if any. */
+const findOpenOrder = async (scope, http) => {
+	const brandId = optionalBrandId(scope.brand_id);
+	return (await services.orders.list({
+		store_id: scope.store_id,
+		channel_id: scope.channel_id,
+		fulfillment_id: scope.fulfillment_id,
+		...brandId ? { brand_id: brandId } : {},
+		status: "OPEN",
+		limit: 20
+	}, http)).find((order) => sameBrand(order.brand_id, brandId)) ?? null;
+};
+var Order = class Order {
+	draft;
+	synced;
+	deleted = false;
+	persisted;
+	listeners = /* @__PURE__ */ new Set();
+	externalNotify;
+	http;
+	flush;
+	constructor(config, notify) {
+		this.draft = cloneOrder(config.order);
+		this.synced = cloneOrder(config.order);
+		this.persisted = config.persisted;
+		this.http = config.http;
+		this.externalNotify = notify;
+		this.flush = createFlushController({
+			getDraft: () => this.draft,
+			setDraft: (next) => {
+				this.draft = next;
+			},
+			getSynced: () => this.synced,
+			setSynced: (next) => {
+				this.synced = next;
+			},
+			isDeleted: () => this.deleted,
+			isPersisted: () => this.persisted,
+			setPersisted: (next) => {
+				this.persisted = next;
+			},
+			notify: () => this.notify(),
+			http: this.http,
+			debounceMs: config.debounceMs,
+			fresh: config.fresh ?? false,
+			sleep: config.sleep
+		});
+	}
+	/**
+	* Opens a cart session: reuses an existing OPEN order for the scope, or a
+	* local draft. Does not POST until `persist()` or the first mutating flush.
+	*/
+	static async open(options, notify) {
+		const http = buildHttpOptions(options);
+		const debounceMs = options.debounceMs ?? 300;
+		let body;
+		let scope;
+		if (options.fromOrderId) {
+			const source = await services.orders.get(options.fromOrderId, http);
+			body = buildInsertFromSource(options, source);
+			scope = {
+				store_id: body.store_id,
+				channel_id: body.channel_id,
+				fulfillment_id: body.fulfillment_id,
+				brand_id: optionalBrandId(body.brand_id)
+			};
+		} else {
+			body = buildInsertFromOptions(options);
+			scope = {
+				store_id: options.scope.store_id,
+				channel_id: options.scope.channel_id,
+				fulfillment_id: options.scope.fulfillment_id,
+				brand_id: optionalBrandId(options.scope.brand_id)
+			};
+		}
+		const reuse = options.reuseOpen ?? true;
+		const existing = reuse ? await findOpenOrder(scope, http) : null;
+		if (existing) return new Order({
+			order: existing,
+			http,
+			debounceMs,
+			persisted: true
+		}, notify);
+		return new Order({
+			order: buildLocalDraft(body),
+			http,
+			debounceMs,
+			persisted: false,
+			fresh: !reuse
+		}, notify);
+	}
+	static async reorder(orderId, options = {}, notify) {
+		const http = buildHttpOptions(options);
+		const debounceMs = options.debounceMs ?? 300;
+		const strategy = options.strategy ?? "replace";
+		const dto = await services.orders.reorder(orderId, { strategy }, http);
+		return new Order({
+			order: dto,
+			http,
+			debounceMs,
+			persisted: true
+		}, notify);
+	}
+	/** Opens a session and POSTs immediately if no OPEN order exists yet. */
+	static async create(options, notify) {
+		const order = await Order.open(options, notify);
+		if (!order.isPersisted()) await order.persist();
+		return order;
+	}
+	/** @internal test hook — create without POST */
+	static fromExisting(config, notify) {
+		return new Order({
+			order: config.order,
+			http: config.http,
+			debounceMs: config.debounceMs ?? 300,
+			persisted: config.persisted ?? true,
+			sleep: config.sleep
+		}, notify);
+	}
+	/** Whether this session has a server row yet. */
+	isPersisted() {
+		return this.persisted;
+	}
+	/** Persist a local draft via POST (no-op if already on the server). */
+	async persist() {
+		if (this.deleted || this.persisted) return;
+		await this.flush.flushNow();
+	}
+	/** Whether local edits failed to reach the server (e.g. offline). */
+	hasPendingSync() {
+		return this.flush.getPending();
+	}
+	/** Retries pending edits; call when connectivity returns. */
+	resume() {
+		return this.flush.resume();
+	}
+	/** Abandons the session locally: pending edits are dropped, no request. */
+	dispose() {
+		this.flush.cancel();
+		this.deleted = true;
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	getOrder() {
+		return cloneOrder(this.draft);
+	}
+	/**
+	* Upsell / cross-sell / down-sell products for items currently in the cart.
+	* Skips targets whose base (unconfigured) customization is already in the cart —
+	* same product id with a different modifier tree is still allowed.
+	*/
+	getRecommendations(lookup, quantity, types = DEFAULT_RECOMMENDATION_TYPES) {
+		if (!lookup) return [];
+		return collectRecommendations({
+			lines: this.draft.lines,
+			lookup,
+			quantity,
+			types
+		});
+	}
+	/**
+	* Rebuild a customization {@link Snapshot} for a root cart line so callers
+	* can reopen it with `createSession(lookup, snapshot.productId, { snapshot })`.
+	*/
+	getCustomizationSnapshot(rootLineUid, lookup) {
+		const root = this.draft.lines.find((line) => line.uid === rootLineUid);
+		if (!root || root.parent_uid != null) return null;
+		return fromOrderLines(root, this.draft.lines, lookup);
+	}
+	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();
+	}
+	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();
+	}
+	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();
+	}
+	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();
+	}
+	emptyOrder() {
+		if (this.deleted) return;
+		const nextLines = emptyLines();
+		this.draft = {
+			...this.draft,
+			lines: nextLines,
+			redeem: [],
+			totals: recomputeTotals(nextLines, this.draft.totals.currency)
+		};
+		this.scheduleAfterMutate();
+	}
+	setScope(scope) {
+		if (this.deleted) return;
+		this.draft = {
+			...this.draft,
+			store_id: scope.store_id ?? this.draft.store_id,
+			channel_id: scope.channel_id ?? this.draft.channel_id,
+			fulfillment_id: scope.fulfillment_id ?? this.draft.fulfillment_id,
+			brand_id: scope.brand_id === void 0 ? this.draft.brand_id : optionalBrandId(scope.brand_id)
+		};
+		this.scheduleAfterMutate();
+	}
+	/** Shallow-merges into order metadata; `null` values are kept as-is. */
+	setMetadata(patch) {
+		if (this.deleted) return;
+		const metadata = {
+			...this.draft.metadata ?? {},
+			...patch
+		};
+		this.draft = {
+			...this.draft,
+			metadata
+		};
+		this.scheduleAfterMutate();
+	}
+	setCustomerDetails(details) {
+		if (this.deleted) return;
+		const hasAddressInfo = details.address_info !== void 0;
+		const hasBillingInfo = details.billing_info !== void 0;
+		const address_info = !hasAddressInfo ? this.draft.customer.address_info : details.address_info;
+		const billing_info = !hasBillingInfo ? this.draft.customer.billing_info : details.billing_info;
+		const customer = {
+			...this.draft.customer,
+			address_info,
+			billing_info
+		};
+		this.draft = {
+			...this.draft,
+			customer
+		};
+		this.scheduleAfterMutate();
+	}
+	async cancelOrder() {
+		if (this.deleted) return;
+		this.flush.cancel();
+		if (this.persisted) {
+			const next = await services.orders.cancel(this.draft.id, this.http);
+			this.draft = cloneOrder(next);
+			this.synced = cloneOrder(next);
+		} else {
+			let payment_status = "CANCELLED";
+			if (this.draft.payment_status === "PAID") payment_status = "PAID";
+			if (this.draft.payment_status === "REFUNDED") payment_status = "REFUNDED";
+			const resolved_at = (/* @__PURE__ */ new Date()).toISOString();
+			let status = "VOIDED";
+			if (this.draft.payment_status === "PAID") status = "REVERSED";
+			const d1 = { status };
+			const d2 = { fulfillment_status: status };
+			const next = {
+				...this.draft,
+				...d1,
+				...d2,
+				payment_status,
+				resolved_at
+			};
+			this.draft = next;
+			this.synced = cloneOrder(next);
+		}
+		this.deleted = true;
+		this.notify();
+	}
+	async refundOrder() {
+		if (this.deleted) return;
+		this.flush.cancel();
+		if (!this.persisted) return;
+		const next = await services.orders.refund(this.draft.id, this.http);
+		this.draft = cloneOrder(next);
+		this.synced = cloneOrder(next);
+		this.deleted = true;
+		this.notify();
+	}
+	async validateOrder() {
+		const draft = this.getOrder();
+		const b1 = {
+			store_id: draft.store_id,
+			channel_id: draft.channel_id
+		};
+		const b2 = { fulfillment_id: draft.fulfillment_id };
+		const b3 = {
+			brand_id: draft.brand_id,
+			is_anonymous: draft.is_anonymous
+		};
+		const b4 = {
+			lines: draft.lines,
+			redeem: draft.redeem ?? []
+		};
+		const b5 = { totals: draft.totals };
+		const body = {
+			...b1,
+			...b2,
+			...b3,
+			...b4,
+			...b5
+		};
+		await services.orders.validate(body, this.http);
+	}
+	async placeOrder(input = {}) {
+		await this.persist();
+		await this.flush.settle();
+		await this.validateOrder();
+		try {
+			await services.orders.place(this.draft.id, input, this.http);
+		} catch (error) {
+			if (!(error instanceof StorefrontHttpError) || error.status !== 409) throw error;
+		}
+		const next = await services.orders.get(this.draft.id, this.http);
+		this.draft = cloneOrder(next);
+		this.synced = cloneOrder(next);
+		this.notify();
+	}
+	scheduleAfterMutate() {
+		this.flush.markDirtyDuringFlight();
+		this.notify();
+		this.flush.schedule();
+	}
+	notify() {
+		this.externalNotify?.();
+		this.listeners.forEach((listener) => listener());
+	}
+};
+//#endregion
+//#region src/order/fulfillmentTrack.ts
+const isPrimaryPathKind = (pathKind) => {
+	return pathKind === "default" || pathKind === "success" || pathKind == null;
+};
+const pathKindForTarget = (target) => {
+	if (!target || target.data.kind !== "terminal") return "default";
+	const status = target.data.mappedStatus;
+	if (status === "VOIDED") return "cancel";
+	if (status === "REVERSED") return "refund";
+	if (status === "REFUNDED" || status === "RETURNED") return "refund";
+	return "success";
+};
+const pickLabel = (label, fallback) => {
+	if (typeof label === "string") return label.trim() || fallback;
+	if (!label) return fallback;
+	const en = label.en_us?.trim() || label.en?.trim();
+	if (en) return en;
+	for (const value of Object.values(label)) {
+		const trimmed = value.trim();
+		if (trimmed) return trimmed;
+	}
+	return fallback;
+};
+const durationMs = (entered_at, exited_at) => {
+	if (!exited_at) return null;
+	const start = Date.parse(entered_at);
+	const end = Date.parse(exited_at);
+	if (Number.isNaN(start) || Number.isNaN(end)) return null;
+	return Math.max(0, end - start);
+};
+const currentNodes = (workflow, currentNodeIds) => {
+	if (currentNodeIds.length === 0) return [];
+	const current = new Set(currentNodeIds);
+	return workflow.nodes.filter((node) => current.has(node.id));
+};
+const visitedStates = (workflow) => {
+	return workflow.nodes.filter((node) => node.data.entered_at).toSorted((a, b) => {
+		const left = a.data.entered_at ?? "";
+		const right = b.data.entered_at ?? "";
+		return left.localeCompare(right);
+	}).map((node) => {
+		const entered_at = node.data.entered_at ?? "";
+		const exited_at = node.data.exited_at;
+		const b1 = {
+			id: node.id,
+			label: node.data.label
+		};
+		const b2 = {
+			mappedStatus: node.data.mappedStatus,
+			entered_at
+		};
+		const b3 = {
+			exited_at,
+			durationMs: durationMs(entered_at, exited_at)
+		};
+		return {
+			...b1,
+			...b2,
+			...b3
+		};
+	});
+};
+/** Walk primary-path milestones; one meta entry per order index (deduped). */
+const walkPrimaryMilestones = (workflow) => {
+	const nodesById = new Map(workflow.nodes.map((node) => [node.id, node]));
+	const primaryIn = /* @__PURE__ */ new Map();
+	const primaryOut = /* @__PURE__ */ new Map();
+	for (const node of workflow.nodes) {
+		primaryIn.set(node.id, []);
+		primaryOut.set(node.id, []);
+	}
+	for (const edge of workflow.edges) {
+		if (!nodesById.has(edge.source) || !nodesById.has(edge.target)) continue;
+		const target = nodesById.get(edge.target);
+		const pathKind = edge.data?.pathKind ?? pathKindForTarget(target);
+		if (!isPrimaryPathKind(pathKind)) continue;
+		primaryOut.get(edge.source)?.push(edge.target);
+		primaryIn.get(edge.target)?.push(edge.source);
+	}
+	const orders = /* @__PURE__ */ new Map();
+	const carryById = /* @__PURE__ */ new Map();
+	const metaByOrder = /* @__PURE__ */ new Map();
+	const parentsReady = (id) => {
+		return (primaryIn.get(id) ?? []).every((parentId) => carryById.has(parentId));
+	};
+	const queue = workflow.nodes.filter((node) => {
+		return (primaryIn.get(node.id) ?? []).length === 0;
+	}).map((node) => node.id);
+	const queued = new Set(queue);
+	while (queue.length > 0) {
+		const id = queue.shift();
+		queued.delete(id);
+		if (carryById.has(id)) continue;
+		const parentCarries = (primaryIn.get(id) ?? []).map((parentId) => {
+			return carryById.get(parentId) ?? 0;
+		});
+		let parentCarry = 0;
+		if (parentCarries.length > 0) parentCarry = Math.max(...parentCarries);
+		const node = nodesById.get(id);
+		const milestone = node?.data.milestone?.trim();
+		let carry = parentCarry;
+		if (milestone) {
+			const order = parentCarry + 1;
+			orders.set(id, order);
+			carry = order;
+			const fallback = milestone.replaceAll("_", " ");
+			const meta = {
+				id,
+				milestone,
+				label: pickLabel(node?.data.label, fallback)
+			};
+			metaByOrder.set(order, meta);
+		}
+		carryById.set(id, carry);
+		for (const child of primaryOut.get(id) ?? []) {
+			if (carryById.has(child) || queued.has(child)) continue;
+			if (!parentsReady(child)) continue;
+			queue.push(child);
+			queued.add(child);
+		}
+	}
+	let total = 0;
+	for (const order of orders.values()) if (order > total) total = order;
+	if (total === 0) return null;
+	return {
+		orders,
+		carryById,
+		metaByOrder,
+		total
+	};
+};
+const resolveCurrentMilestoneOrder = (workflow, currentNodeIds, walk) => {
+	const { orders, carryById } = walk;
+	let current = 0;
+	for (const id of currentNodeIds) {
+		const carry = carryById.get(id) ?? 0;
+		if (carry > current) current = carry;
+	}
+	if (current === 0) for (const node of workflow.nodes) {
+		if (!node.data.milestone?.trim()) continue;
+		if (!node.data.entered_at) continue;
+		const order = orders.get(node.id) ?? 0;
+		if (order > current) current = order;
+	}
+	return current;
+};
+const completedByOrder = (workflow, walk) => {
+	const result = /* @__PURE__ */ new Map();
+	for (const node of workflow.nodes) {
+		const order = walk.orders.get(node.id);
+		if (order == null) continue;
+		if (!node.data.entered_at) continue;
+		result.set(order, true);
+	}
+	return result;
+};
+const stepsFromWalk = (workflow, walk) => {
+	const completed = completedByOrder(workflow, walk);
+	const steps = [];
+	for (let order = 1; order <= walk.total; order++) {
+		const meta = walk.metaByOrder.get(order);
+		if (!meta) continue;
+		const b1 = {
+			id: meta.id,
+			milestone: meta.milestone,
+			order
+		};
+		const b2 = {
+			completed: completed.get(order) === true,
+			label: meta.label
+		};
+		steps.push({
+			...b1,
+			...b2
+		});
+	}
+	return steps;
+};
+/** Last milestone is done once current has reached the end (e.g. Fulfilled). */
+const isMilestoneStepDone = (order, current, total) => {
+	if (order < current) return true;
+	return current >= total && order === current;
+};
+/** Deduped primary-path milestones (one per order index). */
+const milestoneTrack = (workflow) => {
+	const walk = walkPrimaryMilestones(workflow);
+	if (!walk) return [];
+	return stepsFromWalk(workflow, walk);
+};
+/** Ordered milestones + current index from `current_node_ids` (dashboard algo). */
+const milestoneSteps = (workflow, currentNodeIds) => {
+	const walk = walkPrimaryMilestones(workflow);
+	if (!walk) return null;
+	const current = resolveCurrentMilestoneOrder(workflow, currentNodeIds, walk);
+	if (current === 0) return null;
+	const steps = stepsFromWalk(workflow, walk);
+	if (steps.length === 0) return null;
+	return {
+		steps,
+		current,
+		total: walk.total
+	};
+};
+//#endregion
+//#region src/order/validate.ts
+const PRICE_FIELDS = [
+	"unit_subtotal",
+	"subtotal",
+	"unit_total",
+	"total",
+	"unit_group_subtotal",
+	"group_subtotal",
+	"unit_group_total",
+	"group_total"
+];
+const TAX_FIELDS = [
+	"unit_tax_total",
+	"tax_total",
+	"unit_group_tax_total",
+	"group_tax_total"
+];
+const DISCOUNT_FIELDS = [
+	"discount_rate",
+	"unit_discount",
+	"discount_total",
+	"unit_group_discount",
+	"group_discount"
+];
+const TOTALS_FIELDS = [
+	"subtotal",
+	"discount_total",
+	"tax_total",
+	"total",
+	"discount_rate",
+	"tax_rate"
+];
+const MONEY_SELF_CHECKS = [
+	["unit_subtotal", "subtotal"],
+	["unit_discount", "discount_total"],
+	["unit_tax_total", "tax_total"],
+	["unit_total", "total"]
+];
+const pushLineIssue = (lines, uid, issue) => {
+	const list = lines[uid] ?? [];
+	list.push(issue);
+	lines[uid] = list;
+};
+const bigEq = (a, b) => {
+	return new Big(a).eq(new Big(b));
+};
+const bigStr = (n) => {
+	return new Big(n).toString();
+};
+const rateEq = (a, b) => {
+	if (a == null && b == null) return true;
+	if (a == null || b == null) return false;
+	return bigEq(a, b);
+};
+const rateStr = (n) => {
+	if (n == null) return "null";
+	return bigStr(n);
+};
+const childrenOf = (lines, parentUid) => {
+	const children = lines.filter((line) => {
+		return line.parent_uid === 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)) {
+			pushLineIssue(out, child.uid, { code: "MODIFIER_NOT_FOUND" });
+			continue;
+		}
+		collectUnmatchedModifiers(lines, lookup, child.id, child.uid, out);
+	}
+};
+const checkFeeSelfConsistency = (line, out) => {
+	const qty = new Big(line.quantity);
+	for (const [unitField, totalField] of MONEY_SELF_CHECKS) {
+		const expected = new Big(line[unitField]).times(qty);
+		const actual = new Big(line[totalField]);
+		if (expected.eq(actual)) continue;
+		pushLineIssue(out, line.uid, {
+			code: "QUANTITY_MISMATCH",
+			field: totalField,
+			expected: expected.toString(),
+			actual: actual.toString()
+		});
+	}
+};
+const feeMoneyEq = (actual, expected) => {
+	if (!bigEq(actual.unit_subtotal, expected.unit_subtotal)) return false;
+	if (!bigEq(actual.unit_tax_total, expected.unit_tax_total)) return false;
+	if (!bigEq(actual.unit_total, expected.unit_total)) return false;
+	return rateEq(actual.tax_rate, expected.tax_rate);
+};
+const compareExpectedFeeLines = (submitted, expected, out) => {
+	const expectedById = new Map(expected.map((line) => [line.id, line]));
+	const seen = /* @__PURE__ */ new Set();
+	for (const line of submitted) {
+		if (line.type !== "FEE") continue;
+		if (seen.has(line.id)) {
+			pushLineIssue(out, line.uid, {
+				code: "FEE_MISMATCH",
+				field: "id"
+			});
+			continue;
+		}
+		seen.add(line.id);
+		const exp = expectedById.get(line.id);
+		if (!exp) {
+			pushLineIssue(out, line.uid, {
+				code: "FEE_MISMATCH",
+				field: "id"
+			});
+			continue;
+		}
+		if (feeMoneyEq(line, exp)) continue;
+		const b1 = {
+			code: "FEE_MISMATCH",
+			field: "total"
+		};
+		const b2 = {
+			expected: bigStr(exp.total),
+			actual: bigStr(line.total)
+		};
+		pushLineIssue(out, line.uid, {
+			...b1,
+			...b2
+		});
+	}
+	for (const exp of expected) {
+		if (seen.has(exp.id)) continue;
+		const b1 = {
+			code: "FEE_MISMATCH",
+			field: "total"
+		};
+		const b2 = {
+			expected: bigStr(exp.total),
+			actual: "0"
+		};
+		pushLineIssue(out, exp.uid, {
+			...b1,
+			...b2
+		});
+	}
+};
+const compareMoneyFields = (actual, expected, out) => {
+	for (const field of PRICE_FIELDS) {
+		if (bigEq(actual[field], expected[field])) continue;
+		pushLineIssue(out, actual.uid, {
+			code: "PRICE_MISMATCH",
+			field,
+			expected: bigStr(expected[field]),
+			actual: bigStr(actual[field])
+		});
+	}
+	for (const field of TAX_FIELDS) {
+		if (bigEq(actual[field], expected[field])) continue;
+		pushLineIssue(out, actual.uid, {
+			code: "TAX_MISMATCH",
+			field,
+			expected: bigStr(expected[field]),
+			actual: bigStr(actual[field])
+		});
+	}
+	if (!rateEq(actual.tax_rate, expected.tax_rate)) {
+		const b1 = {
+			code: "TAX_MISMATCH",
+			field: "tax_rate"
+		};
+		const b2 = { expected: rateStr(expected.tax_rate) };
+		const b3 = { actual: rateStr(actual.tax_rate) };
+		const p12 = {
+			...b1,
+			...b2
+		};
+		pushLineIssue(out, actual.uid, {
+			...p12,
+			...b3
+		});
+	}
+	for (const field of DISCOUNT_FIELDS) {
+		if (bigEq(actual[field], expected[field])) continue;
+		pushLineIssue(out, actual.uid, {
+			code: "DISCOUNT_MISMATCH",
+			field,
+			expected: bigStr(expected[field]),
+			actual: bigStr(actual[field])
+		});
+	}
+};
+const compareTrees = (actualLines, expectedLines, actualUid, expectedUid, out) => {
+	const actual = actualLines.find((line) => line.uid === actualUid);
+	const expected = expectedLines.find((line) => line.uid === expectedUid);
+	if (!actual || !expected) {
+		if (actual) pushLineIssue(out, actual.uid, { code: "STRUCTURE_MISMATCH" });
+		return;
+	}
+	if (actual.id !== expected.id) {
+		pushLineIssue(out, actual.uid, {
+			code: "STRUCTURE_MISMATCH",
+			field: "id",
+			expected: expected.id,
+			actual: actual.id
+		});
+		return;
+	}
+	if (actual.quantity !== expected.quantity) pushLineIssue(out, actual.uid, {
+		code: "QUANTITY_MISMATCH",
+		field: "quantity",
+		expected: String(expected.quantity),
+		actual: String(actual.quantity)
+	});
+	compareMoneyFields(actual, expected, out);
+	const actualChildren = childrenOf(actualLines, actual.uid);
+	const expectedChildren = childrenOf(expectedLines, expected.uid);
+	if (actualChildren.length !== expectedChildren.length) pushLineIssue(out, actual.uid, {
+		code: "STRUCTURE_MISMATCH",
+		field: "children",
+		expected: String(expectedChildren.length),
+		actual: String(actualChildren.length)
+	});
+	const len = Math.min(actualChildren.length, expectedChildren.length);
+	for (let i = 0; i < len; i++) compareTrees(actualLines, expectedLines, actualChildren[i].uid, expectedChildren[i].uid, out);
+};
+const checkRootProductQuantities = (roots, lookup, out) => {
+	const qtyByProductId = {};
+	for (const root of roots) {
+		if (root.type === "FEE") continue;
+		const current = qtyByProductId[root.id];
+		if (current) {
+			current.sum += root.quantity;
+			current.uids.push(root.uid);
+			continue;
+		}
+		qtyByProductId[root.id] = {
+			sum: root.quantity,
+			uids: [root.uid]
+		};
+	}
+	for (const productId of Object.keys(qtyByProductId)) {
+		const product = lookup.productsById[productId];
+		const agg = qtyByProductId[productId];
+		if (!product || !agg) continue;
+		const min = product.pricing.minimum_quantity;
+		const max = product.pricing.maximum_quantity;
+		const { sum, uids } = agg;
+		if (sum > max) {
+			const b1 = { code: "QUANTITY_ABOVE_MAXIMUM" };
+			const b2 = {
+				field: "quantity",
+				expected: String(max)
+			};
+			const issue = {
+				...b1,
+				...b2,
+				actual: String(sum)
+			};
+			for (const uid of uids) pushLineIssue(out, uid, issue);
+		}
+		if (sum < min) {
+			const b1 = { code: "QUANTITY_BELOW_MINIMUM" };
+			const b2 = {
+				field: "quantity",
+				expected: String(min)
+			};
+			const issue = {
+				...b1,
+				...b2,
+				actual: String(sum)
+			};
+			for (const uid of uids) pushLineIssue(out, uid, issue);
+		}
+	}
+};
+const validateProductRoot = (root, lines, lookup, locale, out) => {
+	const product = lookup.productsById[root.id];
+	if (!product) {
+		pushLineIssue(out, root.uid, { code: "PRODUCT_NOT_FOUND" });
+		return;
+	}
+	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" });
+	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);
+	const expectedRoot = expected.find((line) => line.parent_uid == null);
+	if (!expectedRoot) {
+		pushLineIssue(out, root.uid, { code: "STRUCTURE_MISMATCH" });
+		return;
+	}
+	compareTrees(lines, expected, root.uid, expectedRoot.uid, out);
+};
+/** Compare cart lines/totals against a fresh menu (exact Big.js equality). */
+const validateOrderAgainstMenu = (input) => {
+	const locale = input.locale ?? "en_us";
+	const issues = [];
+	const lineIssues = {};
+	if (!input.menu) return {
+		ok: false,
+		issues: [{ code: "NO_MENU" }],
+		lines: {}
+	};
+	if (!input.menuActive) issues.push({ code: "MENU_CLOSED" });
+	const roots = input.lines.filter((line) => line.parent_uid == null);
+	if (roots.length === 0) {
+		issues.push({ code: "EMPTY_ORDER" });
+		return {
+			ok: false,
+			issues,
+			lines: lineIssues
+		};
+	}
+	const lookup = indexMenu(input.menu);
+	for (const root of roots) {
+		if (root.type === "FEE") {
+			checkFeeSelfConsistency(root, lineIssues);
+			continue;
+		}
+		validateProductRoot(root, input.lines, lookup, locale, lineIssues);
+	}
+	checkRootProductQuantities(roots, lookup, lineIssues);
+	if (input.expectedFeeLines) compareExpectedFeeLines(input.lines, input.expectedFeeLines, lineIssues);
+	const expectedTotals = recomputeTotals(input.lines, input.totals.currency);
+	for (const field of TOTALS_FIELDS) {
+		if (bigEq(input.totals[field], expectedTotals[field])) continue;
+		issues.push({
+			code: "TOTALS_MISMATCH",
+			field,
+			expected: bigStr(expectedTotals[field]),
+			actual: bigStr(input.totals[field])
+		});
+	}
+	const hasLineIssues = Object.keys(lineIssues).length > 0;
+	if (issues.length === 0 && !hasLineIssues) return { ok: true };
+	return {
+		ok: false,
+		issues,
+		lines: lineIssues
+	};
+};
+const descendantUids = (lines, rootUid) => {
+	const uids = /* @__PURE__ */ new Set([rootUid]);
+	let grew = true;
+	while (grew) {
+		grew = false;
+		for (const line of lines) {
+			if (!line.parent_uid) continue;
+			if (!uids.has(line.parent_uid) || uids.has(line.uid)) continue;
+			uids.add(line.uid);
+			grew = true;
+		}
+	}
+	return uids;
+};
+const issuesForTree = (lines, rootUid, lineIssues) => {
+	const uids = descendantUids(lines, rootUid);
+	const issues = [];
+	for (const uid of uids) {
+		const list = lineIssues[uid];
+		if (list) issues.push(...list);
+	}
+	return issues;
+};
+const collectOrderLineDiffs = (input) => {
+	const locale = input.locale ?? "en_us";
+	const roots = input.lines.filter((line) => {
+		return line.parent_uid == null && line.type === "PRODUCT";
+	});
+	const lookup = input.menu ? indexMenu(input.menu) : null;
+	const diffs = [];
+	for (const root of roots) {
+		const issues = issuesForTree(input.lines, root.uid, input.lineIssues);
+		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 product = lookup?.productsById[root.id];
+		if (missing || !product || !lookup) {
+			diffs.push({
+				uid: root.uid,
+				previous,
+				next: null,
+				issues
+			});
+			continue;
+		}
+		try {
+			const snapshot = fromOrderLines(root, input.lines, lookup);
+			const next = toOrderLines(createSession(lookup, root.id, { snapshot }).root, locale);
+			diffs.push({
+				uid: root.uid,
+				previous,
+				next,
+				issues
+			});
+		} catch {
+			diffs.push({
+				uid: root.uid,
+				previous,
+				next: null,
+				issues
+			});
+		}
+	}
+	return diffs;
+};
+//#endregion
+//#region src/rules/assert.ts
+const assert = (value, message) => {
+	if (value) return;
+	throw new Error(message);
+};
+//#endregion
+//#region src/rules/common.ts
+const primitiveError = (primitive) => {
+	return `Condition primitive must be ${primitive}`;
+};
+const typeError = (type) => {
+	return `Condition type must be ${type}`;
+};
+const defaultConditionError = "Condition was not met";
+const getLineByProductId = (lines, productId) => {
+	if (!productId) return void 0;
+	return lines?.find((line) => line.id === productId);
+};
+const countCartProducts = (lines, includeModifiers) => {
+	if (!lines?.length) return 0;
+	return lines.filter((line) => {
+		if (line.type === "FEE") return false;
+		if (includeModifiers) return true;
+		if (!(line.parent_uid == null)) return false;
+		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/booleanMatcher.ts
+const matchBooleanOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "boolean", primitiveError("boolean"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "boolean", "Invalid boolean value");
+	switch (operator) {
+		case "is": return matcher === value;
+		case "is not": return matcher !== value;
+		default: throw new Error(`Operator ${operator} not supported in boolean matcher`);
+	}
+};
+const isAnonymousCustomer = (condition, isAnonymous) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Customer is anonymous";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, isAnonymous ?? false);
+};
+const orderIncludesProductWithTag$3 = (condition, matcher) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product with tag";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, matcher);
+};
+const isAnonymousOrder = (condition, isAnonymous) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Is anonymous order";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, isAnonymous ?? false);
+};
+//#endregion
+//#region src/rules/currencyMatcher.ts
+const matchCurrencyOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "currency", primitiveError("currency"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "number", "Invalid currency value");
+	switch (operator) {
+		case "equal to": return matcher === value;
+		case "not equal to": return matcher !== value;
+		case "greater than": return matcher > value;
+		case "greater than or equal to": return matcher >= value;
+		case "less than": return matcher < value;
+		case "less than or equal to": return matcher <= value;
+		default: throw new Error(`Operator ${operator} not supported in currency matcher`);
+	}
+};
+const orderIncludesProductWithTag$2 = (condition, matcher) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product with tag";
+	assert(primitive === "currency", primitiveError("currency"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchCurrencyOperator(condition, matcher);
+};
+const orderTotal = (condition, total) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order total";
+	assert(primitive === "currency", primitiveError("currency"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchCurrencyOperator(condition, total);
+};
+//#endregion
+//#region src/rules/customMatcher.ts
+const MULTI_CUSTOM_TYPES = [
+	"Fulfillments",
+	"Stores",
+	"Channels",
+	"Brands"
+];
+const isMultiCustomType = (type) => {
+	return MULTI_CUSTOM_TYPES.includes(type);
+};
+const splitCsv = (value) => {
+	return value.split(",").map((part) => part.trim()).filter(Boolean);
+};
+const matchCustomEquality = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "custom", primitiveError("custom"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "string", "Invalid custom value");
+	switch (operator) {
+		case "is": return matcher === value;
+		case "is not": return matcher !== value;
+		default: throw new Error(`Operator ${operator} not supported in custom matcher`);
+	}
+};
+const matchCustomMulti = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "custom", primitiveError("custom"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "string", "Invalid custom value");
+	const allowed = splitCsv(value);
+	if (allowed.length === 0) return false;
+	const candidates = [matcher];
+	if (operator === "is any of") return allowed.some((id) => candidates.includes(id));
+	if (operator === "is none of") return !allowed.some((id) => candidates.includes(id));
+	if (operator === "is all of") return allowed.every((id) => candidates.includes(id));
+	throw new Error(`Operator ${operator} not supported in custom matcher`);
+};
+const matchCustom = (condition, matcher) => {
+	if (isMultiCustomType(condition.type)) return matchCustomMulti(condition, matcher);
+	return matchCustomEquality(condition, matcher);
+};
+const assertCustom = (condition, order) => {
+	const { type } = condition;
+	switch (type) {
+		case "Fulfillment":
+		case "Fulfillments": return matchCustom(condition, order.fulfillment_id);
+		case "Store":
+		case "Stores": return matchCustom(condition, order.store_id);
+		case "Channel":
+		case "Channels": return matchCustom(condition, order.channel_id);
+		case "Brand":
+		case "Brands": return matchCustom(condition, order.brand_id);
+		default: throw new Error(`Condition ${type} not supported in custom matcher`);
+	}
+};
+//#endregion
+//#region src/rules/enumMatcher.ts
+const matchEnumOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "enum", primitiveError("enum"));
+	if (typeof matcher === "undefined") return false;
+	switch (operator) {
+		case "is":
+			assert(typeof value === "string", "Expected a single enum value");
+			return matcher === value;
+		case "is not":
+			assert(typeof value === "string", "Expected a single enum value");
+			return matcher !== value;
+		case "is any of":
+			assert(Array.isArray(value), "Expected a list of enum values");
+			return value.includes(matcher);
+		case "is none of":
+			assert(Array.isArray(value), "Expected a list of enum values");
+			return !value.includes(matcher);
+		default: throw new Error(`Operator ${operator} not supported in enum matcher`);
+	}
+};
+const paymentCollectAt = (condition, collectAt) => {
+	const matcherType = "Payment collect at";
+	assert(condition.primitive === "enum", primitiveError("enum"));
+	assert(condition.type === matcherType, typeError(matcherType));
+	return matchEnumOperator(condition, collectAt);
+};
+const paymentMethod = (condition, method) => {
+	const matcherType = "Payment method";
+	assert(condition.primitive === "enum", primitiveError("enum"));
+	assert(condition.type === matcherType, typeError(matcherType));
+	return matchEnumOperator(condition, method);
+};
+const paymentStatus = (condition, status) => {
+	const matcherType = "Payment status";
+	assert(condition.primitive === "enum", primitiveError("enum"));
+	assert(condition.type === matcherType, typeError(matcherType));
+	return matchEnumOperator(condition, status);
+};
+const CONDITION_INTERPRETATION_DEFAULT = "server";
+const isInterpretationCompatible = (interpretation, runtime, fallback) => {
+	if (!runtime) return true;
+	const value = interpretation ?? fallback;
+	if (value === "both") return true;
+	return value === runtime;
+};
+//#endregion
+//#region src/rules/numberMatcher.ts
+const matchNumberOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "number", primitiveError("number"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "number", "Invalid number value");
+	switch (operator) {
+		case "equal to": return matcher === value;
+		case "not equal to": return matcher !== value;
+		case "greater than": return matcher > value;
+		case "greater than or equal to": return matcher >= value;
+		case "less than": return matcher < value;
+		case "less than or equal to": return matcher <= value;
+		default: throw new Error(`Operator ${operator} not supported in number matcher`);
+	}
+};
+const orderIncludesProduct = (condition, quantity) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchNumberOperator(condition, quantity ?? 0);
+};
+const cartProductCount = (condition, count) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Cart product count";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchNumberOperator(condition, count);
+};
+const orderIncludesProductWithTag$1 = (condition, matcher) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product with tag";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchNumberOperator(condition, matcher);
+};
+//#endregion
+//#region src/rules/stringCondition.utils.ts
+const getCaseInsensitive = (condition) => {
+	return condition.caseInsensitive ?? false;
+};
+const normalizeStringForMatch = (value, caseInsensitive) => {
+	if (caseInsensitive) return value.toLowerCase();
+	return value;
+};
+const normalizePairForMatch = (matcher, expected, caseInsensitive) => {
+	return {
+		matcher: normalizeStringForMatch(matcher, caseInsensitive),
+		expected: normalizeStringForMatch(expected, caseInsensitive)
+	};
+};
+//#endregion
+//#region src/rules/stringMatcher.ts
+const matchStringOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "string", primitiveError("string"));
+	if (typeof matcher === "undefined") return false;
+	const caseInsensitive = getCaseInsensitive(condition);
+	const pair = normalizePairForMatch(matcher, String(value), caseInsensitive);
+	const normalizedMatcher = pair.matcher;
+	const normalizedExpected = pair.expected;
+	switch (operator) {
+		case "equal to": return normalizedMatcher === normalizedExpected;
+		case "not equal to": return normalizedMatcher !== normalizedExpected;
+		case "starts with": return normalizedMatcher.startsWith(normalizedExpected);
+		case "ends with": return normalizedMatcher.endsWith(normalizedExpected);
+		case "contains": return normalizedMatcher.includes(normalizedExpected);
+		default: throw new Error(`Operator ${operator} not supported in string matcher`);
+	}
+};
+const orderIncludesProductWithTag = (condition, matcher) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Order includes product with tag";
+	assert(primitive === "string", primitiveError("string"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchStringOperator(condition, matcher);
+};
+//#endregion
+//#region src/rules/monitoringMatcher.ts
+const windowOf = (condition) => {
+	if (!("window_minutes" in condition)) return void 0;
+	return condition.window_minutes;
+};
+const accumulatedEvents = (condition, count) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Accumulated events";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	if (typeof count === "undefined") return false;
+	return matchNumberOperator(condition, count);
+};
+const apiErrorRate = (condition, rate) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "API error rate";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	if (typeof rate === "undefined") return false;
+	return matchNumberOperator(condition, rate);
+};
+const httpStatus = (condition, status) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "HTTP status";
+	assert(primitive === "number", primitiveError("number"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	if (typeof status === "undefined") return false;
+	return matchNumberOperator(condition, status);
+};
+const requestPath = (condition, path) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Request path";
+	assert(primitive === "string", primitiveError("string"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchStringOperator(condition, path);
+};
+const failureMessage = (condition, message) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Failure message";
+	assert(primitive === "string", primitiveError("string"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchStringOperator(condition, message);
+};
+const windowMinutes = (condition) => {
+	return windowOf(condition);
+};
+//#endregion
+//#region src/rules/recurringDateCron.ts
+var import_dayjs_min = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(t, e) {
+		"object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+	})(exports, (function() {
+		"use strict";
+		var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = {
+			name: "en",
+			weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+			months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+			ordinal: function(t) {
+				var e = [
+					"th",
+					"st",
+					"nd",
+					"rd"
+				], n = t % 100;
+				return "[" + t + (e[(n - 20) % 10] || e[n] || e[0]) + "]";
+			}
+		}, m = function(t, e, n) {
+			var r = String(t);
+			return !r || r.length >= e ? t : "" + Array(e + 1 - r.length).join(n) + t;
+		}, v = {
+			s: m,
+			z: function(t) {
+				var e = -t.utcOffset(), n = Math.abs(e), r = Math.floor(n / 60), i = n % 60;
+				return (e <= 0 ? "+" : "-") + m(r, 2, "0") + ":" + m(i, 2, "0");
+			},
+			m: function t(e, n) {
+				if (e.date() < n.date()) return -t(n, e);
+				var r = 12 * (n.year() - e.year()) + (n.month() - e.month()), i = e.clone().add(r, c), s = n - i < 0, u = e.clone().add(r + (s ? -1 : 1), c);
+				return +(-(r + (n - i) / (s ? i - u : u - i)) || 0);
+			},
+			a: function(t) {
+				return t < 0 ? Math.ceil(t) || 0 : Math.floor(t);
+			},
+			p: function(t) {
+				return {
+					M: c,
+					y: h,
+					w: o,
+					d: a,
+					D: d,
+					h: u,
+					m: s,
+					s: i,
+					ms: r,
+					Q: f
+				}[t] || String(t || "").toLowerCase().replace(/s$/, "");
+			},
+			u: function(t) {
+				return void 0 === t;
+			}
+		}, g = "en", D = {};
+		D[g] = M;
+		var p = function(t) {
+			return t instanceof b;
+		}, S = function t(e, n, r) {
+			var i;
+			if (!e) return g;
+			if ("string" == typeof e) {
+				var s = e.toLowerCase();
+				D[s] && (i = s), n && (D[s] = n, i = s);
+				var u = e.split("-");
+				if (!i && u.length > 1) return t(u[0]);
+			} else {
+				var a = e.name;
+				D[a] = e, i = a;
+			}
+			return !r && i && (g = i), i || !r && g;
+		}, w = function(t, e) {
+			if (p(t)) return t.clone();
+			var n = "object" == typeof e ? e : {};
+			return n.date = t, n.args = arguments, new b(n);
+		}, O = v;
+		O.l = S, O.i = p, O.w = function(t, e) {
+			return w(t, {
+				locale: e.$L,
+				utc: e.$u,
+				x: e.$x,
+				$offset: e.$offset
+			});
+		};
+		var b = function() {
+			function M(t) {
+				this.$L = S(t.locale, null, !0), this.parse(t);
+			}
+			var m = M.prototype;
+			return m.parse = function(t) {
+				this.$d = function(t) {
+					var e = t.date, n = t.utc;
+					if (null === e) return /* @__PURE__ */ new Date(NaN);
+					if (O.u(e)) return /* @__PURE__ */ new Date();
+					if (e instanceof Date) return new Date(e);
+					if ("string" == typeof e && !/Z$/i.test(e)) {
+						var r = e.match($);
+						if (r) {
+							var i = r[2] - 1 || 0, s = (r[7] || "0").substring(0, 3);
+							return n ? new Date(Date.UTC(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s)) : new Date(r[1], i, r[3] || 1, r[4] || 0, r[5] || 0, r[6] || 0, s);
+						}
+					}
+					return new Date(e);
+				}(t), this.$x = t.x || {}, this.init();
+			}, m.init = function() {
+				var t = this.$d;
+				this.$y = t.getFullYear(), this.$M = t.getMonth(), this.$D = t.getDate(), this.$W = t.getDay(), this.$H = t.getHours(), this.$m = t.getMinutes(), this.$s = t.getSeconds(), this.$ms = t.getMilliseconds();
+			}, m.$utils = function() {
+				return O;
+			}, m.isValid = function() {
+				return !(this.$d.toString() === l);
+			}, m.isSame = function(t, e) {
+				var n = w(t);
+				return this.startOf(e) <= n && n <= this.endOf(e);
+			}, m.isAfter = function(t, e) {
+				return w(t) < this.startOf(e);
+			}, m.isBefore = function(t, e) {
+				return this.endOf(e) < w(t);
+			}, m.$g = function(t, e, n) {
+				return O.u(t) ? this[e] : this.set(n, t);
+			}, m.unix = function() {
+				return Math.floor(this.valueOf() / 1e3);
+			}, m.valueOf = function() {
+				return this.$d.getTime();
+			}, m.startOf = function(t, e) {
+				var n = this, r = !!O.u(e) || e, f = O.p(t), l = function(t, e) {
+					var i = O.w(n.$u ? Date.UTC(n.$y, e, t) : new Date(n.$y, e, t), n);
+					return r ? i : i.endOf(a);
+				}, $ = function(t, e) {
+					return O.w(n.toDate()[t].apply(n.toDate("s"), (r ? [
+						0,
+						0,
+						0,
+						0
+					] : [
+						23,
+						59,
+						59,
+						999
+					]).slice(e)), n);
+				}, y = this.$W, M = this.$M, m = this.$D, v = "set" + (this.$u ? "UTC" : "");
+				switch (f) {
+					case h: return r ? l(1, 0) : l(31, 11);
+					case c: return r ? l(1, M) : l(0, M + 1);
+					case o:
+						var g = this.$locale().weekStart || 0, D = (y < g ? y + 7 : y) - g;
+						return l(r ? m - D : m + (6 - D), M);
+					case a:
+					case d: return $(v + "Hours", 0);
+					case u: return $(v + "Minutes", 1);
+					case s: return $(v + "Seconds", 2);
+					case i: return $(v + "Milliseconds", 3);
+					default: return this.clone();
+				}
+			}, m.endOf = function(t) {
+				return this.startOf(t, !1);
+			}, m.$set = function(t, e) {
+				var n, o = O.p(t), f = "set" + (this.$u ? "UTC" : ""), l = (n = {}, n[a] = f + "Date", n[d] = f + "Date", n[c] = f + "Month", n[h] = f + "FullYear", n[u] = f + "Hours", n[s] = f + "Minutes", n[i] = f + "Seconds", n[r] = f + "Milliseconds", n)[o], $ = o === a ? this.$D + (e - this.$W) : e;
+				if (o === c || o === h) {
+					var y = this.clone().set(d, 1);
+					y.$d[l]($), y.init(), this.$d = y.set(d, Math.min(this.$D, y.daysInMonth())).$d;
+				} else l && this.$d[l]($);
+				return this.init(), this;
+			}, m.set = function(t, e) {
+				return this.clone().$set(t, e);
+			}, m.get = function(t) {
+				return this[O.p(t)]();
+			}, m.add = function(r, f) {
+				var d, l = this;
+				r = Number(r);
+				var $ = O.p(f), y = function(t) {
+					var e = w(l);
+					return O.w(e.date(e.date() + Math.round(t * r)), l);
+				};
+				if ($ === c) return this.set(c, this.$M + r);
+				if ($ === h) return this.set(h, this.$y + r);
+				if ($ === a) return y(1);
+				if ($ === o) return y(7);
+				var M = (d = {}, d[s] = e, d[u] = n, d[i] = t, d)[$] || 1, m = this.$d.getTime() + r * M;
+				return O.w(m, this);
+			}, m.subtract = function(t, e) {
+				return this.add(-1 * t, e);
+			}, m.format = function(t) {
+				var e = this, n = this.$locale();
+				if (!this.isValid()) return n.invalidDate || l;
+				var r = t || "YYYY-MM-DDTHH:mm:ssZ", i = O.z(this), s = this.$H, u = this.$m, a = this.$M, o = n.weekdays, c = n.months, f = n.meridiem, h = function(t, n, i, s) {
+					return t && (t[n] || t(e, r)) || i[n].slice(0, s);
+				}, d = function(t) {
+					return O.s(s % 12 || 12, t, "0");
+				}, $ = f || function(t, e, n) {
+					var r = t < 12 ? "AM" : "PM";
+					return n ? r.toLowerCase() : r;
+				};
+				return r.replace(y, (function(t, r) {
+					return r || function(t) {
+						switch (t) {
+							case "YY": return String(e.$y).slice(-2);
+							case "YYYY": return O.s(e.$y, 4, "0");
+							case "M": return a + 1;
+							case "MM": return O.s(a + 1, 2, "0");
+							case "MMM": return h(n.monthsShort, a, c, 3);
+							case "MMMM": return h(c, a);
+							case "D": return e.$D;
+							case "DD": return O.s(e.$D, 2, "0");
+							case "d": return String(e.$W);
+							case "dd": return h(n.weekdaysMin, e.$W, o, 2);
+							case "ddd": return h(n.weekdaysShort, e.$W, o, 3);
+							case "dddd": return o[e.$W];
+							case "H": return String(s);
+							case "HH": return O.s(s, 2, "0");
+							case "h": return d(1);
+							case "hh": return d(2);
+							case "a": return $(s, u, !0);
+							case "A": return $(s, u, !1);
+							case "m": return String(u);
+							case "mm": return O.s(u, 2, "0");
+							case "s": return String(e.$s);
+							case "ss": return O.s(e.$s, 2, "0");
+							case "SSS": return O.s(e.$ms, 3, "0");
+							case "Z": return i;
+						}
+						return null;
+					}(t) || i.replace(":", "");
+				}));
+			}, m.utcOffset = function() {
+				return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+			}, m.diff = function(r, d, l) {
+				var $, y = this, M = O.p(d), m = w(r), v = (m.utcOffset() - this.utcOffset()) * e, g = this - m, D = function() {
+					return O.m(y, m);
+				};
+				switch (M) {
+					case h:
+						$ = D() / 12;
+						break;
+					case c:
+						$ = D();
+						break;
+					case f:
+						$ = D() / 3;
+						break;
+					case o:
+						$ = (g - v) / 6048e5;
+						break;
+					case a:
+						$ = (g - v) / 864e5;
+						break;
+					case u:
+						$ = g / n;
+						break;
+					case s:
+						$ = g / e;
+						break;
+					case i:
+						$ = g / t;
+						break;
+					default: $ = g;
+				}
+				return l ? $ : O.a($);
+			}, m.daysInMonth = function() {
+				return this.endOf(c).$D;
+			}, m.$locale = function() {
+				return D[this.$L];
+			}, m.locale = function(t, e) {
+				if (!t) return this.$L;
+				var n = this.clone(), r = S(t, e, !0);
+				return r && (n.$L = r), n;
+			}, m.clone = function() {
+				return O.w(this.$d, this);
+			}, m.toDate = function() {
+				return new Date(this.valueOf());
+			}, m.toJSON = function() {
+				return this.isValid() ? this.toISOString() : null;
+			}, m.toISOString = function() {
+				return this.$d.toISOString();
+			}, m.toString = function() {
+				return this.$d.toUTCString();
+			}, M;
+		}(), _ = b.prototype;
+		return w.prototype = _, [
+			["$ms", r],
+			["$s", i],
+			["$m", s],
+			["$H", u],
+			["$W", a],
+			["$M", c],
+			["$y", h],
+			["$D", d]
+		].forEach((function(t) {
+			_[t[1]] = function(e) {
+				return this.$g(e, t[0], t[1]);
+			};
+		})), w.extend = function(t, e) {
+			return t.$i || (t(e, b, w), t.$i = !0), w;
+		}, w.locale = S, w.isDayjs = p, w.unix = function(t) {
+			return w(1e3 * t);
+		}, w.en = D[g], w.Ls = D, w.p = {}, w;
+	}));
+})))(), 1);
+import_dayjs_min.default.extend(utc);
+import_dayjs_min.default.extend(timezone);
+import_dayjs_min.default.extend(isBetween);
+import_dayjs_min.default.extend(isSameOrAfter);
+import_dayjs_min.default.extend(weekOfYear);
+import_dayjs_min.default.extend(advancedFormat);
+var RecurringDateCron = class {
+	startDate;
+	endDate;
+	repeat;
+	timezone;
+	constructor(values, timezone) {
+		this.startDate = new Date(values.startDate);
+		this.endDate = new Date(values.endDate);
+		this.repeat = values.repeat;
+		this.timezone = timezone;
+	}
+	day = (...params) => {
+		return (0, import_dayjs_min.default)(...params).tz(this.timezone);
+	};
+	getExpression() {
+		const start = this.day(this.startDate);
+		const end = this.day(this.endDate);
+		const startDayOfMonth = start.date();
+		const endDayOfMonth = end.date();
+		const dayOfMonthRange = `${startDayOfMonth}-${endDayOfMonth}`;
+		const sameDayOfMonth = startDayOfMonth === endDayOfMonth;
+		const startDayOfWeek = start.day();
+		const endDayOfWeek = end.day();
+		const dayOfWeekRange = `${startDayOfWeek}-${endDayOfWeek}`;
+		const sameDayOfWeek = startDayOfWeek === endDayOfWeek;
+		const dayOfMonth = sameDayOfMonth ? startDayOfMonth : dayOfMonthRange;
+		const dayOfWeek = sameDayOfWeek ? startDayOfWeek : dayOfWeekRange;
+		const startOfMonth = start.clone().startOf("month");
+		const weeks = Math.ceil(Math.abs(start.diff(startOfMonth, "weeks", true)));
+		switch (this.repeat) {
+			case "NONE": return `0 0`;
+			case "DAILY": return `* *`;
+			case "WEEKDAYS": return `* 1-5`;
+			case "WEEKENDS": return `* 6,0`;
+			case "WEEKLY": return `* ${dayOfWeek}`;
+			case "FORTNIGHTLY": return `F ${dayOfWeek}`;
+			case "MONTHLY": return `${dayOfMonth} *`;
+			case "LAST_DAY_OF_MONTH": return `L *`;
+			case "WEEK_OF_MONTH": return `${weeks}W ${dayOfWeek}`;
+			default: throw new Error(`Unsupported repeat value: ${this.repeat}`);
+		}
+	}
+	getDescription(cron) {
+		const start = this.day(this.startDate);
+		const end = this.day(this.endDate);
+		const isSameDay = start.isSame(end, "day");
+		const fromDate = start.format("MMMM Do");
+		const toDate = end.format("MMMM Do");
+		const fromTime = start.format("HH:mm");
+		const toTime = end.format("HH:mm");
+		const fromDayOfMonth = start.format("Do");
+		const toDayOfMonth = end.format("Do");
+		const isStartOfDay = start.isSame(start.clone().startOf("day"), "minutes");
+		const isEndOfDay = end.isSame(end.clone().endOf("day"), "minutes");
+		const isFullDay = isStartOfDay && isEndOfDay && isSameDay;
+		assert(cron, "Invalid recurring date cron expression");
+		const segments = cron.split(" ");
+		const first = segments[0];
+		const second = segments[1];
+		assert(first && second, "Invalid recurring date cron expression");
+		const compoundFromToDate = `from ${fromDate} at ${fromTime} to ${toDate} at ${toTime}`;
+		const singleFromToDate = `on ${fromDate} from ${fromTime} to ${toTime}`;
+		const fullDayFromToDay = `on ${fromDate}`;
+		let fromToDate = isSameDay ? singleFromToDate : compoundFromToDate;
+		if (isFullDay) fromToDate = fullDayFromToDay;
+		const fromToTime = isFullDay ? "" : ` from ${fromTime} to ${toTime}`;
+		const fromDayOfWeek = start.format("dddd");
+		const fromToDayOfWeek = `${fromDayOfWeek}s to ${end.format("dddd")}s`;
+		const dayOfWeek = isSameDay ? `on ${fromDayOfWeek}s` : fromToDayOfWeek;
+		const singleDayOfMonth = `on the ${fromDayOfMonth}`;
+		const fromToDayOfMonth = `on the ${fromDayOfMonth} to ${toDayOfMonth}`;
+		const dayOfMonth = isSameDay ? singleDayOfMonth : fromToDayOfMonth;
+		const weeks = Number(first.slice(0, -1));
+		let weekOfMonth = "1st";
+		if (weeks === 2) weekOfMonth = "2nd";
+		if (weeks === 3) weekOfMonth = "3rd";
+		if (weeks === 4) weekOfMonth = "4th";
+		if (weeks === 5) weekOfMonth = "5th";
+		const startsOn = `, starting on ${start.format("MMMM Do")}`;
+		switch (this.repeat) {
+			case "NONE": return `Once ${fromToDate}`;
+			case "DAILY": return `Daily${fromToTime}${startsOn}`;
+			case "WEEKDAYS": return `On weekdays${fromToTime}${startsOn}`;
+			case "WEEKENDS": return `On weekends${fromToTime}${startsOn}`;
+			case "WEEKLY": return `Weekly ${dayOfWeek}${fromToTime}${startsOn}`;
+			case "FORTNIGHTLY": return `Fortnightly ${dayOfWeek}${fromToTime}${startsOn}`;
+			case "MONTHLY": return `Monthly ${dayOfMonth}${fromToTime}${startsOn}`;
+			case "LAST_DAY_OF_MONTH": return `Every Last day of the month${fromToTime}${startsOn}`;
+			case "WEEK_OF_MONTH": return `Every ${weekOfMonth} ${fromDayOfWeek} of the month${fromToTime}${startsOn}`;
+			default: throw new Error(`Unsupported repeat value: ${this.repeat}`);
+		}
+	}
+	get result() {
+		const expression = this.getExpression();
+		const description = this.getDescription(expression);
+		return {
+			startDate: this.startDate,
+			endDate: this.endDate,
+			repeat: this.repeat,
+			expression,
+			description
+		};
+	}
+	match = (date) => {
+		const dateObj = this.day(date);
+		if (!dateObj.isValid()) return false;
+		if (this.repeat === "NONE") return dateObj.isBetween(this.startDate, this.endDate, "minutes", "[]");
+		const started = dateObj.isSameOrAfter(this.startDate, "day");
+		const isWeekday = dateObj.day() >= 1 && dateObj.day() <= 5;
+		const isWeekend = dateObj.day() === 0 || dateObj.day() === 6;
+		const dayOfWeek = dateObj.day();
+		const firstDayOfWeek = this.startDate.getDay();
+		const lastDayOfWeek = this.endDate.getDay();
+		const isBetweenWeekDays = dayOfWeek >= firstDayOfWeek && dayOfWeek <= lastDayOfWeek;
+		const dayOfMonth = dateObj.date();
+		const firstDayOfMonth = this.startDate.getDate();
+		const lastDayOfMonth = this.endDate.getDate();
+		const isBetweenDaysOfMonth = dayOfMonth >= firstDayOfMonth && dayOfMonth <= lastDayOfMonth;
+		let start = this.day(this.startDate);
+		start = start.year(dateObj.year());
+		start = start.month(dateObj.month());
+		start = start.date(dateObj.date());
+		let end = this.day(this.endDate);
+		end = end.year(dateObj.year());
+		end = end.month(dateObj.month());
+		end = end.date(dateObj.date());
+		const betweenTime = dateObj.isBetween(start, end, "minutes", "[]");
+		switch (this.repeat) {
+			case "DAILY":
+				if (!started) return false;
+				return betweenTime;
+			case "WEEKDAYS":
+				if (!started || !isWeekday) return false;
+				return betweenTime;
+			case "WEEKENDS":
+				if (!started || !isWeekend) return false;
+				return betweenTime;
+			case "WEEKLY":
+				if (!started || !isBetweenWeekDays) return false;
+				return betweenTime;
+			case "FORTNIGHTLY": {
+				if (!started || !isBetweenWeekDays) return false;
+				const weekOfYear = dateObj.week();
+				const conditionWeekOfYear = this.day(this.startDate).week();
+				if (!(weekOfYear % 2 === conditionWeekOfYear % 2)) return false;
+				return betweenTime;
+			}
+			case "MONTHLY":
+				if (!started || !isBetweenDaysOfMonth) return false;
+				return betweenTime;
+			case "LAST_DAY_OF_MONTH":
+				if (!started) return false;
+				if (!(dayOfMonth === dateObj.endOf("month").date())) return false;
+				return betweenTime;
+			case "WEEK_OF_MONTH": {
+				if (!started || !isBetweenWeekDays) return false;
+				const firstDay = dateObj.clone().startOf("month");
+				const startDate = this.day(this.startDate);
+				const conditionFirstDay = startDate.clone().startOf("month");
+				if (!(startDate.diff(conditionFirstDay, "weeks") + 1 === Math.abs(dateObj.diff(firstDay, "weeks") + 1))) return false;
+				return betweenTime;
+			}
+			default: throw new Error(`Unsupported repeat value: ${this.repeat}`);
+		}
+	};
+};
+//#endregion
+//#region src/rules/recurringDateMatcher.ts
+const matchRecurringDateOperator = (condition, matcher) => {
+	const { primitive, operator } = condition;
+	assert(primitive === "recurring date", primitiveError("recurring date"));
+	if (typeof matcher === "undefined") return false;
+	switch (operator) {
+		case "falls within period": return new RecurringDateCron(condition).match(matcher);
+		default: {
+			const msg = `Operator ${operator} not supported in recurring date matcher`;
+			throw new Error(msg);
+		}
+	}
+};
+const currentDate = (condition, referenceDate) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Current date";
+	assert(primitive === "recurring date", primitiveError("recurring date"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value value");
+	const current = referenceDate ?? (/* @__PURE__ */ new Date()).toISOString();
+	return matchRecurringDateOperator(condition, current);
+};
+//#endregion
+//#region src/rules/RulesEngine.ts
+var RulesEngine = class {
+	order;
+	customer;
+	payment;
+	monitoring;
+	referenceDate;
+	runtime;
+	constructor(params = {}) {
+		const { order, customer, payment, monitoring, referenceDate } = params;
+		const { runtime } = params;
+		this.order = order;
+		this.customer = customer;
+		this.payment = payment;
+		this.monitoring = monitoring;
+		this.referenceDate = referenceDate;
+		this.runtime = runtime;
+	}
+	getDependency(prop, type) {
+		const value = this[prop];
+		const errorMsg = `You cannot use "${type}" condition without sending ${String(prop)}`;
+		assert(value !== void 0, errorMsg);
+		return value;
+	}
+	selectError = (prev, next) => {
+		if (!prev) return next;
+		return next === "Condition was not met" ? prev : next;
+	};
+	getProductId = (condition) => {
+		if (!("product_id" in condition) || !condition.product_id) throw new Error("Invalid product_id");
+		return condition.product_id;
+	};
+	getProductTag = (condition) => {
+		if (!("tag" in condition) || !condition.tag) throw new Error("Invalid tag");
+		return condition.tag;
+	};
+	matchOrderProductTag = (condition, match) => {
+		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;
+		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 === "Request path") {
+			const monitoring = this.getDependency("monitoring", type);
+			return requestPath(condition, monitoring.path);
+		}
+		if (type === "Failure message") {
+			const monitoring = this.getDependency("monitoring", type);
+			return failureMessage(condition, monitoring.message);
+		}
+		throw new Error(`Condition ${type} not supported in string matcher`);
+	};
+	assertNumber = (condition) => {
+		const { primitive, type } = condition;
+		assert(primitive === "number", primitiveError("number"));
+		if (type === "Cart product count") {
+			const order = this.getDependency("order", type);
+			const include = "include_modifiers" in condition && Boolean(condition.include_modifiers);
+			const count = countCartProducts(order.lines, include);
+			return cartProductCount(condition, count);
+		}
+		if (type === "Order includes product") {
+			const order = this.getDependency("order", type);
+			const productId = this.getProductId(condition);
+			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 === "Accumulated events") {
+			const monitoring = this.getDependency("monitoring", type);
+			const window = windowMinutes(condition);
+			if (window == null) return false;
+			const count = monitoring.event_counts[window];
+			return accumulatedEvents(condition, count);
+		}
+		if (type === "API error rate") {
+			const monitoring = this.getDependency("monitoring", type);
+			const window = windowMinutes(condition);
+			if (window == null) return false;
+			const rate = monitoring.error_rates[window];
+			return apiErrorRate(condition, rate);
+		}
+		if (type === "HTTP status") {
+			const monitoring = this.getDependency("monitoring", type);
+			return httpStatus(condition, monitoring.http_status);
+		}
+		throw new Error(`Condition ${type} not supported in number matcher`);
+	};
+	assertBoolean = (condition) => {
+		const { primitive, type } = condition;
+		assert(primitive === "boolean", primitiveError("boolean"));
+		if (type === "Is anonymous order") {
+			const order = this.getDependency("order", type);
+			return isAnonymousOrder(condition, order.is_anonymous);
+		}
+		if (type === "Customer is anonymous") {
+			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);
+		});
+		throw new Error(`Condition ${type} not supported in boolean matcher`);
+	};
+	assertCurrency = (condition) => {
+		const { primitive, type } = condition;
+		assert(primitive === "currency", primitiveError("currency"));
+		if (type === "Order total") {
+			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);
+		});
+		throw new Error(`Condition ${type} not supported in currency matcher`);
+	};
+	assertEnum = (condition) => {
+		const { primitive, type } = condition;
+		assert(primitive === "enum", primitiveError("enum"));
+		const payment = this.getDependency("payment", type);
+		switch (type) {
+			case "Payment collect at": return paymentCollectAt(condition, payment.collect_at);
+			case "Payment method": return paymentMethod(condition, payment.method);
+			case "Payment status": return paymentStatus(condition, payment.status);
+			default: throw new Error(`Condition ${type} not supported in enum matcher`);
+		}
+	};
+	assertAbsoluteDate = (condition) => {
+		const { primitive, type } = condition;
+		assert(primitive === "absolute date", primitiveError("absolute date"));
+		const msg = `Condition ${type} not supported in absolute date matcher`;
+		throw new Error(msg);
+	};
+	assertRelativeDate = (condition) => {
+		const { primitive, type } = condition;
+		assert(primitive === "relative date", primitiveError("relative date"));
+		const msg = `Condition ${type} not supported in relative date matcher`;
+		throw new Error(msg);
+	};
+	assertRecurringDate = (condition) => {
+		const { primitive, type } = condition;
+		assert(primitive === "recurring date", primitiveError("recurring date"));
+		if (type === "Current date") return currentDate(condition, this.referenceDate);
+		const msg = `Condition ${type} not supported in recurring date matcher`;
+		throw new Error(msg);
+	};
+	assertCustom = (condition) => {
+		const order = this.getDependency("order", condition.type);
+		return assertCustom(condition, order);
+	};
+	assertCondition = (condition) => {
+		const { primitive } = condition;
+		switch (primitive) {
+			case "string": return this.assertString(condition);
+			case "number": return this.assertNumber(condition);
+			case "boolean": return this.assertBoolean(condition);
+			case "currency": return this.assertCurrency(condition);
+			case "enum": return this.assertEnum(condition);
+			case "absolute date": return this.assertAbsoluteDate(condition);
+			case "relative date": return this.assertRelativeDate(condition);
+			case "recurring date": return this.assertRecurringDate(condition);
+			case "custom": return this.assertCustom(condition);
+			default: throw new Error(`Unsupported primitive: ${primitive}`);
+		}
+	};
+	matchCondition = (condition) => {
+		try {
+			if (this.assertCondition(condition)) return {
+				match: condition,
+				error: null
+			};
+			return {
+				match: null,
+				error: condition.invalidMessage ?? "Condition was not met"
+			};
+		} catch (error) {
+			return {
+				match: null,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	matchAndConditions = (andConditions) => {
+		let error = null;
+		for (const condition of andConditions) {
+			const interp = condition.interpretation;
+			if (!isInterpretationCompatible(interp, this.runtime, "server")) return {
+				match: null,
+				error: defaultConditionError
+			};
+			const result = this.matchCondition(condition);
+			if (!result.match) {
+				error = this.selectError(error, result.error);
+				return {
+					match: null,
+					error: error ?? "Condition was not met"
+				};
+			}
+		}
+		return {
+			match: andConditions,
+			error: null
+		};
+	};
+	matchOrConditions = (orConditions) => {
+		let error = null;
+		for (const andConditions of orConditions) {
+			const result = this.matchAndConditions(andConditions);
+			if (result.match) return {
+				match: result.match,
+				error: null
+			};
+			error = this.selectError(error, result.error);
+		}
+		return {
+			match: null,
+			error: error ?? "Condition was not met"
+		};
+	};
+	matchRules = (rules, options) => {
+		const exclusive = options?.exclusive ?? false;
+		const matched = [];
+		for (const rule of rules) {
+			if (!isInterpretationCompatible(rule.interpretation, this.runtime, "both")) continue;
+			const conditions = rule.conditions ?? [];
+			if (conditions.length === 0) {
+				matched.push(rule);
+				if (exclusive) return matched;
+				continue;
+			}
+			if (!this.matchOrConditions(conditions).match) continue;
+			matched.push(rule);
+			if (exclusive) return matched;
+		}
+		return matched;
+	};
+};
+//#endregion
+//#region src/rules/absoluteDateMatcher.ts
+const matchAbsoluteDateOperator = (condition, matcher) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "absolute date", primitiveError("absolute date"));
+	if (typeof matcher === "undefined") return false;
+	const matcherDate = (0, import_dayjs_min.default)(matcher);
+	const expectedDate = (0, import_dayjs_min.default)(value);
+	switch (operator) {
+		case "is": return matcherDate.isSame(expectedDate, "day");
+		case "is not": return !matcherDate.isSame(expectedDate, "day");
+		case "is before": return matcherDate.isBefore(expectedDate, "day");
+		case "is after": return matcherDate.isAfter(expectedDate, "day");
+		default: {
+			const msg = `Operator ${operator} not supported in absolute date matcher`;
+			throw new Error(msg);
+		}
+	}
+};
+//#endregion
+//#region src/rules/relativeDateMatcher.ts
+const matchRelativeDateOperator = (condition, matcher, referenceDate) => {
+	const { primitive, operator, value } = condition;
+	assert(primitive === "relative date", primitiveError("relative date"));
+	if (typeof matcher === "undefined") return false;
+	assert(typeof value === "string", "Invalid relative date value");
+	const [amountString, unitRaw] = value.split("/");
+	assert(amountString && unitRaw, "Amount & Unit required");
+	const amount = parseInt(amountString, 10);
+	const unit = unitRaw;
+	const issueDate = (0, import_dayjs_min.default)(referenceDate ?? (/* @__PURE__ */ new Date()).toISOString());
+	const matcherDate = (0, import_dayjs_min.default)(matcher);
+	switch (operator) {
+		case "occurred": {
+			const endDate = issueDate.subtract(amount, unit).endOf(unit);
+			const startDate = endDate.startOf(unit);
+			const sameStart = matcherDate.isSame(startDate, unit);
+			const afterStart = matcherDate.isAfter(startDate);
+			const sameEnd = matcherDate.isSame(endDate, unit);
+			const beforeEnd = matcherDate.isBefore(endDate);
+			return (sameStart || afterStart) && (sameEnd || beforeEnd);
+		}
+		case "occurred in the last": {
+			const targetDate = issueDate.subtract(amount, unit);
+			const sameTarget = matcherDate.isSame(targetDate, unit);
+			const afterTarget = matcherDate.isAfter(targetDate);
+			const sameIssue = matcherDate.isSame(issueDate, unit);
+			const beforeIssue = matcherDate.isBefore(issueDate);
+			return (sameTarget || afterTarget) && (sameIssue || beforeIssue);
+		}
+		case "occurred more than": {
+			const targetDate = issueDate.subtract(amount, unit);
+			return matcherDate.isBefore(targetDate, unit);
+		}
+		default: {
+			const msg = `Operator ${operator} not supported in relative date matcher`;
+			throw new Error(msg);
+		}
+	}
+};
+//#endregion
+//#region src/rules/checkout.ts
+const DEFAULT_SHIPPING_FIELDS = {
+	address_line1: "required",
+	address_line2: "optional",
+	city: "optional",
+	state: "optional",
+	zip: "optional",
+	country: "optional",
+	reference: "optional",
+	instructions: "optional"
+};
+const DEFAULT_BILLING_FIELDS = {
+	type: "required",
+	legal_name: "required",
+	address_line1: "required",
+	address_line2: "optional",
+	city: "optional",
+	state: "optional",
+	zip: "optional",
+	country: "optional",
+	tax_id: "required",
+	tax_id_type: "required"
+};
+const getCheckoutFieldValue = (info, key) => {
+	if (!info) return void 0;
+	const top = info[key];
+	if (top != null && top !== "") return top;
+	const metadata = info.metadata;
+	if (!metadata || typeof metadata !== "object") return void 0;
+	if (Array.isArray(metadata)) return void 0;
+	return metadata[key];
+};
+const isCheckoutFieldFilled = (info, key) => {
+	const value = getCheckoutFieldValue(info, key);
+	if (value == null) return false;
+	if (typeof value === "string") return value.trim().length > 0;
+	return true;
+};
+const fallbackRequired = {
+	fallback: true,
+	interpretation: "both",
+	effect: { mode: "required" },
+	conditions: []
+};
+const defaultCheckoutPreferences = {
+	shipping: {
+		fields: DEFAULT_SHIPPING_FIELDS,
+		rules: [fallbackRequired]
+	},
+	billing: {
+		fields: DEFAULT_BILLING_FIELDS,
+		rules: [fallbackRequired]
+	}
+};
+const factsFromOrder = (order) => {
+	const brand_id = order.brand_id ?? void 0;
+	const b1 = {
+		total: order.totals?.total ?? 0,
+		is_anonymous: order.is_anonymous ?? false,
+		brand_id
+	};
+	const b2 = {
+		store_id: order.store_id,
+		channel_id: order.channel_id
+	};
+	const b3 = {
+		fulfillment_id: order.fulfillment_id,
+		lines: order.lines
+	};
+	return {
+		...b1,
+		...b2,
+		...b3
+	};
+};
+const checkoutFromMeta = (order) => {
+	const raw = order.metadata?.checkout;
+	if (!raw || typeof raw !== "object") return null;
+	const checkout = raw;
+	if (!checkout.shipping?.rules || !checkout.billing?.rules) return null;
+	return checkout;
+};
+const resolveSection = (section, engine) => {
+	const ranked = section.rules.filter((rule) => !rule.fallback);
+	const matched = engine.matchRules(ranked, { exclusive: true });
+	const fallback = section.rules.find((rule) => rule.fallback);
+	return (matched[0] ?? fallback)?.effect.mode ?? "required";
+};
+/** Only these fulfillment types ship to the customer's address. */
+const SHIPPING_FULFILLMENT_TYPES = /* @__PURE__ */ new Set(["DELIVERY"]);
+const resolveCheckout = (order, options) => {
+	const fromMeta = checkoutFromMeta(order);
+	const checkout = options?.checkout ?? fromMeta ?? defaultCheckoutPreferences;
+	const runtime = options?.runtime ?? "client";
+	const referenceDate = options?.now ?? (/* @__PURE__ */ new Date()).toISOString();
+	const facts = factsFromOrder(order);
+	const engine = new RulesEngine({
+		order: facts,
+		customer: { is_anonymous: facts.is_anonymous },
+		referenceDate,
+		runtime
+	});
+	const type = options?.fulfillmentType;
+	const ships = !type || SHIPPING_FULFILLMENT_TYPES.has(type);
+	let shipping = "hidden";
+	if (ships) shipping = resolveSection(checkout.shipping, engine);
+	const billing = resolveSection(checkout.billing, engine);
+	const shippingFields = checkout.shipping.fields ?? DEFAULT_SHIPPING_FIELDS;
+	const billingFields = checkout.billing.fields ?? DEFAULT_BILLING_FIELDS;
+	return {
+		shipping,
+		billing,
+		shippingFields,
+		billingFields
+	};
+};
+//#endregion
+//#region src/rules/payments.ts
+const runsOnClient = (condition) => {
+	const fallback = CONDITION_INTERPRETATION_DEFAULT;
+	return isInterpretationCompatible(condition.interpretation, "client", fallback);
+};
+/**
+* Client pre-filter for a payment's conditions against a local order.
+* Server-only conditions count as met; place order checks them all.
+*/
+const paymentMatchesClientConditions = (conditions, order, options) => {
+	const groups = (conditions ?? []).map((group) => group.filter(runsOnClient));
+	if (groups.length === 0) return true;
+	if (groups.some((group) => group.length === 0)) return true;
+	const facts = factsFromOrder(order);
+	const engine = new RulesEngine({
+		order: facts,
+		customer: { is_anonymous: facts.is_anonymous },
+		referenceDate: options?.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+		runtime: "client"
+	});
+	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 };