@wix/himalaya-cli 0.1582.0 → 0.1584.0

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

@@ -25,7 +25,7 @@ import { initials } from "../_shared/himi-text.js";
 import { copyParam, stashCopy } from "../_shared/himi-copy.js";
 import { formatMonthDay } from "../_shared/engine-intl.js";
 import { openRichLink } from "../_shared/rich-content-link.js";
-import { richBody, ROW_IMAGE_WIDTH } from "../_shared/rich-body.js";
+import { descriptionBody, ROW_IMAGE_WIDTH } from "../_shared/rich-body.js";
 
 interface FeedRow {
   id: string;
@@ -104,7 +104,7 @@ function feedText(item: WixFeedItem): string {
     if (joined) return joined;
   }
   const lean = item.entity?.body?.content;
-  return typeof lean === "string" && lean.trim() ? lean.trim() : copyParam("feed.sharedUpdateFallback", "Shared an update.");
+  return descriptionBody(lean, copyParam("feed.sharedUpdateFallback", "Shared an update.")).bodyText;
 }
 
 function authorName(item: WixFeedItem, profiles: WixFeedProfile[]): string {
@@ -172,7 +172,8 @@ function feedRow(item: WixFeedItem, profiles: WixFeedProfile[]): FeedRow {
   const count = Array.isArray(item.reactionsList) ? item.reactionsList.length : 0;
   const avatar = authorAvatar(item, profiles);
   // A Ricos post's plain text is the whole document's (every node level), not feedText's one-level read.
-  const { bodyJson, bodyText: text } = richBody(item.content, feedText(item), ROW_IMAGE_WIDTH);
+  const fallback = item.content == null ? copyParam("feed.sharedUpdateFallback", "Shared an update.") : feedText(item);
+  const { bodyJson, bodyText: text } = descriptionBody(item.content || item.entity?.body?.content, fallback, ROW_IMAGE_WIDTH);
   // A Ricos post draws its own images in RichContent, so the separate row image would repeat the first one.
   const image = bodyJson ? "" : contentImage(item);
   return {

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

@@ -0,0 +1,243 @@
+import { defineService } from "@himalaya/state";
+import { getGroup, listRules, type WixGroup, type WixGroupRule } from "@himalaya/wix-groups";
+import { WIX_DETAIL_IMAGE } from "@himalaya/wix-media";
+import { copyParam, stashCopy } from "../_shared/himi-copy.js";
+import { groupImage } from "../_shared/himi-media.js";
+import { descriptionBody } from "../_shared/rich-body.js";
+import { openRichLink } from "../_shared/rich-content-link.js";
+import { formatDateMedium } from "../_shared/engine-intl.js";
+
+// The About & rules page of ONE group. The group is `input.id`, never a fallback: a missing
+// id is an error, not "the first group". The group read and the rules read are independent —
+// the page renders the group's own facts when only the rules read failed, and says so in the
+// rules region, so a rules outage is never shown as "this group has no rules".
+//
+// Read-only and online-only: no write exists on this page, so there is nothing to queue.
+
+interface RuleRow {
+  id: string;
+  number: string;
+  title: string;
+  description: string;
+}
+
+type Failure = "forbidden" | "missing" | "failed";
+
+interface State {
+  status: "loading" | "ready" | "error";
+  id: string;
+  name: string;
+  description: string;
+  descriptionJson: string;
+  hasDescriptionJson: boolean;
+  privacy: string;
+  createdDate: string;
+  memberCount: string;
+  image: string;
+  initial: string;
+  rules: RuleRow[];
+  /** The group read failed: the whole page says why. */
+  errorText: string;
+  /** The rules read alone failed: only the rules region says why. */
+  rulesErrorText: string;
+  hideLoading: boolean;
+  hideError: boolean;
+  hideContent: boolean;
+  hideImage: boolean;
+  hidePrivacy: boolean;
+  hideCreated: boolean;
+  hideMemberCount: boolean;
+  hideRules: boolean;
+  hideRulesEmpty: boolean;
+  hideRulesError: boolean;
+}
+
+const initial: State = {
+  status: "loading",
+  id: "",
+  name: "",
+  description: "",
+  descriptionJson: "",
+  hasDescriptionJson: false,
+  privacy: "",
+  createdDate: "",
+  memberCount: "",
+  image: "",
+  initial: "G",
+  rules: [],
+  errorText: "",
+  rulesErrorText: "",
+  hideLoading: false,
+  hideError: true,
+  hideContent: true,
+  hideImage: true,
+  hidePrivacy: true,
+  hideCreated: true,
+  hideMemberCount: true,
+  hideRules: true,
+  hideRulesEmpty: true,
+  hideRulesError: true,
+};
+
+/** Bumped by every group load, so a response that arrives after a newer load began is dropped. */
+let loadSeq = 0;
+
+function inputId(): string {
+  // `himalaya.input.id` is the contract: hosts thread the opener's `id` nav param
+  // (himi.open { screenId: "himi_group_about", id }) into worker input.
+  const input = (globalThis as { himalaya?: { input?: { id?: string } } }).himalaya?.input;
+  return typeof input?.id === "string" ? input.id : "";
+}
+
+function failureOf(e: unknown): Failure {
+  const message = String((e as Error)?.message ?? e);
+  if (/HTTP (401|403)\b/.test(message)) return "forbidden";
+  if (/HTTP 404\b/.test(message)) return "missing";
+  return "failed";
+}
+
+function groupFailureText(failure: Failure): string {
+  if (failure === "forbidden") return copyParam("groupAbout.forbiddenTitle", "You can’t view this group’s details.");
+  if (failure === "missing") return copyParam("groupAbout.missingTitle", "This group no longer exists.");
+  return copyParam("groupAbout.errorTitle", "This group’s details could not be loaded.");
+}
+
+function rulesFailureText(failure: Failure): string {
+  if (failure === "forbidden") return copyParam("groupAbout.rulesForbidden", "You can’t view this group’s rules.");
+  return copyParam("groupAbout.rulesError", "The rules could not be loaded.");
+}
+
+/** The rules the server sent, numbered from 1. `undefined` when the answer is not a rules list
+ *  at all — a missing or non-array `rules` is a malformed answer, not an empty group. */
+function ruleRowsOf(response: unknown): RuleRow[] | undefined {
+  const rules = (response as { rules?: unknown } | null | undefined)?.rules;
+  if (!Array.isArray(rules)) return undefined;
+  const rows: RuleRow[] = [];
+  for (const entry of rules as WixGroupRule[]) {
+    const title = typeof entry?.title === "string" ? entry.title.trim() : "";
+    const description = typeof entry?.description === "string" ? entry.description.trim() : "";
+    if (!title && !description) continue;
+    rows.push({ id: `rule_${rows.length + 1}`, number: String(rows.length + 1), title, description });
+  }
+  return rows;
+}
+
+function withRules(state: State, rules: RuleRow[] | undefined, failure: Failure | undefined): State {
+  if (failure || !rules) {
+    return {
+      ...state,
+      rules: [],
+      rulesErrorText: rulesFailureText(failure ?? "failed"),
+      hideRules: true,
+      hideRulesEmpty: true,
+      hideRulesError: false,
+    };
+  }
+  return {
+    ...state,
+    rules,
+    rulesErrorText: "",
+    hideRules: rules.length === 0,
+    hideRulesEmpty: rules.length > 0,
+    hideRulesError: true,
+  };
+}
+
+function capitalized(value: string): string {
+  const lower = value.trim().toLowerCase();
+  return lower ? lower[0].toUpperCase() + lower.slice(1) : "";
+}
+
+function createdLabel(value: unknown): string {
+  if (typeof value !== "string" || !value) return "";
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? "" : formatDateMedium(date);
+}
+
+function groupState(state: State, id: string, group: WixGroup): State {
+  const name = (group.name || (group as { title?: string }).title || copyParam("group.groupFallbackName", "Group")).trim();
+  const body = descriptionBody(group.description, descriptionBody(group.teaser, "").bodyText);
+  const privacy = capitalized(group.privacyStatus ?? "");
+  const created = createdLabel(group.createdDate);
+  const count = group.membersCount ?? group.memberCount;
+  const image = groupImage(group, WIX_DETAIL_IMAGE);
+  return {
+    ...state,
+    status: "ready",
+    id,
+    name,
+    description: body.bodyText,
+    descriptionJson: body.bodyJson,
+    hasDescriptionJson: body.bodyJson !== "",
+    privacy,
+    createdDate: created,
+    memberCount: typeof count === "number" ? `${count} ${count === 1 ? "member" : "members"}` : "",
+    image,
+    initial: (name[0] || "G").toUpperCase(),
+    errorText: "",
+    hideLoading: true,
+    hideError: true,
+    hideContent: false,
+    hideImage: !image,
+    hidePrivacy: !privacy,
+    hideCreated: !created,
+    hideMemberCount: typeof count !== "number",
+  };
+}
+
+function groupErrorState(id: string, failure: Failure): State {
+  return {
+    ...initial,
+    id,
+    status: "error",
+    errorText: groupFailureText(failure),
+    hideLoading: true,
+    hideError: false,
+    hideContent: true,
+  };
+}
+
+const svc = defineService<State, {
+  load: (state: State, arg?: unknown) => Promise<State | undefined>;
+  reloadRules: (state: State, arg?: unknown) => Promise<State | undefined>;
+  openLink: (state: State, arg?: unknown) => Promise<undefined>;
+}>("himiBrandedGroupAbout", {
+  state: initial,
+  actions: {
+    load: async (state, arg) => {
+      stashCopy(arg);
+      const seq = ++loadSeq;
+      const id = inputId();
+      if (!id) return groupErrorState("", "missing");
+      const [groupResult, rulesResult] = await Promise.allSettled([getGroup(id), listRules(id)]);
+      // A newer load began while these reads were in flight: its answer owns the state.
+      if (seq !== loadSeq) return undefined;
+      if (groupResult.status === "rejected") return groupErrorState(id, failureOf(groupResult.reason));
+      // Social Groups wraps the entity as `{ group }`; the typed signature claims a bare group.
+      const group = ((groupResult.value as unknown as { group?: WixGroup }).group ?? groupResult.value) as WixGroup;
+      if (!group || typeof group !== "object" || (group.id && group.id !== id)) return groupErrorState(id, "failed");
+      const ready = groupState(state, id, group);
+      return rulesResult.status === "rejected"
+        ? withRules(ready, undefined, failureOf(rulesResult.reason))
+        : withRules(ready, ruleRowsOf(rulesResult.value), undefined);
+    },
+    // Retry for the rules region alone: the group's own facts stay on screen.
+    reloadRules: async (state, arg) => {
+      stashCopy(arg);
+      const id = state.id;
+      if (!id) return undefined;
+      const seq = loadSeq;
+      try {
+        const rules = ruleRowsOf(await listRules(id));
+        if (seq !== loadSeq || inputId() !== id) return undefined;
+        return withRules(state, rules, undefined);
+      } catch (e) {
+        if (seq !== loadSeq || inputId() !== id) return undefined;
+        return withRules(state, undefined, failureOf(e));
+      }
+    },
+    openLink: async (_state, arg) => { await openRichLink(arg); return undefined; },
+  },
+});
+
+export { svc };

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

@@ -1,69 +1,135 @@
-// himi-branded-lite-loyalty — reads the real Wix Loyalty program + rewards (getLoyaltyProgram + listLoyaltyRewards).
-// a failed query is an error with Retry (or Sign in when Wix refuses the
-// visitor) and an empty one is a real empty state — never sample rows presented as
-// the customer's own. Samples appear only in the host's explicit sample preview
-// (_shared/branded-load-state.ts).
+// Public Loyalty offering plus the current member's separately verified balance.
 import { defineService } from "../_shared/collection-service.js";
 import { LOADING, loaded, loadFailed, type LoadCopy, type LoadFlags } from "../_shared/branded-load-state.js";
-import { getLoyaltyProgram, listLoyaltyRewards, type WixLoyaltyReward } from "@himalaya/wix-loyalty";
+import { copyParam, copyTemplate } from "../_shared/himi-copy.js";
+import { formatCurrency, formatNumber } from "../_shared/engine-intl.js";
+import { memberAccess, assertMemberAccess } from "../_shared/member-access.js";
+import { getLoyaltyProgram, listLoyaltyRewards, listLoyaltyEarningRules, getCurrentMemberLoyaltyAccount, type WixLoyaltyReward, type WixLoyaltyEarningRule } from "@himalaya/wix-loyalty";
 
 interface Row { id: string; name: string; subtitle: string }
 interface S extends LoadFlags {
-  programName: string; unit: string;
-  rewards: Row[]; emptyText: string;
-  isMock: boolean; notMock: boolean; /** #2849 — hiddenWhen() hides on TRUE, so these are inverted: the empty-state banner
-   *  shows only when the site really has none, and the unavailable one only when the
-   *  query failed. A failed query must never render the sentence that claims the
-   *  customer has no content. */
-  notMockEmpty: boolean; notMockUnavailable: boolean;
+  programName: string; unit: string; currency: string;
+  rewards: Row[]; earningRules: Row[]; emptyText: string; earningEmptyText: string;
+  hideCatalog: boolean; hideEarningHeading: boolean; inactiveText: string;
+  rewardError: string; earningError: string; hideRewardError: boolean; hideEarningError: boolean; hideRewardRows: boolean;
+  memberPoints: string; memberMessage: string;
+  hideMemberCard: boolean; hideMemberSignIn: boolean; hideMemberRetry: boolean;
 }
+const PRIVATE_EMPTY = { memberPoints: "", memberMessage: "", hideMemberCard: true, hideMemberSignIn: true, hideMemberRetry: true };
+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 };
 
-/** "500 points" / "Free" from a reward's requiredPoints. */
-function pointsLabel(r: WixLoyaltyReward, unit: string): string {
-  const pts = typeof r.requiredPoints === "number" ? r.requiredPoints : undefined;
-  if (pts === undefined) return "";
-  if (pts <= 0) return "Free";
-  return `${pts.toLocaleString()} ${unit}`;
+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 {
+  const base = configs?.filter(config => !config.tierId);
+  return base?.length === 1 ? base[0] : undefined;
 }
-
-function norm(r: WixLoyaltyReward, unit: string): Row {
-  return { id: r.id || r.name || "reward", name: r.name || "Reward", subtitle: pointsLabel(r, unit) };
+function points(value: number, customUnit: string): string {
+  const unit = customUnit || copyParam(value === 1 ? "loyalty.pointOne" : "loyalty.pointMany", value === 1 ? "point" : "points");
+  return copyTemplate("loyalty.pointsLabel", "{points} {unit}", { points: formatNumber(value), unit });
+}
+function rewardLabel(reward: WixLoyaltyReward, customUnit: string): string {
+  const configs = reward.discountAmount?.configsByTier ?? reward.couponReward?.fixedAmount?.configsByTier
+    ?? reward.couponReward?.percentage?.configsByTier ?? reward.couponReward?.freeShipping?.configsByTier;
+  const cost = configs?.length ? baseConfig<{ tierId?: string; costInPoints?: number }>(configs)?.costInPoints : reward.requiredPoints;
+  if (!amount(cost)) return copyParam("loyalty.costUnavailable", "Points details unavailable");
+  return cost === 0 ? copyParam("loyalty.free", "Free") : points(cost, customUnit);
+}
+function earningLabel(rule: WixLoyaltyEarningRule, customUnit: string, currency: string): string {
+  if (rule.fixedAmount) {
+    const value = baseConfig(rule.fixedAmount.configs)?.points;
+    return amount(value) ? points(value, customUnit) : copyParam("loyalty.earningUnavailable", "Points details unavailable");
+  }
+  const rate = baseConfig(rule.conversionRate?.configs);
+  if (!rate || !amount(rate.points) || !amount(rate.moneyAmount) || rate.moneyAmount === 0 || !currency) {
+    return copyParam("loyalty.earningUnavailable", "Points details unavailable");
+  }
+  return copyTemplate("loyalty.pointsPerSpend", "{points} per {amount}", {
+    points: points(rate.points, customUnit), amount: formatCurrency(rate.moneyAmount, currency, "en", Number.isInteger(rate.moneyAmount) ? 0 : undefined),
+  });
+}
+function businessStamp(): unknown {
+  return (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input?.__himiPreferenceBusiness;
+}
+function currencyFrom(s: S, arg: unknown): string {
+  if (!arg || typeof arg !== "object" || !("currency" in arg)) return s.currency;
+  const raw = (arg as { currency?: unknown }).currency;
+  return typeof raw === "string" && /^[A-Z]{3}$/.test(raw) ? raw : "";
 }
-
-const MOCK: Row[] = [
-  { id: "sample-5off",    name: "5% off your next order", subtitle: "500 points" },
-  { id: "sample-ship",    name: "Free shipping",         subtitle: "300 points" },
-  { id: "sample-15",      name: "15% off any purchase",  subtitle: "750 points" },
-  { id: "sample-gift",    name: "Free welcome gift",     subtitle: "1,000 points" },
-];
-
-/** sample rows reach the screen ONLY in the host's explicit sample preview;
- *  a failed or empty query is an honest error / empty state (branded-load-state.ts). */
 const COPY: LoadCopy<Row> = {
-  prefix: "loyalty",
-  empty: "No rewards to redeem yet.",
-  error: "The rewards program couldn't be loaded.",
-  signIn: "Sign in to see your points and rewards.",
-  sample: () => MOCK.map((r) => ({ ...r })),
+  prefix: "loyalty", empty: "No rewards to redeem yet.",
+  error: "The rewards program couldn't be loaded.", signIn: "The rewards program couldn't be loaded.",
+  sample: () => [{ id: "sample-reward", name: copyParam("loyalty.sampleReward", "5% off your next order"), subtitle: points(500, "") }],
 };
 
-const svc = defineService<S, { load: (s: S) => Promise<S> }>("himiBrandedLoyalty", {
-  state: { ...LOADING, programName: "Rewards", unit: "points", rewards: [], emptyText: "" },
+const svc = defineService<S, { prepare: (s: S) => S; load: (s: S, arg?: unknown) => Promise<S> }>("himiBrandedLoyalty", {
+  state: INITIAL,
+  notHydrated: ["memberPoints", "memberMessage", "hideMemberCard", "hideMemberSignIn", "hideMemberRetry"],
+  notPersisted: ["memberPoints", "memberMessage", "hideMemberCard", "hideMemberSignIn", "hideMemberRetry"],
   actions: {
-    load: async (s) => {
+    prepare: s => ({ ...s, ...PRIVATE_EMPTY }),
+    load: async (s, arg) => {
+      const currency = currencyFrom(s, arg);
+      const business = businessStamp();
       try {
-        const prog = await getLoyaltyProgram();
-        const p = prog.loyaltyProgram ?? prog.program;
-        const unit = (p?.pointDefinition?.customName || "points").trim() || "points";
-        const programName = (p?.name || "Rewards").trim() || "Rewards";
-        const r = await listLoyaltyRewards();
-        const rewards = (r.rewards ?? []).filter((x) => x.active !== false).map((x) => norm(x, unit));
-        return { ...s, programName, unit, ...loaded("rewards", rewards, COPY) };
-      } catch (err) {
-        return { ...s, ...loadFailed("rewards", err, COPY) };
+        const [response, member] = await Promise.all([getLoyaltyProgram(), memberAccess()]);
+        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") {
+          return { ...common, ...loaded("rewards", [], COPY), earningRules: [], earningEmptyText: "", hideCatalog: true,
+            inactiveText: copyParam("loyalty.inactive", "The rewards program isn't available right now.") };
+        }
+        // Balance failures cannot discard a public offering that loaded correctly.
+        const privateStateSupported = !!member.scope && ((globalThis as { himalaya?: { readLifecycleVersion?: number } }).himalaya?.readLifecycleVersion ?? 0) >= 1;
+        const accountRead = member.email && privateStateSupported
+          ? getCurrentMemberLoyaltyAccount().then(value => ({ value, failed: false })).catch(() => ({ value: undefined, failed: true }))
+          : Promise.resolve({ value: undefined, failed: false });
+        const [[rewardResult, earningResult], account] = await Promise.all([
+          Promise.allSettled([listLoyaltyRewards(), listLoyaltyEarningRules()]), accountRead,
+        ]);
+        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),
+        }));
+        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),
+        }));
+        let privateState = { ...PRIVATE_EMPTY };
+        if (member.email) {
+          try {
+            await assertMemberAccess(member);
+            const balance = account.value?.account?.points?.balance;
+            privateState = { ...PRIVATE_EMPTY, hideMemberCard: false,
+              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.") : "",
+              hideMemberRetry: !account.failed };
+          } catch {
+            const current = await memberAccess();
+            privateState = { ...PRIVATE_EMPTY, hideMemberCard: !current.email, hideMemberSignIn: !!current.email,
+              memberMessage: current.email ? copyParam("loyalty.pointsError", "Your points couldn't be loaded.") : "", hideMemberRetry: !current.email };
+          }
+        } else {
+          privateState.hideMemberSignIn = false;
+        }
+        return { ...common, ...loaded("rewards", rewards, COPY), ...privateState, 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",
+          emptyText: rewardResult.status === "rejected" ? "" : rewards.length ? "" : copyParam("loyalty.emptyText", COPY.empty),
+          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,
+          ...failure, signInRequired: false, noSignIn: true };
       }
     },
   },
 });
+svc.prepare();
 svc.load();
 export { svc };

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

@@ -1,3 +1,4 @@
+import { descriptionBody } from "../_shared/rich-body.js";
 import { paymentSetupMessage } from "../_shared/payment-setup.js";
 import { offlineWriteMessage, offlineWritesEnabled, withOnlineWrites } from "../_shared/online-actions.js";
 import { connectivity } from "@himalaya/state";
@@ -140,7 +141,7 @@ function planRow(plan: WixPlan): PlanRow {
   return {
     id: plan.id || "",
     name,
-    description: (plan.description ?? "").trim(),
+    description: descriptionBody(plan.description).bodyText,
     trialBadge,
     noTrialBadge: !trialBadge,
     priceLine: money(plan),

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

@@ -1,3 +1,4 @@
+import { descriptionBody } from "../_shared/rich-body.js";
 // himi-branded-lite-podcasts — live RSS episodes with a persistent queue and
 // the shared native/web media playback transport.
 import { defineService } from "../_shared/collection-service.js";
@@ -99,7 +100,7 @@ function norm(episode: Episode): Row | null {
     title: (episode.title || "Episode").trim() || "Episode",
     subtitle: [dateLabel(episode.date), duration ? clock(duration) : ""].filter(Boolean).join(" · "),
     image: (episode.image || "").trim(),
-    description: (episode.descriptionExcerpt || "").trim(),
+    description: descriptionBody(episode.descriptionExcerpt).bodyText,
     audioUrl,
     durationMs: duration,
     progressLabel: "",

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

@@ -1,3 +1,4 @@
+import { descriptionBody } from "../_shared/rich-body.js";
 // himi-branded-lite-portfolio — real, public Wix Portfolio projects.
 // Empty and error states stay explicit; media IDs are normalized for every host.
 import { defineService } from "../_shared/collection-service.js";
@@ -28,7 +29,7 @@ function norm(project: WixPortfolioProject): Row {
   return {
     id: project.id || project.slug || title,
     title,
-    subtitle: (project.description || "").trim(),
+    subtitle: descriptionBody(project.description).bodyText,
     image,
     initial: (title[0] || "#").toUpperCase(),
     hasImage: Boolean(image),

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

@@ -1,3 +1,4 @@
+import { descriptionBody } from "../_shared/rich-body.js";
 // himi-branded-lite-portfolio-project — real Wix Portfolio project detail.
 // The public project row is resolved again from Wix, then its ordered project
 // items supply the actual image/video/text story. No sample project is invented.
@@ -59,7 +60,7 @@ function row(item: WixPortfolioProjectItem, index: number): MediaRow {
   return {
     id: item.id || `portfolio-item-${index}`,
     title: (item.title ?? "").trim(),
-    description: (item.description ?? "").trim(),
+    description: descriptionBody(item.description).bodyText,
     image,
     videoUrl: hasVideo ? videoUrl : "",
     hasImage,
@@ -132,7 +133,7 @@ const svc = defineService<State, { load: (state: State, arg?: unknown) => Promis
           id,
           title: (project.title || copyParam("portfolioProject.projectFallbackName", "Project")).trim(),
           initial: ((project.title || "P").trim()[0] || "P").toUpperCase(),
-          description: (project.description ?? "").trim(),
+          description: descriptionBody(project.description).bodyText,
           coverImage: wixMediaUrl(portfolioCoverRef(project.coverImage), WIX_DETAIL_IMAGE),
           items,
           emptyText: items.length ? "" : copyParam("portfolioProject.noMediaText", "This project has no published media yet."),

package/templates/branded-lite/tier5-src/himi-branded-lite-program/facts.ts

@@ -0,0 +1,52 @@
+import type { WixProgramFull } from "@himalaya/wix-online-programs";
+import { copyParam } from "../_shared/himi-copy.js";
+import { formatDateMedium } from "../_shared/engine-intl.js";
+
+export interface ProgramFact { id: string; icon: string; title: string; body: string }
+
+/** Only explicit Program fields establish a fact. Missing access is never public. */
+export function programFacts(program: WixProgramFull, locale: string): ProgramFact[] {
+  const facts: ProgramFact[] = [];
+  const timeline = program.timeline;
+  if (timeline?.selfPaced === true) facts.push({
+    id: "pace", icon: "clock",
+    title: copyParam("program.facts.selfPacedTitle", "Self-paced"),
+    body: copyParam("program.facts.selfPacedBody", "Complete steps at your own pace."),
+  });
+  else if (timeline?.selfPaced === false) facts.push({
+    id: "pace", icon: "clock",
+    title: copyParam("program.facts.scheduledTitle", "Scheduled"),
+    body: copyParam("program.facts.scheduledBody", "Follow the program schedule."),
+  });
+
+  const rawStart = timeline?.startDate;
+  // A date-only field is a calendar day, not midnight in the viewer's time zone. Build it at LOCAL noon and
+  // format it in the local zone: that reads the same day with ECMA-402 and on engines without it (watch/Wear),
+  // whose fallback ignores a timeZone argument and reads local getters.
+  const dateOnly = typeof rawStart === "string" ? /^(\d{4})-(\d{2})-(\d{2})$/.exec(rawStart.trim()) : null;
+  const date = dateOnly ? new Date(Number(dateOnly[1]), Number(dateOnly[2]) - 1, Number(dateOnly[3]), 12)
+    : typeof rawStart === "string" && rawStart.trim() ? new Date(rawStart) : undefined;
+  if (date && Number.isFinite(date.getTime())) {
+    let body: string;
+    try { body = formatDateMedium(date, locale); }
+    catch { body = formatDateMedium(date, "en"); }
+    facts.push({ id: "start", icon: "calendar", title: copyParam("program.facts.fixedStartTitle", "Fixed start date"), body });
+  } else if (timeline?.selfPaced === true && (rawStart === undefined || rawStart === "")) facts.push({
+    id: "start", icon: "calendar",
+    title: copyParam("program.facts.flexibleStartTitle", "Flexible start date"),
+    body: copyParam("program.facts.flexibleStartBody", "Start whenever you're ready."),
+  });
+
+  const access = program.restrictions?.accessType?.toUpperCase();
+  if (access === "PUBLIC") facts.push({
+    id: "access", icon: "globe",
+    title: copyParam("program.facts.publicTitle", "Public"),
+    body: copyParam("program.facts.publicBody", "Anyone can join."),
+  });
+  else if (access === "PRIVATE") facts.push({
+    id: "access", icon: "lock",
+    title: copyParam("program.facts.privateTitle", "Private"),
+    body: copyParam("program.facts.privateBody", "Approval is required to join."),
+  });
+  return facts;
+}