@fire-spark/core 0.4.0 → 0.4.1

package/dist/index.d.ts

@@ -783,6 +783,12 @@ declare const isDeviceCharged: (tender: {
 }) => boolean;
 /** Most a REDEMPTION can cover: order total − tip − delivery (D18). */
 declare const redemptionCap: (order: Pick<Order$1, "lines" | "totals">) => number;
+/**
+ * Trims payment redeems in application order so their sum fits the cap.
+ * Discount redeems are left untouched. The last trimmed amount is whatever
+ * room remains, so the kept amounts sum to at most `cap`.
+ */
+declare const clampPaymentRedeems: (redeem: readonly OrderRedeem[], cap: number, _currency: string) => OrderRedeem[];
 type SimpleTenderPayment = {
   id?: string;
   type?: PaymentTenderInput["method"];
@@ -1142,6 +1148,8 @@ declare class RulesEngine {
   private assertBoolean;
   private assertCurrency;
   private assertEnum;
+  private customerAge;
+  private customerDate;
   private assertAbsoluteDate;
   private assertRelativeDate;
   private assertRecurringDate;
@@ -1316,4 +1324,4 @@ declare const validateCardholderName: (value: string) => CardholderNameError | n
  */
 declare const cardPreviewGroups: (value: string) => CardPreviewSlot[][];
 //#endregion
-export { type ApplyRedeemInput, type AuthConfigureOptions, CARD_BRANDS, type CardBrand, type CardBrandSpec, type CardCvcError, type CardExpiry, type CardExpiryError, type CardNumberError, type CardPreviewSlot, type CardholderNameError, type CreateOrderOptions, type CreateSessionOptions, type CustomizationPath, type CustomizationSession, DEFAULT_RECOMMENDATION_TYPES, type ExchangeOptions, type FailedCharge, type FlatMenuCategory, type GroupDisplayType, type IdBuilder, type ListMenusStreamOptions, type ListPaymentsOptions, type Menu, type MenuCategoryNode, type MenuLookup, type MilestoneSteps, type MilestoneTrackItem, type ModifierControlType, type ModifierCtx, type ModifierGroupCtx, type NestedMenuCategory, Order, type OrderCustomerSource, type OrderDraft, type OrderIssue, type OrderIssueCode, type OrderLineDiff, type OrderLineIssue, type OrderLineIssueCode, type OrderScope, OrderSyncPendingError, OrderValidationError, type OrderValidationResult, type PayIntentOptions, type PayIntentResult, type PayOptions, type PaymentCardBrand, type PaymentProgressEvent, type PaymentProgressListener, type PaymentRunOptions, type PaymentSessionOptions, type PricingModifier, type Product, type ProductCtx, type QuantitiesByPath, type RecommendationType, RecurringDateCron, type RemoveRedeemInput, type ReorderOrderOptions, type ResetOptions, type ReversalOutcome, type ReverseAllOptions, RulesEngine, type ScheduleWindow, type SelectionStatus, type SelectionsByPath, type SerializedError, type ServiceHttpOptions, type SimpleTenderPayment, type Snapshot, type StorefrontAccessToken, type StorefrontErrorDetails, StorefrontHttpError, type TrackWorkflow, type ValidateOptions, type ValidateOrderAgainstMenuInput, type Variant, type VariantGroup, type VariantGroupCtx, type VariantOptionCtx, type VariantSelection, type VerifyWebhookSignatureInput, type VisitedState, addLines, auth, buildCustomerSnapshot, cardBrandSpec, cardDigits, cardNumberGaps, cardNumberMaxLength, cardPreviewGroups, caretAfterDigits, collectOrderLineDiffs, computeStartingPrice, countCartProducts, coveredAmount, createSession, currentNodes, cvcMaxLength, defaultConditionError, detectCardBrand, flattenMenuCategories, flushLogs, formatCardNumber, formatCvc, formatExpiry, fromOrderLines, genId, genOrderId, getLogContext, getScheduleWindow, indexMenu, isCardNumberComplete, isCardNumberDefinitelyInvalid, isCheckoutFieldFilled, isCvcComplete, isDeviceCharged, isDeviceNotLinked, isExpiryComplete, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isPosDeviceNotLinked, isPosUnauthorized, isRealPaymentMethod, isStorefrontNotFound, isVariantBase, listMenusStream, localizePosError, log, logError, luhnCheck, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, normalizeCardholderName, orderPaymentRedeems, parseExpiry, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, redemptionCap, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, selectablePayments, serializeError, services, setLineQuantity, storefrontJson, stripRedemptionLines, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, verifyWebhookSignature, visitedStates };
+export { type ApplyRedeemInput, type AuthConfigureOptions, CARD_BRANDS, type CardBrand, type CardBrandSpec, type CardCvcError, type CardExpiry, type CardExpiryError, type CardNumberError, type CardPreviewSlot, type CardholderNameError, type CreateOrderOptions, type CreateSessionOptions, type CustomizationPath, type CustomizationSession, DEFAULT_RECOMMENDATION_TYPES, type ExchangeOptions, type FailedCharge, type FlatMenuCategory, type GroupDisplayType, type IdBuilder, type ListMenusStreamOptions, type ListPaymentsOptions, type Menu, type MenuCategoryNode, type MenuLookup, type MilestoneSteps, type MilestoneTrackItem, type ModifierControlType, type ModifierCtx, type ModifierGroupCtx, type NestedMenuCategory, Order, type OrderCustomerSource, type OrderDraft, type OrderIssue, type OrderIssueCode, type OrderLineDiff, type OrderLineIssue, type OrderLineIssueCode, type OrderScope, OrderSyncPendingError, OrderValidationError, type OrderValidationResult, type PayIntentOptions, type PayIntentResult, type PayOptions, type PaymentCardBrand, type PaymentProgressEvent, type PaymentProgressListener, type PaymentRunOptions, type PaymentSessionOptions, type PricingModifier, type Product, type ProductCtx, type QuantitiesByPath, type RecommendationType, RecurringDateCron, type RemoveRedeemInput, type ReorderOrderOptions, type ResetOptions, type ReversalOutcome, type ReverseAllOptions, RulesEngine, type ScheduleWindow, type SelectionStatus, type SelectionsByPath, type SerializedError, type ServiceHttpOptions, type SimpleTenderPayment, type Snapshot, type StorefrontAccessToken, type StorefrontErrorDetails, StorefrontHttpError, type TrackWorkflow, type ValidateOptions, type ValidateOrderAgainstMenuInput, type Variant, type VariantGroup, type VariantGroupCtx, type VariantOptionCtx, type VariantSelection, type VerifyWebhookSignatureInput, type VisitedState, addLines, auth, buildCustomerSnapshot, cardBrandSpec, cardDigits, cardNumberGaps, cardNumberMaxLength, cardPreviewGroups, caretAfterDigits, clampPaymentRedeems, collectOrderLineDiffs, computeStartingPrice, countCartProducts, coveredAmount, createSession, currentNodes, cvcMaxLength, defaultConditionError, detectCardBrand, flattenMenuCategories, flushLogs, formatCardNumber, formatCvc, formatExpiry, fromOrderLines, genId, genOrderId, getLogContext, getScheduleWindow, indexMenu, isCardNumberComplete, isCardNumberDefinitelyInvalid, isCheckoutFieldFilled, isCvcComplete, isDeviceCharged, isDeviceNotLinked, isExpiryComplete, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isPosDeviceNotLinked, isPosUnauthorized, isRealPaymentMethod, isStorefrontNotFound, isVariantBase, listMenusStream, localizePosError, log, logError, luhnCheck, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, normalizeCardholderName, orderPaymentRedeems, parseExpiry, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, redemptionCap, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, selectablePayments, serializeError, services, setLineQuantity, storefrontJson, stripRedemptionLines, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, verifyWebhookSignature, visitedStates };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { DIGITAL_COLLECT_AT, PARTIAL_APPROVAL_ERROR, activeIntent, amountTolerance, createAttemptReference, createPaymentError, currencyDecimals, currentIntent, defaultReversalFor, discountRedeems, groupPaymentRedeems, isDeliveryFee, isPaymentError, isPaymentRedeem, isRealPaymentMethod, isRealPaymentMethod as isRealPaymentMethod$1, isTenderSettled, isTipFee, liveTenders, memoryPaymentStorage, missingDeviceFields, orderPaymentRedeems, orderPaymentRedeems as orderPaymentRedeems$1, paymentRedeemsCoverTotal, resolvePaymentPolicy, resolveProviderEnvironment, roundTo, scopedPaymentStorage, taxBreakdown, toChargeAmount, withTerminalLock } from "@fire-spark/payments";
+import { DIGITAL_COLLECT_AT, PARTIAL_APPROVAL_ERROR, activeIntent, amountTolerance, createAttemptReference, createPaymentError, currentIntent, defaultReversalFor, discountRedeems, groupPaymentRedeems, isDeliveryFee, isPaymentError, isPaymentRedeem, isRealPaymentMethod, isRealPaymentMethod as isRealPaymentMethod$1, isTenderSettled, isTipFee, liveTenders, memoryPaymentStorage, missingDeviceFields, money, moneyNumber, moneyZero, orderPaymentRedeems, orderPaymentRedeems as orderPaymentRedeems$1, paymentRedeemsCoverTotal, resolvePaymentPolicy, resolveProviderEnvironment, scopedPaymentStorage, taxBreakdown, toChargeAmount, withTerminalLock } from "@fire-spark/payments";
 import advancedFormat from "dayjs/plugin/advancedFormat.js";
 import isBetween from "dayjs/plugin/isBetween.js";
 import isSameOrAfter from "dayjs/plugin/isSameOrAfter.js";
@@ -3465,37 +3465,42 @@ const isDeviceCharged = (tender) => {
 /** Most a REDEMPTION can cover: order total − tip − delivery (D18). */
 const redemptionCap = (order) => {
 	const primaryOnly = order.lines.filter((line) => line.parent_uid == null).reduce((sum, line) => {
-		return isTipFee(line) || isDeliveryFee(line) ? sum + line.group_total : sum;
-	}, 0);
-	const decimals = currencyDecimals(order.totals.currency);
-	return Math.max(roundTo(order.totals.total - primaryOnly, decimals), 0);
+		if (!(isTipFee(line) || isDeliveryFee(line))) return sum;
+		return sum.plus(line.group_total);
+	}, moneyZero());
+	const cap = money(order.totals.total).minus(primaryOnly);
+	if (cap.lt(0)) return 0;
+	return moneyNumber(cap);
 };
 /**
 * Room left for order-level payment redeems: the D18 cap minus what the
 * payment redeems kept on lines already cover.
 */
 const orderRedeemCap = (order) => {
-	const used = orderPaymentRedeems({ lines: order.lines }).reduce((sum, item) => sum + (item.amount ?? 0), 0);
-	const decimals = currencyDecimals(order.totals.currency);
-	return Math.max(roundTo(redemptionCap(order) - used, decimals), 0);
+	const used = orderPaymentRedeems({ lines: order.lines }).reduce((sum, item) => {
+		return sum.plus(item.amount ?? 0);
+	}, moneyZero());
+	const left = money(redemptionCap(order)).minus(used);
+	if (left.lt(0)) return 0;
+	return moneyNumber(left);
 };
 /**
 * Trims payment redeems in application order so their sum fits the cap.
-* Discount redeems are left untouched.
+* Discount redeems are left untouched. The last trimmed amount is whatever
+* room remains, so the kept amounts sum to at most `cap`.
 */
-const clampPaymentRedeems = (redeem, cap, currency) => {
-	const decimals = currencyDecimals(currency);
-	let left = cap;
+const clampPaymentRedeems = (redeem, cap, _currency) => {
+	let left = money(cap);
 	return redeem.flatMap((item) => {
 		if (!isPaymentRedeem(item)) return [item];
-		const amount = item.amount ?? 0;
-		const fits = Math.max(roundTo(Math.min(amount, left), decimals), 0);
-		left = roundTo(left - fits, decimals);
-		if (fits <= 0) return [];
-		if (fits + amountTolerance(currency) >= amount) return [item];
+		const amount = money(item.amount ?? 0);
+		const fits = amount.lt(left) ? amount : left;
+		left = left.minus(fits);
+		if (fits.lte(0)) return [];
+		if (fits.eq(amount)) return [item];
 		return [{
 			...item,
-			amount: fits
+			amount: moneyNumber(fits)
 		}];
 	});
 };
@@ -3884,14 +3889,15 @@ const chargedTenders = (intents) => {
 };
 /** Settled tenders plus PENDING `confirm_after_inject`, order currency. */
 const coveredAmount = (intents) => {
-	return chargedTenders(intents).reduce((sum, tender) => {
-		return sum + tender.amount.total;
-	}, 0);
+	return moneyNumber(chargedTenders(intents).reduce((sum, tender) => {
+		return sum.plus(tender.amount.total);
+	}, moneyZero()));
 };
 const remainingAmount = (order) => {
-	const decimals = currencyDecimals(order.totals.currency);
-	const left = order.totals.total - coveredAmount(order.payment_intents);
-	return Math.max(roundTo(left, decimals), 0);
+	const covered = money(coveredAmount(order.payment_intents));
+	const left = money(order.totals.total).minus(covered);
+	if (left.lt(0)) return 0;
+	return moneyNumber(left);
 };
 const isPlaced = (order) => order.status !== "OPEN";
 /** Orchestrator failures carry the charge-currency amount, not the order's. */
@@ -4021,12 +4027,9 @@ var PaymentSession = class {
 		const conversion = await this.chargeAmount(payment, amount, server);
 		const config = record(payment.config);
 		const methodConfig = record(payment.method.config);
-		const share = order.totals.total > 0 ? amount / order.totals.total : 1;
-		const decimals = currencyDecimals(order.totals.currency);
-		const taxes = taxBreakdown(order.lines, {
-			share,
-			decimals
-		});
+		const total = order.totals.total;
+		const share = moneyNumber(total > 0 ? money(amount).div(total) : money(1));
+		const taxes = taxBreakdown(order.lines, { share });
 		const info = order.customer.customer_info;
 		const customer = {
 			document: info.document_number ?? null,
@@ -6959,391 +6962,8 @@ const verifyWebhookSignature = async (input) => {
 	return safeEqual(received, await hmacHex(secret, body));
 };
 //#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);
-};
-const paymentIsMixed = (condition, isMixed) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Payment is mixed";
-	assert(primitive === "boolean", primitiveError("boolean"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchBooleanOperator(condition, isMixed ?? false);
-};
-const paymentCaptured = (condition, captured) => {
-	const { type, primitive, value } = condition;
-	const matcherType = "Payment captured";
-	assert(primitive === "boolean", primitiveError("boolean"));
-	assert(type === matcherType, typeError(matcherType));
-	assert(value != null, "Invalid value");
-	return matchBooleanOperator(condition, captured ?? 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_OPERATORS = [
-	"is any of",
-	"is none of",
-	"is all of"
-];
-const isMultiOperator = (operator) => {
-	return MULTI_OPERATORS.includes(operator);
-};
-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 = typeof matcher === "object" ? matcher : [matcher];
-	if (candidates.length === 0) return false;
-	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`);
-};
-/**
-* The operator picks the arity: `Payment` is single-select in order rules and
-* multi-select in fulfillment workflows. `matcher` may be a set (one id per
-* tender): `is` matches when some id matches, `is not` when none does.
-*/
-const matchCustom = (condition, matcher) => {
-	if (isMultiOperator(condition.operator)) return matchCustomMulti(condition, matcher);
-	if (typeof matcher === "undefined" || typeof matcher === "string") return matchCustomEquality(condition, matcher);
-	if (matcher.length === 0) return false;
-	const matches = (id) => matchCustomEquality(condition, id);
-	if (condition.operator === "is not") return matcher.every(matches);
-	return matcher.some(matches);
-};
-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 NEGATIVE_ENUM_OPERATORS = ["is not", "is none of"];
-/**
-* Enum condition over a set (one value per tender): positive operators
-* match when some value matches, negative ones when none matches.
-*/
-const matchEnumSet = (condition, matcher) => {
-	if (typeof matcher === "undefined" || typeof matcher === "string") return matchEnumOperator(condition, matcher);
-	if (matcher.length === 0) return false;
-	const matches = (value) => matchEnumOperator(condition, value);
-	if (NEGATIVE_ENUM_OPERATORS.includes(condition.operator)) return matcher.every(matches);
-	return matcher.some(matches);
-};
-const paymentCollectAt = (condition, collectAt) => {
-	const matcherType = "Payment collect at";
-	assert(condition.primitive === "enum", primitiveError("enum"));
-	assert(condition.type === matcherType, typeError(matcherType));
-	return matchEnumSet(condition, collectAt);
-};
-const paymentMethod = (condition, method) => {
-	const matcherType = "Payment method";
-	assert(condition.primitive === "enum", primitiveError("enum"));
-	assert(condition.type === matcherType, typeError(matcherType));
-	return matchEnumSet(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) => {
+//#region ../../node_modules/.pnpm/dayjs@1.11.9/node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = /* @__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() {
@@ -7638,7 +7258,412 @@ var import_dayjs_min = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((
 			return w(1e3 * t);
 		}, w.en = D[g], w.Ls = D, w.p = {}, w;
 	}));
-})))(), 1);
+}));
+//#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/absoluteDateMatcher.ts
+var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
+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/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);
+};
+const paymentIsMixed = (condition, isMixed) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Payment is mixed";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, isMixed ?? false);
+};
+const paymentCaptured = (condition, captured) => {
+	const { type, primitive, value } = condition;
+	const matcherType = "Payment captured";
+	assert(primitive === "boolean", primitiveError("boolean"));
+	assert(type === matcherType, typeError(matcherType));
+	assert(value != null, "Invalid value");
+	return matchBooleanOperator(condition, captured ?? 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_OPERATORS = [
+	"is any of",
+	"is none of",
+	"is all of"
+];
+const isMultiOperator = (operator) => {
+	return MULTI_OPERATORS.includes(operator);
+};
+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 = typeof matcher === "object" ? matcher : [matcher];
+	if (candidates.length === 0) return false;
+	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`);
+};
+/**
+* The operator picks the arity: `Payment` is single-select in order rules and
+* multi-select in fulfillment workflows. `matcher` may be a set (one id per
+* tender): `is` matches when some id matches, `is not` when none does.
+*/
+const matchCustom = (condition, matcher) => {
+	if (isMultiOperator(condition.operator)) return matchCustomMulti(condition, matcher);
+	if (typeof matcher === "undefined" || typeof matcher === "string") return matchCustomEquality(condition, matcher);
+	if (matcher.length === 0) return false;
+	const matches = (id) => matchCustomEquality(condition, id);
+	if (condition.operator === "is not") return matcher.every(matches);
+	return matcher.some(matches);
+};
+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 NEGATIVE_ENUM_OPERATORS = ["is not", "is none of"];
+/**
+* Enum condition over a set (one value per tender): positive operators
+* match when some value matches, negative ones when none matches.
+*/
+const matchEnumSet = (condition, matcher) => {
+	if (typeof matcher === "undefined" || typeof matcher === "string") return matchEnumOperator(condition, matcher);
+	if (matcher.length === 0) return false;
+	const matches = (value) => matchEnumOperator(condition, value);
+	if (NEGATIVE_ENUM_OPERATORS.includes(condition.operator)) return matcher.every(matches);
+	return matcher.some(matches);
+};
+const paymentCollectAt = (condition, collectAt) => {
+	const matcherType = "Payment collect at";
+	assert(condition.primitive === "enum", primitiveError("enum"));
+	assert(condition.type === matcherType, typeError(matcherType));
+	return matchEnumSet(condition, collectAt);
+};
+const paymentMethod = (condition, method) => {
+	const matcherType = "Payment method";
+	assert(condition.primitive === "enum", primitiveError("enum"));
+	assert(condition.type === matcherType, typeError(matcherType));
+	return matchEnumSet(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
 import_dayjs_min.default.extend(utc);
 import_dayjs_min.default.extend(timezone);
 import_dayjs_min.default.extend(isBetween);
@@ -7835,6 +7860,47 @@ const currentDate = (condition, referenceDate) => {
 	return matchRecurringDateOperator(condition, current);
 };
 //#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/RulesEngine.ts
 var RulesEngine = class {
 	order;
@@ -7932,6 +7998,7 @@ var RulesEngine = class {
 			const monitoring = this.getDependency("monitoring", type);
 			return httpStatus(condition, monitoring.http_status);
 		}
+		if (type === "Customer age") return matchNumberOperator(condition, this.customerAge());
 		throw new Error(`Condition ${type} not supported in number matcher`);
 	};
 	assertBoolean = (condition) => {
@@ -7989,17 +8056,40 @@ var RulesEngine = class {
 			default: throw new Error(`Condition ${type} not supported in enum matcher`);
 		}
 	};
+	customerAge = () => {
+		const dob = this.customer?.dob;
+		if (!dob) return void 0;
+		const born = new Date(dob);
+		const now = new Date(this.referenceDate ?? Date.now());
+		if (Number.isNaN(born.getTime()) || Number.isNaN(now.getTime())) return;
+		let age = now.getUTCFullYear() - born.getUTCFullYear();
+		const month = now.getUTCMonth() - born.getUTCMonth();
+		const beforeBirthday = now.getUTCDate() < born.getUTCDate();
+		if (month < 0 || month === 0 && beforeBirthday) age -= 1;
+		return age;
+	};
+	customerDate = (type) => {
+		const customer = this.customer;
+		if (type === "Birthday") return customer?.dob;
+		if (type === "Registration") return customer?.registered_at;
+		if (type === "Customer last visit") return customer?.last_visit_at;
+		if (type === "Customer last session") return customer?.last_session_at;
+	};
 	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);
+		if (type !== "Today") {
+			const msg = `Condition ${type} not supported in absolute date matcher`;
+			throw new Error(msg);
+		}
+		const today = this.referenceDate ?? (/* @__PURE__ */ new Date()).toISOString();
+		return matchAbsoluteDateOperator(condition, today);
 	};
 	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);
+		const fact = this.customerDate(type);
+		return matchRelativeDateOperator(condition, fact, this.referenceDate);
 	};
 	assertRecurringDate = (condition) => {
 		const { primitive, type } = condition;
@@ -8104,66 +8194,6 @@ var RulesEngine = class {
 	};
 };
 //#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",
@@ -8616,4 +8646,4 @@ const cardPreviewGroups = (value) => {
 	return groups;
 };
 //#endregion
-export { CARD_BRANDS, DEFAULT_RECOMMENDATION_TYPES, Order, OrderSyncPendingError, OrderValidationError, RecurringDateCron, RulesEngine, StorefrontHttpError, addLines, auth, buildCustomerSnapshot, cardBrandSpec, cardDigits, cardNumberGaps, cardNumberMaxLength, cardPreviewGroups, caretAfterDigits, collectOrderLineDiffs, computeStartingPrice, countCartProducts, coveredAmount, createSession, currentNodes, cvcMaxLength, defaultConditionError, detectCardBrand, flattenMenuCategories, flushLogs, formatCardNumber, formatCvc, formatExpiry, fromOrderLines, genId, genOrderId, getLogContext, getScheduleWindow, indexMenu, isCardNumberComplete, isCardNumberDefinitelyInvalid, isCheckoutFieldFilled, isCvcComplete, isDeviceCharged, isDeviceNotLinked, isExpiryComplete, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isPosDeviceNotLinked, isPosUnauthorized, isRealPaymentMethod, isStorefrontNotFound, isVariantBase, listMenusStream, localizePosError, log, logError, luhnCheck, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, normalizeCardholderName, orderPaymentRedeems, parseExpiry, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, redemptionCap, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, selectablePayments, serializeError, services, setLineQuantity, storefrontJson, stripRedemptionLines, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, verifyWebhookSignature, visitedStates };
+export { CARD_BRANDS, DEFAULT_RECOMMENDATION_TYPES, Order, OrderSyncPendingError, OrderValidationError, RecurringDateCron, RulesEngine, StorefrontHttpError, addLines, auth, buildCustomerSnapshot, cardBrandSpec, cardDigits, cardNumberGaps, cardNumberMaxLength, cardPreviewGroups, caretAfterDigits, clampPaymentRedeems, collectOrderLineDiffs, computeStartingPrice, countCartProducts, coveredAmount, createSession, currentNodes, cvcMaxLength, defaultConditionError, detectCardBrand, flattenMenuCategories, flushLogs, formatCardNumber, formatCvc, formatExpiry, fromOrderLines, genId, genOrderId, getLogContext, getScheduleWindow, indexMenu, isCardNumberComplete, isCardNumberDefinitelyInvalid, isCheckoutFieldFilled, isCvcComplete, isDeviceCharged, isDeviceNotLinked, isExpiryComplete, isKioskUnauthorized, isMilestoneStepDone, isOnSchedule, isOrderValidationError, isPosDeviceNotLinked, isPosUnauthorized, isRealPaymentMethod, isStorefrontNotFound, isVariantBase, listMenusStream, localizePosError, log, logError, luhnCheck, matchAbsoluteDateOperator, matchBooleanOperator, matchCurrencyOperator, matchEnumOperator, matchNumberOperator, matchRecurringDateOperator, matchRelativeDateOperator, matchStringOperator, milestoneSteps, milestoneTrack, nestMenuCategories, normalizeCardholderName, orderPaymentRedeems, parseExpiry, paymentMatchesClientConditions, recomputeRedemptions, recomputeTotals, redemptionCap, remainingAmount, removeLine, replaceLine, resolveCheckout, reversePayment, runPaymentAttempt, selectablePayments, serializeError, services, setLineQuantity, storefrontJson, stripRedemptionLines, toOrderLines, toPaymentCardBrand, validateCardNumber, validateCardholderName, validateCvc, validateExpiry, validateOrderAgainstMenu, verifyWebhookSignature, visitedStates };

package/package.json

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