@wix/himalaya-cli 0.1632.0 → 0.1634.0

package/templates/branded-lite/tier5-src/himi-branded-lite-loyalty/earning.ts

@@ -0,0 +1,148 @@
+import { getMyMember, updateMember } from "@himalaya/wix-members";
+import { listMyLoyaltyFollowedChannels, followMyLoyaltyChannel, type WixLoyaltyProgram, type WixLoyaltyEarningRule } from "@himalaya/wix-loyalty";
+import { open } from "@himalaya/open-url";
+import { navigate } from "@himalaya/state";
+import { memberAccess, assertMemberAccess, type MemberAccess } from "../_shared/member-access.js";
+import { copyParam } from "../_shared/himi-copy.js";
+
+export interface SocialRow { id: string; name: string; label: string; followed: boolean }
+export interface EarningState {
+  hideBirthday: boolean; birthdayLabel: string; birthdayDraft: number; birthdayPicked: boolean; birthdayOpen: boolean;
+  socialChannels: SocialRow[]; earnBusy: boolean; earnMessage: string;
+}
+export const EARNING_EMPTY: EarningState = { hideBirthday: true, birthdayLabel: "", birthdayDraft: 0, birthdayPicked: false, birthdayOpen: false, socialChannels: [], earnBusy: false, earnMessage: "" };
+const business = () => (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input?.__himiPreferenceBusiness;
+const obj = (v: unknown): Record<string, unknown> => v && typeof v === "object" ? v as Record<string, unknown> : {};
+const HOSTS: Record<string, string> = { FACEBOOK: "facebook.com", INSTAGRAM: "instagram.com", LINKEDIN: "linkedin.com", TIKTOK: "tiktok.com", X: "x.com" };
+/** Engine-safe URL check; never hand a program-supplied scheme or credentials to open_url. */
+export function validSocialUrl(type: string, url: string): boolean {
+  const host = /^https:\/\/([^/?#]+)(?:[/?#]|$)/i.exec(url)?.[1]?.toLowerCase();
+  return !!host && !!HOSTS[type] && (host === HOSTS[type] || host === `www.${HOSTS[type]}` || host === `m.${HOSTS[type]}`);
+}
+export function birthdayRule(rule: WixLoyaltyEarningRule): boolean {
+  return rule.status === "ACTIVE" && rule.triggerActivityType === "segments-contact_enters_segment" && rule.metadata?.ruleTypeTag?.ruleType === "BIRTHDAY";
+}
+export function birthdateAt(value: number): string | undefined {
+  if (!Number.isFinite(value)) return undefined;
+  const date = new Date(value * 1000), today = new Date();
+  if (!Number.isFinite(date.getTime()) || date.getFullYear() < 1900 || date > today) return undefined;
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+
+// Private controller state never hydrates. Every network completion rechecks the
+// authenticated member AND business before publishing, including background writes.
+export function createEarningController<S extends EarningState>(publish: () => Promise<unknown>) {
+  let revision = 0, busy = false;
+  let context: { member: MemberAccess; site: unknown; id: string; birthday: boolean; date: string; channels: { type: string; url: string; followed: boolean }[] } | undefined;
+  let outcome: { version: number; message: string; date?: string } | undefined;
+  const check = async (c: NonNullable<typeof context>) => {
+    await assertMemberAccess(c.member);
+    if (business() !== c.site || context !== c) throw new Error("Member access changed");
+  };
+  const view = (): EarningState => ({ ...EARNING_EMPTY, earnBusy: busy, hideBirthday: !context?.birthday || (!!context.member.email && !context.id),
+    birthdayLabel: copyParam(context?.date ? "loyalty.editBirthday" : "loyalty.addBirthday", context?.date ? "Edit birthday" : "Add birthday"),
+    socialChannels: context?.channels.map(c => ({ id: c.type, name: c.type, followed: c.followed,
+      label: copyParam(c.followed ? "loyalty.followed" : "loyalty.follow", c.followed ? "Followed" : "Follow") })) ?? [] });
+  const signIn = (s: S) => navigate(s, { screenId: "himi_sign_in", args: { returnTo: "himi_loyalty" } });
+  async function write(c: NonNullable<typeof context>, version: number, task: () => Promise<string | undefined>) {
+    let message = copyParam("loyalty.earnSaved", "Saved. Your points will update when the earning rule runs."), date: string | undefined;
+    try { await check(c); date = await task(); await check(c); }
+    catch { message = copyParam("loyalty.earnFailed", "Couldn't confirm this change. Refresh before trying again."); }
+    finally { busy = false; }
+    if (context !== c || version !== revision) { await publish(); return; }
+    try { await check(c); outcome = { version, message, date }; await publish(); }
+    catch { outcome = undefined; await publish(); }
+  }
+  return {
+    clear() { revision++; context = undefined; outcome = undefined; },
+    async load(member: MemberAccess, program: WixLoyaltyProgram, rules: WixLoyaltyEarningRule[]): Promise<EarningState> {
+      const version = ++revision;
+      const birthday = rules.some(birthdayRule);
+      const channels = rules.some(r => r.status === "ACTIVE" && r.triggerActivityType === "wix_loyalty-social_media_channel_followed")
+        ? (program.socialMediaSettings?.channels ?? []).filter(c => c.enabled === true && validSocialUrl(c.type ?? "", c.url ?? ""))
+          .map(c => ({ type: c.type!, url: c.url!, followed: false })) : [];
+      const c = { member, site: business(), id: "", birthday, date: "", channels };
+      context = c; outcome = undefined;
+      if (!member.email || (!birthday && !channels.length)) return view();
+      try {
+        const [profile, followed] = await Promise.allSettled([
+          birthday ? getMyMember({ fieldsets: ["FULL"] }) : Promise.resolve(undefined),
+          channels.length ? listMyLoyaltyFollowedChannels() : Promise.resolve(undefined),
+        ]);
+        await check(c);
+        if (version !== revision) return { ...EARNING_EMPTY };
+        let failed = false;
+        if (birthday) {
+          if (profile.status === "fulfilled" && profile.value?.member?.id) {
+            c.id = profile.value.member.id;
+            c.date = profile.value.member.contact?.birthdate ?? "";
+          } else { c.id = ""; failed = true; }
+        }
+        if (channels.length) {
+          const rows = followed.status === "fulfilled" ? followed.value?.followedChannels : undefined;
+          if (followed.status === "fulfilled" && (rows === undefined || Array.isArray(rows))) {
+            const known = new Set(rows?.map(row => row.channel));
+            c.channels = channels.map(channel => ({ ...channel, followed: known.has(channel.type) }));
+          } else { c.channels = []; failed = true; }
+        }
+        return { ...view(), earnMessage: failed ? copyParam("loyalty.earnLoadError", "Your earning actions couldn't be loaded. Refresh to try again.") : "" };
+      } catch {
+        if (context !== c || version !== revision) return { ...EARNING_EMPTY };
+        // A failed private read must not pretend the member has never followed.
+        c.channels = []; c.id = "";
+        return { ...view(), earnMessage: copyParam("loyalty.earnLoadError", "Your earning actions couldn't be loaded. Refresh to try again.") };
+      }
+    },
+    async openBirthday(s: S): Promise<S> {
+      if (!(await memberAccess()).email) return signIn(s);
+      const c = context;
+      if (!c?.birthday || !c.id || busy) return s;
+      await check(c);
+      const parsed = c.date ? new Date(`${c.date}T12:00:00`).getTime() / 1000 : Date.now() / 1000;
+      return { ...s, birthdayOpen: true, birthdayPicked: false, birthdayDraft: Number.isFinite(parsed) ? parsed : 0, earnMessage: "" };
+    },
+    draftBirthday(s: S, arg: unknown): S { const value = Number(obj(arg).value); return busy || !birthdateAt(value) ? s : { ...s, birthdayDraft: value, birthdayPicked: true }; },
+    closeBirthday(s: S): S { return busy ? s : { ...s, birthdayOpen: false }; },
+    saveBirthday(s: S): S {
+      const c = context, date = birthdateAt(s.birthdayDraft);
+      if (busy || !s.birthdayOpen || !c?.id || !c.birthday) return s;
+      if (!date || !s.birthdayPicked) return { ...s, earnMessage: copyParam("loyalty.birthdayInvalid", "Choose a birthday in the past.") };
+      busy = true;
+      void write(c, revision, async () => {
+        const result = await updateMember(c.id, { member: { contact: { birthdate: date } } });
+        if (result.member?.contact?.birthdate !== date) throw new Error("Birthday update was not confirmed");
+        return date;
+      });
+      return { ...s, earnBusy: true, earnMessage: copyParam("loyalty.saving", "Saving…") };
+    },
+    async followChannel(s: S, arg: unknown): Promise<S> {
+      if (!(await memberAccess()).email) return signIn(s);
+      const c = context, channel = c?.channels.find(row => row.type === obj(arg).id);
+      if (!c || !channel || busy) return s;
+      await check(c);
+      if (busy) return s;
+      busy = true;
+      void write(c, revision, async () => {
+        if (!channel.followed) {
+          const result = await followMyLoyaltyChannel(channel.type);
+          if (result.followedChannel?.channel !== channel.type) throw new Error("Follow was not confirmed");
+          await check(c); channel.followed = true;
+        }
+        const opened = await open(channel.url);
+        if (!opened.opened) throw new Error("Could not open channel");
+        return undefined;
+      });
+      return { ...s, earnBusy: true, earnMessage: copyParam("loyalty.saving", "Saving…") };
+    },
+    async finishEarning(s: S): Promise<S> {
+      if (context) {
+        try { await check(context); }
+        catch { context = undefined; outcome = undefined; return { ...s, ...EARNING_EMPTY }; }
+      }
+      if (!outcome || outcome.version !== revision || !context) return { ...s, earnBusy: busy };
+      if (outcome.date) context.date = outcome.date;
+      const message = outcome.message; outcome = undefined;
+      return { ...s, ...view(), earnMessage: message };
+    },
+  };
+}

package/templates/branded-lite/tier5-src/himi-branded-lite-loyalty/index.ts

@@ -9,13 +9,20 @@ import { calendarDay, formatCurrency, formatDateMedium, formatNumber } from "../
 import { appLocale, isSingular } from "../_shared/app-locale.js";
 import { memberAccess, assertMemberAccess } from "../_shared/member-access.js";
 import {
-  getLoyaltyProgram, listLoyaltyRewards, listLoyaltyEarningRules, getCurrentMemberLoyaltyAccount, getLoyaltyTiersProgram, listMyLoyaltyCoupons,
+  getLoyaltyProgram, listLoyaltyRewards, listLoyaltyEarningRules, getCurrentMemberLoyaltyAccount, getLoyaltyTiersProgram, listMyLoyaltyCoupons, listMyReferralRewards,
   type WixLoyaltyReward, type WixLoyaltyEarningRule, type WixLoyaltyProgram, type WixLoyaltyAccount, type WixLoyaltyTiersProgram,
-  type WixLoyaltyCoupon, type WixLoyaltyRewardConfig,
+  type WixLoyaltyCoupon, type WixReferralReward,
 } from "@himalaya/wix-loyalty";
 
+import { buildOfferings, visibleOfferings, offeringRewardLabel, memberRewardCost, OFFERING_TIER_LIMIT, type OfferingGroup } from "../_shared/loyalty-offerings.js";
+
+import { createEarningController, EARNING_EMPTY, type EarningState } from "./earning.js";
+import { withOnlineWrites } from "../_shared/online-actions.js";
+
 interface Row { id: string; name: string; subtitle: string }
-interface S extends LoadFlags {
+interface S extends LoadFlags, EarningState {
+  offeringGroups: OfferingGroup[]; offeringsExpanded: boolean;
+  hideTierOfferings: boolean; hideBaseOffering: boolean; hideShowAllTiers: boolean; tierError: string;
   programName: string; unit: string; currency: string;
   rewards: Row[]; earningRules: Row[]; emptyText: string; earningEmptyText: string;
   hideCatalog: boolean; hideEarningHeading: boolean; inactiveText: string;
@@ -29,12 +36,13 @@ interface S extends LoadFlags {
   /** "Rewards available (N)"; hidden when N is 0 or cannot be counted honestly. */
   memberRewards: string; hideMemberRewards: boolean;
 }
-const PRIVATE_EMPTY = {
+const PRIVATE_EMPTY = { ...EARNING_EMPTY,
   memberPoints: "", memberMessage: "", hideMemberCard: true, hideMemberSignIn: true, hideMemberRetry: true,
   memberTier: "", memberExpiry: "", memberExpiryUrgent: "", memberRewards: "", hideMemberRewards: true,
 };
 const PRIVATE_KEYS = Object.keys(PRIVATE_EMPTY) as (keyof typeof PRIVATE_EMPTY)[];
-const INITIAL: S = { ...LOADING, ...PRIVATE_EMPTY, programName: "", unit: "", currency: "", rewards: [], earningRules: [], emptyText: "", earningEmptyText: "", hideCatalog: false, hideEarningHeading: true, inactiveText: "", rewardError: "", earningError: "", hideRewardError: true, hideEarningError: true, hideRewardRows: false };
+const OFFERING_EMPTY = { offeringGroups: [] as OfferingGroup[], offeringsExpanded: false, hideTierOfferings: true, hideBaseOffering: false, hideShowAllTiers: true, tierError: "" };
+const INITIAL: S = { ...OFFERING_EMPTY, ...LOADING, ...PRIVATE_EMPTY, programName: "", unit: "", currency: "", rewards: [], earningRules: [], emptyText: "", earningEmptyText: "", hideCatalog: false, hideEarningHeading: true, inactiveText: "", rewardError: "", earningError: "", hideRewardError: true, hideEarningError: true, hideRewardRows: false };
 
 function amount(value: unknown): value is number { return typeof value === "number" && Number.isFinite(value) && value >= 0; }
 function baseConfig<T extends { tierId?: string }>(configs: T[] | undefined): T | undefined {
@@ -73,22 +81,13 @@ function currencyFrom(s: S, arg: unknown): string {
   const raw = (arg as { currency?: unknown }).currency;
   return typeof raw === "string" && /^[A-Z]{3}$/.test(raw) ? raw : "";
 }
-/** What `reward` costs a member on `tierId` (undefined = the base tier): its row for that tier,
- *  else the base row, else the legacy flat `requiredPoints`. Undefined when nothing prices it. */
-function memberCost(reward: WixLoyaltyReward, tierId: string | undefined): number | undefined {
-  const configs: WixLoyaltyRewardConfig[] | undefined = reward.discountAmount?.configsByTier ?? reward.couponReward?.fixedAmount?.configsByTier
-    ?? reward.couponReward?.percentage?.configsByTier ?? reward.couponReward?.freeShipping?.configsByTier;
-  if (!configs?.length) return amount(reward.requiredPoints) ? reward.requiredPoints : undefined;
-  const row = (tierId ? configs.find(config => config.tierId === tierId) : undefined) ?? baseConfig(configs);
-  return amount(row?.costInPoints) ? row.costInPoints : undefined;
-}
 /** The one-app `calculateAvailableRewardsToClaim`: active rewards the balance covers on the
  *  member's tier (an SPI discount prices itself in text, not points, so it is left out), plus
  *  claimed coupons that are still ACTIVE and not deleted. */
 export function countAvailableRewards(rewards: WixLoyaltyReward[], coupons: WixLoyaltyCoupon[], balance: number, tierId: string | undefined): number {
   const claimable = rewards.filter(reward => {
     if (reward.active !== true || reward.type === "SPI_DISCOUNT_AMOUNT") return false;
-    const cost = memberCost(reward, tierId);
+    const cost = memberRewardCost(reward, tierId);
     return cost !== undefined && cost <= balance;
   }).length;
   return claimable + coupons.filter(coupon => coupon.status === "ACTIVE" && !coupon.couponReference?.deleted).length;
@@ -128,11 +127,12 @@ const settle = <T>(read: Promise<T>): Promise<Settled<T>> => read.then(value =>
 /** The status lines for a member whose balance is known. A failed tiers read only drops the tier;
  *  a failed coupon or rewards read drops the count, because a partial total would understate it. */
 function statusLines(program: WixLoyaltyProgram, account: WixLoyaltyAccount, balance: number, tiers: Settled<WixLoyaltyTiersProgram>,
-  coupons: Settled<{ loyaltyCoupons?: WixLoyaltyCoupon[] }>, rewards: WixLoyaltyReward[] | undefined) {
+  coupons: Settled<{ loyaltyCoupons?: WixLoyaltyCoupon[] }>, referrals: Settled<{ referralRewards: WixReferralReward[] }>, rewards: WixLoyaltyReward[] | undefined) {
   const tierId = account.tier?.id || undefined;
   const tier = tiers.failed ? "" : currentTierName(tiers.value, tierId);
   const [expiry, urgent] = expirySentence(program, account);
-  const count = coupons.failed || !rewards ? 0 : countAvailableRewards(rewards, coupons.value?.loyaltyCoupons ?? [], balance, tierId);
+  const referralCount = referrals.value?.referralRewards.filter(r => r.rewardType === "COUPON" && r.coupon?.status === "ACTIVE").length ?? 0;
+  const count = coupons.failed || referrals.failed || !rewards ? 0 : countAvailableRewards(rewards, coupons.value?.loyaltyCoupons ?? [], balance, tierId) + referralCount;
   return {
     memberTier: tier ? copyTemplate("loyalty.memberTier", "{tier} tier", { tier }) : "",
     memberExpiry: urgent ? "" : expiry, memberExpiryUrgent: urgent ? expiry : "",
@@ -145,13 +145,26 @@ const COPY: LoadCopy<Row> = {
   sample: () => [{ id: "sample-reward", name: copyParam("loyalty.sampleReward", "5% off your next order"), subtitle: points(500, "") }],
 };
 
-const svc = defineService<S, { prepare: (s: S) => S; load: (s: S, arg?: unknown) => Promise<S> }>("himiBrandedLoyalty", {
+let loadRevision = 0;
+let allOfferings: OfferingGroup[] = [];
+const earning: ReturnType<typeof createEarningController<S>> = createEarningController<S>((): Promise<unknown> => svc.finishEarning());
+const register = withOnlineWrites(defineService, ["saveBirthday", "followChannel"], { messageFields: ["earnMessage"] });
+const svc = register<S, { prepare: (s: S) => S; load: (s: S, arg?: unknown) => Promise<S>; showAllTiers: (s: S) => S;
+  openBirthday: (s: S) => Promise<S>; draftBirthday: (s: S, arg?: unknown) => S; closeBirthday: (s: S) => S;
+  saveBirthday: (s: S) => S; followChannel: (s: S, arg?: unknown) => Promise<S>; finishEarning: (s: S) => Promise<S>;
+}>("himiBrandedLoyalty", {
   state: INITIAL,
   notHydrated: PRIVATE_KEYS,
   notPersisted: PRIVATE_KEYS,
   actions: {
-    prepare: s => ({ ...s, ...PRIVATE_EMPTY }),
+    showAllTiers: s => allOfferings.length ? ({ ...s, offeringsExpanded: true, offeringGroups: allOfferings, hideShowAllTiers: true }) : s,
+    openBirthday: s => earning.openBirthday(s), draftBirthday: (s, arg) => earning.draftBirthday(s, arg),
+    closeBirthday: s => earning.closeBirthday(s), saveBirthday: s => earning.saveBirthday(s),
+    followChannel: (s, arg) => earning.followChannel(s, arg), finishEarning: s => earning.finishEarning(s),
+    prepare: s => { loadRevision++; allOfferings = []; earning.clear(); return { ...s, ...PRIVATE_EMPTY }; },
     load: async (s, arg) => {
+      const revision = ++loadRevision;
+      earning.clear(); allOfferings = [];
       const currency = currencyFrom(s, arg);
       const business = businessStamp();
       try {
@@ -159,8 +172,8 @@ const svc = defineService<S, { prepare: (s: S) => S; load: (s: S, arg?: unknown)
         const program = response.loyaltyProgram ?? response.program;
         if (!program || !["ACTIVE", "DRAFT", "PAUSED"].includes(program.status ?? "")) throw new Error("Loyalty program response is unavailable");
         const customUnit = (program.pointDefinition?.customName ?? "").trim();
-        const common = { ...s, ...PRIVATE_EMPTY, currency, programName: program.name || copyParam("loyalty.programFallback", "Rewards"), unit: customUnit || copyParam("loyalty.pointMany", "points"), inactiveText: "", rewardError: "", earningError: "", hideRewardError: true, hideEarningError: true, hideRewardRows: true, hideEarningHeading: true };
-        if (program.status !== "ACTIVE") {
+        const common = { ...s, ...PRIVATE_EMPTY, ...OFFERING_EMPTY, currency, programName: program.name || copyParam("loyalty.programFallback", "Rewards"), unit: customUnit || copyParam("loyalty.pointMany", "points"), inactiveText: "", rewardError: "", earningError: "", hideRewardError: true, hideEarningError: true, hideRewardRows: true, hideEarningHeading: true };
+        if (program.status !== "ACTIVE" || program.premiumFeatures?.loyaltyProgram === false) {
           return { ...common, ...loaded("rewards", [], COPY), earningRules: [], earningEmptyText: "", hideCatalog: true,
             inactiveText: copyParam("loyalty.inactive", "The rewards program isn't available right now.") };
         }
@@ -169,23 +182,36 @@ const svc = defineService<S, { prepare: (s: S) => S; load: (s: S, arg?: unknown)
         const accountRead = member.email && privateStateSupported
           ? settle(getCurrentMemberLoyaltyAccount())
           : Promise.resolve({ value: undefined, failed: false });
-        // The status lines' reads go only where the balance read goes: never for a visitor or an older host.
-        const statusRead = member.email && privateStateSupported
-          ? Promise.all([settle(getLoyaltyTiersProgram()), settle(listMyLoyaltyCoupons())])
-          : Promise.resolve([{ failed: true }, { failed: true }] as [Settled<WixLoyaltyTiersProgram>, Settled<{ loyaltyCoupons?: WixLoyaltyCoupon[] }>]);
-        const [[rewardResult, earningResult], account, [tiers, coupons]] = await Promise.all([
-          Promise.allSettled([listLoyaltyRewards(), listLoyaltyEarningRules()]), accountRead, statusRead,
+        // Public tier metadata is shared by the visitor offering and the member status.
+        // Coupons and account details remain member-only.
+        const tiersRead = settle(getLoyaltyTiersProgram());
+        const couponsRead = member.email && privateStateSupported ? settle(listMyLoyaltyCoupons())
+          : Promise.resolve({ failed: true } as Settled<{ loyaltyCoupons?: WixLoyaltyCoupon[] }>);
+        const referralsRead = member.email && privateStateSupported ? settle(listMyReferralRewards())
+          : Promise.resolve({ failed: true } as Settled<{ referralRewards: WixReferralReward[] }>);
+        const [[rewardResult, earningResult], account, tiers, coupons, referrals] = await Promise.all([
+          Promise.allSettled([listLoyaltyRewards(), listLoyaltyEarningRules()]), accountRead, tiersRead, couponsRead, referralsRead,
         ]);
         const rewardResponse = rewardResult.status === "fulfilled" ? rewardResult.value : undefined;
         const earningResponse = earningResult.status === "fulfilled" ? earningResult.value : undefined;
         if (businessStamp() !== business) throw new Error("Business changed while Loyalty loaded");
         if (rewardResult.status === "rejected" && earningResult.status === "rejected") throw new Error("Loyalty catalog is unavailable");
         const rewards = (rewardResponse?.rewards ?? []).filter(reward => reward.active === true).map((reward, i) => ({
-          id: reward.id || `reward-${i}`, name: reward.name || copyParam("loyalty.rewardFallback", "Reward"), subtitle: rewardLabel(reward, customUnit),
+          id: reward.id || `reward-${i}`, name: reward.name || copyParam("loyalty.rewardFallback", "Reward"), subtitle: reward.type === "SPI_DISCOUNT_AMOUNT" ? offeringRewardLabel(reward, undefined, customUnit, currency) : rewardLabel(reward, customUnit),
         }));
         const earningRules = (earningResponse?.earningRules ?? []).filter(rule => rule.status === "ACTIVE").map((rule, i) => ({
           id: rule.id || `earning-${i}`, name: rule.title || copyParam("loyalty.earnFallback", "Earn points"), subtitle: earningLabel(rule, customUnit, currency),
         }));
+        const tiered = !tiers.failed && tiers.value?.programSettings?.status === "ACTIVE" && program.premiumFeatures?.tiers !== false;
+        const allOfferingGroups = tiered ? buildOfferings(tiers.value, rewardResponse?.rewards ?? [], earningResponse?.earningRules ?? [], customUnit, currency) : [];
+        const offeringsExpanded = s.offeringsExpanded;
+        const offeringState = { offeringGroups: visibleOfferings(allOfferingGroups, offeringsExpanded), offeringsExpanded,
+          hideTierOfferings: !tiered, hideBaseOffering: tiered, hideShowAllTiers: !tiered || offeringsExpanded || allOfferingGroups.length <= OFFERING_TIER_LIMIT,
+          tierError: tiers.failed ? copyParam("loyalty.tiersError", "Tier benefits couldn't be loaded. Showing the base offering.") : "" };
+        if (revision !== loadRevision) return s;
+        allOfferings = allOfferingGroups;
+        const earningState = member.email && !privateStateSupported ? { ...EARNING_EMPTY } : await earning.load(member, program, earningResponse?.earningRules ?? []);
+        if (businessStamp() !== business) throw new Error("Business changed while Loyalty loaded");
         let privateState = { ...PRIVATE_EMPTY };
         if (member.email) {
           try {
@@ -194,7 +220,7 @@ const svc = defineService<S, { prepare: (s: S) => S; load: (s: S, arg?: unknown)
             const known = typeof balance === "number" && Number.isFinite(balance);
             privateState = { ...PRIVATE_EMPTY, hideMemberCard: false,
               ...(known && privateStateSupported && !account.failed
-                ? statusLines(program, account.value?.account ?? {}, balance, tiers, coupons, rewardResult.status === "fulfilled" ? (rewardResponse?.rewards ?? []) : undefined) : {}),
+                ? statusLines(program, account.value?.account ?? {}, balance, tiers, coupons, referrals, rewardResult.status === "fulfilled" ? (rewardResponse?.rewards ?? []) : undefined) : {}),
               memberPoints: typeof balance === "number" && Number.isFinite(balance) ? points(balance, customUnit) : "",
               memberMessage: !privateStateSupported ? copyParam("loyalty.updateApp", "Update the app to see your points securely.") : account.failed ? copyParam("loyalty.pointsError", "Your points couldn't be loaded.")
                 : typeof balance !== "number" || !Number.isFinite(balance) ? copyParam("loyalty.pointsUnavailable", "Your points aren't available yet.") : "",
@@ -207,7 +233,7 @@ const svc = defineService<S, { prepare: (s: S) => S; load: (s: S, arg?: unknown)
         } else {
           privateState.hideMemberSignIn = false;
         }
-        return { ...common, ...loaded("rewards", rewards, COPY), ...privateState, earningRules, hideCatalog: false, hideEarningHeading: false,
+        return { ...common, ...loaded("rewards", rewards, COPY), ...privateState, ...offeringState, ...earningState, earningRules, hideCatalog: false, hideEarningHeading: false,
           rewardError: rewardResult.status === "rejected" ? copyParam("loyalty.rewardsError", "Rewards couldn't be loaded.") : "",
           earningError: earningResult.status === "rejected" ? copyParam("loyalty.earningError", "Ways to earn points couldn't be loaded.") : "",
           hideRewardError: rewardResult.status === "fulfilled", hideEarningError: earningResult.status === "fulfilled", hideRewardRows: rewardResult.status === "rejected",
@@ -215,7 +241,7 @@ const svc = defineService<S, { prepare: (s: S) => S; load: (s: S, arg?: unknown)
           earningEmptyText: earningResult.status === "rejected" || earningRules.length ? "" : copyParam("loyalty.earningEmpty", "No ways to earn points yet.") };
       } catch (error) {
         const failure = loadFailed("rewards", error, COPY);
-        return { ...s, ...PRIVATE_EMPTY, currency, earningRules: [], earningEmptyText: "", inactiveText: "", hideCatalog: !failure.isMock, hideEarningHeading: true, rewardError: "", earningError: "", hideRewardError: true, hideEarningError: true, hideRewardRows: !failure.isMock,
+        return { ...s, ...PRIVATE_EMPTY, ...OFFERING_EMPTY, currency, earningRules: [], earningEmptyText: "", inactiveText: "", hideCatalog: !failure.isMock, hideEarningHeading: true, rewardError: "", earningError: "", hideRewardError: true, hideEarningError: true, hideRewardRows: !failure.isMock,
           ...failure, signInRequired: false, noSignIn: true };
       }
     },

package/templates/branded-lite/tier5-src/himi-branded-lite-loyalty-rewards/index.ts

@@ -0,0 +1,208 @@
+// Member rewards use their own service, so a public offering can never hydrate a
+// balance or coupon. All private state is online-only, and every completion checks
+// the principal and business. Navigation parameters provide an ID, never a price.
+import { defineService, navigate } from "@himalaya/state";
+import { getLoyaltyProgram, listLoyaltyRewards, getCurrentMemberLoyaltyAccount, listMyLoyaltyCoupons, listMyReferralRewards, redeemMyLoyaltyReward,
+  type WixLoyaltyReward, type WixLoyaltyAccount, type WixLoyaltyCoupon, type WixLoyaltyProgram, type WixReferralReward } from "@himalaya/wix-loyalty";
+import { memberAccess, assertMemberAccess, type MemberAccess } from "../_shared/member-access.js";
+import { withOnlineWrites } from "../_shared/online-actions.js";
+import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
+import { offeringRewardLabel, memberRewardCost, pointLabel } from "../_shared/loyalty-offerings.js";
+
+interface MemberRow { id: string; name: string; subtitle: string; eligibility: string; code: string; isCoupon: boolean; notCoupon: boolean; section: string }
+interface S {
+  hideLoading: boolean; hideContent: boolean; hideSignIn: boolean; hideError: boolean; error: string;
+  points: string; items: MemberRow[]; emptyText: string;
+  confirming: boolean; confirmation: string; selectedId: string; writeBusy: boolean; message: string;
+  referralError: string; resultCode: string; resultName: string;
+}
+const INITIAL: S = { hideLoading: false, hideContent: true, hideSignIn: true, hideError: true, error: "", points: "", items: [], emptyText: "",
+  referralError: "", confirming: false, confirmation: "", selectedId: "", writeBusy: false, message: "", resultCode: "", resultName: "" };
+const PRIVATE_KEYS = Object.keys(INITIAL) as (keyof S)[];
+const input = () => (globalThis as { himalaya?: { input?: Record<string, unknown>; readLifecycleVersion?: number } }).himalaya;
+const business = () => input()?.input?.__himiPreferenceBusiness;
+const object = (arg: unknown): Record<string, unknown> => arg && typeof arg === "object" ? arg as Record<string, unknown> : {};
+let generation = 0, writing = false, reviewing = false;
+let currency = "", restaurantScreen = "";
+let context: { member: MemberAccess; business: unknown; program: WixLoyaltyProgram; account: WixLoyaltyAccount; rewards: WixLoyaltyReward[]; coupons: WixLoyaltyCoupon[]; referrals: WixReferralReward[]; referralKnown: boolean } | undefined;
+let confirmation: { id: string; member: MemberAccess; business: unknown; cost: number } | undefined;
+let result: { generation: number; message: string; coupon?: WixLoyaltyCoupon } | undefined;
+// One confirmed write may await two independently replicated reads. Keep its
+// coupon and stop further spending until both reads reflect the transaction.
+let confirmed: { coupon: WixLoyaltyCoupon; balanceAfter?: number; redeemedAfter?: number } | undefined;
+const pointAmount = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value) && value >= 0;
+// An ambiguous write cannot be retried by another tap or refresh in this session.
+const uncertain = new Set<string>();
+const MAX_UNCERTAIN_REWARDS = 64;
+let uncertaintyOverflow = false;
+const blocked = (id: string) => !!confirmed || uncertaintyOverflow || uncertain.has(id);
+let uncertainPrincipal = "";
+const stamp = (member: MemberAccess) => JSON.stringify([member.email, member.scope, business()]);
+const couponReward = (reward: WixLoyaltyReward) => reward.type === "COUPON_REWARD" || reward.type === "COUPON";
+// These responses confirm the write was rejected. Timeouts (including HTTP 408),
+// 5xx and unclassified errors leave its outcome uncertain and must stay blocked.
+function definitiveRejection(error: unknown): boolean {
+  const status = /\bHTTP\s+(\d{3})\b/.exec(String(error))?.[1];
+  return !!status && ["400", "401", "403", "404", "409", "412", "422", "428", "429"].includes(status);
+}
+const guard = async (c: NonNullable<typeof context>) => {
+  await assertMemberAccess(c.member);
+  if (context !== c || business() !== c.business) throw new Error("Member access changed");
+};
+const signInState = (): S => ({ ...INITIAL, hideLoading: true, hideSignIn: false });
+function reconcile(c: NonNullable<typeof context>) {
+  if (!confirmed) return;
+  const points = c.account.points;
+  const debited = (confirmed.balanceAfter !== undefined && pointAmount(points?.balance) && points.balance <= confirmed.balanceAfter)
+    || (confirmed.redeemedAfter !== undefined && pointAmount(points?.redeemed) && points.redeemed >= confirmed.redeemedAfter);
+  if (debited && c.coupons.some(coupon => coupon.id === confirmed!.coupon.id)) confirmed = undefined;
+}
+function rows(c: NonNullable<typeof context>): Pick<S, "items" | "points" | "emptyText" | "referralError"> {
+  const unit = c.program.pointDefinition?.customName ?? "";
+  const balance = c.account.points?.balance;
+  const ordered = c.rewards.filter(r => r.active === true && !!r.id).map((reward, index) => {
+    const cost = memberRewardCost(reward, c.account.tier?.id);
+    return { reward, index, available: couponReward(reward) && !blocked(reward.id) && cost !== undefined && typeof balance === "number" && Number.isFinite(balance) && balance >= cost ? 1 : 0 };
+  }).sort((a, b) => b.available - a.available || a.index - b.index);
+  const rewards = ordered.map(({ reward }, index) => {
+    const cost = memberRewardCost(reward, c.account.tier?.id);
+    const eligibility = confirmed ? copyParam("loyalty.redeemedRefreshFailed", "Reward redeemed. Your balance couldn't be refreshed; refresh before redeeming again.")
+      : blocked(reward.id) ? copyParam("loyalty.redemptionUncertain", "Check your coupons: this redemption could not be confirmed.")
+      : reward.type === "DISCOUNT_AMOUNT" ? copyParam("loyalty.orderToRedeem", "Use this reward when placing an order.")
+      : !couponReward(reward) ? copyParam("loyalty.checkoutReward", "Use this reward at checkout.")
+      : cost === undefined ? copyParam("loyalty.notOnTier", "This reward is not available on your tier.")
+      : typeof balance !== "number" || !Number.isFinite(balance) ? copyParam("loyalty.pointsUnavailable", "Your points aren't available yet.")
+      : balance < cost ? copyTemplate("loyalty.pointsNeeded", "{points} more needed", { points: pointLabel(cost - balance, unit) })
+      : copyParam("loyalty.readyToRedeem", "Available to redeem");
+    return { id: reward.id, code: "", isCoupon: false, notCoupon: true, section: index === 0 ? copyParam("loyalty.rewardsHeading", "Rewards") : "", name: reward.name || copyParam("loyalty.rewardFallback", "Reward"), subtitle: offeringRewardLabel(reward, c.account.tier?.id, unit, currency), eligibility };
+  });
+  const knownCoupons = confirmed && !c.coupons.some(coupon => coupon.id === confirmed!.coupon.id) ? [...c.coupons, confirmed.coupon] : c.coupons;
+  const coupons = knownCoupons.filter(c => c.status === "ACTIVE" && !c.couponReference?.deleted && !!c.id && !!c.couponReference?.code)
+    .map(c => ({ id: c.id!, name: c.rewardName || copyParam("loyalty.rewardFallback", "Reward"), code: c.couponReference!.code! }));
+  const referralCoupons = c.referrals.filter(r => r.rewardType === "COUPON" && r.coupon?.status === "ACTIVE" && !!r.id && !!r.coupon.code)
+    .map(r => ({ id: `referral:${r.id}`, name: r.coupon!.couponSpecification?.name || copyParam("loyalty.referralReward", "Referral reward"), code: r.coupon!.code! }));
+  const allCoupons = [...coupons, ...referralCoupons];
+  const items: MemberRow[] = [...allCoupons.map((coupon, index) => ({ ...coupon, id: `coupon:${coupon.id}`, isCoupon: true, notCoupon: false, subtitle: "", eligibility: "", section: index === 0 ? copyParam("loyalty.claimedRewards", "Your coupons") : "" })), ...rewards];
+  return { items, referralError: c.referralKnown ? "" : copyParam("loyalty.referralsError", "Referral rewards couldn't be verified. Refresh to try again."), points: !confirmed && typeof balance === "number" && Number.isFinite(balance) ? pointLabel(balance, unit) : "",
+    emptyText: rewards.length || allCoupons.length ? "" : copyParam("loyalty.emptyText", "No rewards to redeem yet.") };
+}
+
+async function redeem(c: NonNullable<typeof context>, selected: NonNullable<typeof confirmation>, version: number) {
+  let coupon: WixLoyaltyCoupon | undefined;
+  let message = "";
+  try {
+    await guard(c);
+    const before = c.account.points;
+    // The server validates current member, active reward, tier and cost atomically.
+    const response = await redeemMyLoyaltyReward(selected.id);
+    await guard(c);
+    coupon = response.coupon;
+    if (!coupon?.id || !coupon.couponReference?.code) throw new Error("Redemption was not confirmed");
+    confirmed = { coupon, balanceAfter: pointAmount(before?.balance) ? Math.max(0, before.balance - selected.cost) : undefined,
+      redeemedAfter: pointAmount(before?.redeemed) ? before.redeemed + selected.cost : undefined };
+    message = copyParam("loyalty.redeemed", "Reward redeemed. Use this coupon at checkout.");
+    const [account, coupons] = await Promise.allSettled([getCurrentMemberLoyaltyAccount(), listMyLoyaltyCoupons()]);
+    await guard(c);
+    // A failed follow-up read cannot erase the successful coupon or retain a stale spendable balance.
+    c.account = account.status === "fulfilled" ? account.value.account ?? {} : {};
+    c.coupons = coupons.status === "fulfilled" ? coupons.value.loyaltyCoupons ?? [] : [];
+    reconcile(c);
+    if (confirmed || account.status === "rejected" || coupons.status === "rejected") message = copyParam("loyalty.redeemedRefreshFailed", "Reward redeemed. Your balance couldn't be refreshed; refresh before redeeming again.");
+  } catch (error) {
+    if (definitiveRejection(error)) {
+      c.account = {}; // The eligibility snapshot may have changed since confirmation.
+      message = copyParam("loyalty.cannotRedeem", "This reward can't be redeemed with your current points and tier.");
+    } else {
+      if (uncertain.size < MAX_UNCERTAIN_REWARDS) uncertain.add(selected.id);
+      else uncertaintyOverflow = true; // Fail closed instead of evicting an ambiguous operation.
+      message = copyParam("loyalty.redemptionFailed", "Couldn't confirm redemption. Check your coupons and balance before redeeming again. This action won't be retried automatically.");
+    }
+  } finally { writing = false; }
+  if (version !== generation || context !== c) { await svc.load(); return; }
+  try { await guard(c); result = { generation: version, message, coupon }; await svc.finishRedemption(); }
+  catch { await svc.load(); }
+}
+
+const register = withOnlineWrites(defineService, ["confirmRedemption"], { messageFields: ["message"] });
+const svc = register<S, {
+  prepare: (s: S) => S; load: (s: S, arg?: unknown) => Promise<S | undefined>;
+  reviewReward: (s: S, arg?: unknown) => Promise<S>; cancelRedemption: (s: S) => S;
+  confirmRedemption: (s: S) => S; finishRedemption: (s: S) => S;
+}>("himiBrandedLoyaltyRewards", {
+  state: INITIAL, notHydrated: PRIVATE_KEYS, notPersisted: PRIVATE_KEYS, perVisit: PRIVATE_KEYS,
+  actions: {
+    prepare: () => { generation++; context = undefined; confirmation = undefined; result = undefined; return { ...INITIAL }; },
+    load: async (s, arg) => {
+      stashCopy(arg);
+      if (writing) return s;
+      const version = ++generation; context = undefined; confirmation = undefined; result = undefined;
+      const args = object(arg);
+      if ("currency" in args) currency = typeof args.currency === "string" && /^[A-Z]{3}$/.test(args.currency) ? args.currency : "";
+      if ("restaurantScreen" in args) restaurantScreen = args.restaurantScreen === "himi_menu" ? "himi_menu" : "";
+      const site = business(), member = await memberAccess();
+      if (!member.email) return signInState();
+      if (!member.scope || (input()?.readLifecycleVersion ?? 0) < 1) return { ...INITIAL, hideLoading: true, hideError: false, error: copyParam("loyalty.updateApp", "Update the app to see your points securely.") };
+      if (uncertainPrincipal !== stamp(member)) { uncertain.clear(); uncertaintyOverflow = false; confirmed = undefined; uncertainPrincipal = stamp(member); }
+      try {
+        const [program, rewards, account, coupons, referrals] = await Promise.all([getLoyaltyProgram(), listLoyaltyRewards(), getCurrentMemberLoyaltyAccount(), listMyLoyaltyCoupons(),
+          listMyReferralRewards().then(value => ({ value, failed: false }), () => ({ value: undefined, failed: true }))]);
+        await assertMemberAccess(member);
+        if (business() !== site || version !== generation) return undefined;
+        const p = program.loyaltyProgram ?? program.program;
+        if (!p || p.status !== "ACTIVE" || p.premiumFeatures?.loyaltyProgram === false) throw new Error("Program unavailable");
+        if ((rewards.rewards !== undefined && !Array.isArray(rewards.rewards)) || (coupons.loyaltyCoupons !== undefined && !Array.isArray(coupons.loyaltyCoupons))) throw new Error("Incomplete member rewards response");
+        context = { member, business: site, program: p, account: account.account ?? {}, rewards: rewards.rewards ?? [], coupons: coupons.loyaltyCoupons ?? [], referrals: referrals.value?.referralRewards ?? [], referralKnown: !referrals.failed };
+        reconcile(context);
+        return { ...INITIAL, hideLoading: true, hideContent: false, ...rows(context) };
+      } catch {
+        if (version !== generation || business() !== site) return undefined;
+        const current = await memberAccess();
+        if (!current.email || stamp(current) !== stamp(member)) return signInState();
+        return { ...INITIAL, hideLoading: true, hideError: false, error: copyParam("loyalty.memberRewardsError", "Your rewards couldn't be loaded. Try again.") };
+      }
+    },
+    reviewReward: async (s, arg) => {
+      const c = context, id = object(arg).id;
+      if (!c || typeof id !== "string" || writing || reviewing || blocked(id)) return s;
+      const reward = c.rewards.find(r => r.id === id && r.active === true);
+      if (!reward) return s;
+      reviewing = true;
+      try {
+        await guard(c);
+        if (reward.type === "DISCOUNT_AMOUNT" && restaurantScreen) return navigate(s, { screenId: restaurantScreen });
+        if (!couponReward(reward)) return { ...s, message: copyParam("loyalty.checkoutReward", "Use this reward at checkout.") };
+        const [freshRewards, freshAccount] = await Promise.all([listLoyaltyRewards(), getCurrentMemberLoyaltyAccount()]);
+        await guard(c);
+        const fresh = freshRewards.rewards?.find(r => r.id === id && r.active === true);
+        if (!fresh || !freshAccount.account) throw new Error("Reward unavailable");
+        c.rewards = freshRewards.rewards!; c.account = freshAccount.account;
+        const cost = memberRewardCost(fresh, c.account.tier?.id), balance = c.account.points?.balance;
+        if (cost === undefined || typeof balance !== "number" || !Number.isFinite(balance) || balance < cost) return { ...s, ...rows(c), message: copyParam("loyalty.cannotRedeem", "This reward can't be redeemed with your current points and tier.") };
+        confirmation = { id, member: c.member, business: c.business, cost };
+        return { ...s, ...rows(c), selectedId: id, confirming: true, message: "", confirmation: copyTemplate("loyalty.confirmReward", "Redeem {name} for {points}?", { name: fresh.name || copyParam("loyalty.rewardFallback", "Reward"), points: pointLabel(cost, c.program.pointDefinition?.customName ?? "") }) };
+      } catch {
+        confirmation = undefined;
+        const current = await memberAccess();
+        if (context !== c || business() !== c.business || stamp(current) !== stamp(c.member)) return signInState();
+        return { ...s, confirming: false, message: copyParam("loyalty.cannotRedeem", "This reward can't be redeemed with your current points and tier.") }; }
+      finally { reviewing = false; }
+    },
+    cancelRedemption: s => { if (writing) return s; confirmation = undefined; return { ...s, confirming: false, selectedId: "", confirmation: "" }; },
+    confirmRedemption: s => {
+      const c = context, selected = confirmation;
+      if (!c || !selected || !s.confirming || writing || blocked(selected.id) || selected.business !== business() || selected.member !== c.member) return s;
+      writing = true; confirmation = undefined;
+      void redeem(c, selected, generation);
+      return { ...s, writeBusy: true, message: copyParam("loyalty.redeeming", "Redeeming…") };
+    },
+    finishRedemption: s => {
+      if (!result || result.generation !== generation || !context) return s;
+      const done = result; result = undefined;
+      return { ...s, hideLoading: true, hideContent: false, hideSignIn: true, hideError: true, ...rows(context), confirming: false, selectedId: "", confirmation: "", writeBusy: false, message: done.message,
+        resultCode: done.coupon?.couponReference?.code ?? "", resultName: done.coupon?.rewardName ?? "" };
+    },
+  },
+});
+svc.prepare();
+svc.load();
+export { svc };