@wix/himalaya-cli 0.1583.0 → 0.1584.0

package/templates/community-club/himalaya.content.json

@@ -55,12 +55,18 @@
     "himi_group": {
       "displayName": "Group"
     },
+    "himi_group_about": {
+      "displayName": "Group About"
+    },
     "himi_groups": {
       "displayName": "Groups"
     },
     "himi_my_events": {
       "displayName": "My Events"
     },
+    "himi_notif_settings": {
+      "displayName": "Notif Settings"
+    },
     "himi_rsvp": {
       "displayName": "RSVP"
     },

package/templates/community-club/tier5-src/_shared/branded-lite-hosted.ts

@@ -97,6 +97,7 @@ export const HOSTED_SCREEN_VERTICALS: Readonly<Record<string, readonly BrandedLi
   himi_gift_card: ["giftCards"],
   himi_gift_cards: ["giftCards"],
   himi_groups: ["groups"],
+  himi_group_about: ["groups"],
   himi_invoice: ["invoices"],
   himi_invoices: ["invoices"],
   himi_loyalty: ["loyalty"],
@@ -107,7 +108,6 @@ export const HOSTED_SCREEN_VERTICALS: Readonly<Record<string, readonly BrandedLi
   himi_my_events: ["events"],
   himi_my_subscriptions: ["plans"],
   himi_new_message: ["inbox", "members"],
-  himi_notif_settings: ["notifsettings"],
   himi_notifications: ["notifications"],
   himi_orders: ["store"],
   himi_photo_album: ["galleries"],

package/templates/community-club/tier5-src/_shared/collection-contract.ts

@@ -19,6 +19,8 @@ export interface CollectionConfig {
   /** Numeric 0–5 row field rendered as a Rating (accessible "N out of 5") instead of
    *  folding a "★★★★☆" glyph string into the metadata line, so screen readers get a value. */
   rating?: string;
+  /** Domain-provided calendar text and its unavailable flag, kept separate from media. */
+  dateBadge?: { text: string; hidden: string };
   sectioned?: boolean;
   view: 'list' | 'grid';
   backendQuery?: boolean;
@@ -38,7 +40,13 @@ export interface CollectionConfig {
   /** The card's primary verb, shown as a visible button beside the overflow.
    * `screenId` opens that screen with the row id; without it the verb reuses the
    * row's own tap action (the detail screen that owns the verb). */
-  primaryVerb?: { label: string; screenId?: string };
+  primaryVerb?: { label: string; screenId?: string;
+    /** A row field holding THIS row's verb label (Register, RSVP, Buy Tickets…); `label` stays the fallback copy. */
+    labelPath?: string;
+    /** A row boolean that hides the verb on rows that offer no action (an event with no registration). */
+    hiddenPath?: string };
+  /** The worker action that shares a row (`tier5.<service>.<name>` with `{ id }`): adds Share to the card's overflow menu. */
+  shareAction?: string;
   /** A TIME-BOUND entity (an event, a booking, a reservation): the boolean row field the
    *  DOMAIN sets once the record has finished — computed by the same rule as the row's own
    *  "Past" label, in the same place, so the two cannot disagree. A finished
@@ -73,7 +81,7 @@ export const COLLECTIONS: Record<string, CollectionConfig> = {
   himiBookingBookings: { rows: 'rows', title: 'title', subtitle: 'subtitle', metadata: ['status'], view: 'list', backendQuery: true,
     defaultFilter: 'value:Upcoming', searchPlaceholder: 'Search by booking ID', countNoun: ['booking', 'bookings'], filterValues: ['Upcoming', 'Past', 'Cancelled'],
     sortLabels: { default: 'Soonest', az: 'Oldest', za: 'Latest' } },
-  himiEvents: { rows: 'results', title: 'title', subtitle: 'dateLine', image: 'image', view: 'grid', backendQuery: true, defaultFilter: 'value:Upcoming', searchPlaceholder: 'Search events', countNoun: ['event', 'events'], filterValues: ['Upcoming', 'Past'], sortLabels: { default: 'Date', az: 'Title A–Z', za: 'Title Z–A' }, primaryVerb: { label: 'Register' }, endedWhen: 'isPast' },
+  himiEvents: { rows: 'results', title: 'title', subtitle: 'dateLine', image: 'image', dateBadge: { text: 'dateBadge', hidden: 'noDateBadge' }, gridColumns: 1, view: 'grid', backendQuery: true, defaultFilter: 'value:Upcoming', searchPlaceholder: 'Search events', countNoun: ['event', 'events'], filterValues: ['Upcoming', 'Past'], sortLabels: { default: 'Date', az: 'Title A–Z', za: 'Title Z–A' }, primaryVerb: { label: 'Register', labelPath: 'actionLabel', hiddenPath: 'noAction' }, shareAction: 'share', endedWhen: 'isPast' },
   himiBlogFeed: { rows: 'posts', title: 'title', subtitle: 'excerpt', image: 'image', filter: 'category', filterValuesFrom: 'categories', view: 'grid', narrowedBy: 'selectedCategoryId' },
   himiOwnerLiteProducts: { rows: 'products', title: 'name', subtitle: 'price', image: 'image', view: 'grid', backendQuery: true, countNoun: ['product', 'products'] },
   himiOwnerModules: { instanceInput: 'module', rows: 'rows', title: 'title', subtitle: 'subtitle', image: 'image', filter: 'statusLabel', view: 'list', paged: true, reviewAction: 'prepareRecord', reviewSelectedAction: 'prepareSelected' },
@@ -208,7 +216,15 @@ export function projectCollection(source: CollectionRow[], config: CollectionCon
       ...(config.endedWhen ? (() => {
         const ended = row[config.endedWhen] === true || (config.endedWhen === 'isPast' && row.statusLabel === 'Past');
         return { collectionEnded: ended, collectionNotEnded: !ended };
-      })() : {}) })),
+      })() : {}),
+      // A row restored from state saved by an older build has no badge flag. An unset hidden flag
+      // fails open and would paint an empty chip, so it reads as "no badge" until a refresh.
+      ...(config.dateBadge && typeof row[config.dateBadge.hidden] !== 'boolean'
+        ? { [config.dateBadge.text]: '', [config.dateBadge.hidden]: true } : {}),
+      // Same for a per-row verb: an unset hidden flag fails open and would show a verb with an unresolved
+      // label, so a row without the flag offers no action until a refresh establishes one.
+      ...(config.primaryVerb?.hiddenPath && typeof row[config.primaryVerb.hiddenPath] !== 'boolean'
+        ? { ...(config.primaryVerb.labelPath ? { [config.primaryVerb.labelPath]: '' } : {}), [config.primaryVerb.hiddenPath]: true } : {}) })),
     filters, loaded: rows.length,
   };
 }

package/templates/community-club/tier5-src/_shared/event-registration.ts

@@ -0,0 +1,86 @@
+// Pure Events registration helpers shared by the event detail and the event list: which action an
+// event offers, its label, and the URLs behind it. One copy, so a card and the detail screen never
+// disagree about whether an event can be registered for.
+import type { WixEvent } from "@himalaya/wix-events";
+import { formatWeekdayDateTime } from "./engine-intl.js";
+import { copyParam } from "./himi-copy.js";
+
+function detailCopy(key: string, fallback: string): string { return copyParam(key, fallback); }
+
+/** Registration CTA kind derived from the event's registration/eventType. */
+export type RegistrationKind = "rsvp" | "tickets" | "external" | "none";
+
+/** Map registration status and decoded eventType onto the CTA variant. The decoded
+ *  `eventType` already folds registration.type / registration.initialType /
+ *  the legacy flat `type` (decodeEvent, #478). Without a recognized type or
+ *  status there is no registration action to offer. */
+export function registrationKindOf(e: WixEvent): RegistrationKind {
+  const raw = e as unknown as { registration?: { type?: string; initialType?: string; status?: string } };
+  const value = (raw.registration?.type ?? e.eventType ?? raw.registration?.initialType ?? "").toUpperCase();
+  if (value === "NONE" || value.includes("NO_REGISTRATION")) return "none";
+  // Open statuses select the footer action, so they must also select the
+  // inventory read and action guards when type metadata is absent or stale.
+  switch (raw.registration?.status?.toUpperCase()) {
+    case "OPEN_TICKETS": return "tickets";
+    case "OPEN_EXTERNAL": return "external";
+    case "OPEN_RSVP":
+    case "OPEN_RSVP_WAITLIST_ONLY":
+    case "SCHEDULED_RSVP": return "rsvp";
+  }
+  if (value.includes("EXTERNAL")) return "external";
+  if (value.includes("TICKET")) return "tickets";
+  if (value.includes("RSVP")) return "rsvp";
+  return "none";
+}
+
+export function eventStatus(e: WixEvent): string {
+  const raw = e as unknown as { status?: string };
+  return (raw.status ?? e.eventStatus ?? "").toUpperCase();
+}
+
+export function registrationUi(e: WixEvent, now: number): { state: string; label: string; action: string; caption: string; notice: string } {
+  const raw = e as unknown as { registration?: { status?: string; registrationPaused?: boolean; registrationDisabled?: boolean; allowedGuestTypes?: string; rsvp?: { startDate?: string }; tickets?: { soldOut?: boolean }; external?: { url?: string } }; form?: { messages?: { registrationClosed?: { message?: string; exploreEventsActionLabel?: string }; ticketsUnavailable?: { message?: string; exploreEventsActionLabel?: string } } } };
+  const r = raw.registration ?? {};
+  const status = eventStatus(e);
+  const type = registrationKindOf(e);
+  if (status === "CANCELED") return { state: "notice", label: "", action: "", caption: "", notice: detailCopy("event.canceledNotice", "This event was canceled.") };
+  if (status === "ENDED") return { state: "notice", label: "", action: "", caption: "", notice: detailCopy("event.endedNotice", "This event has ended.") };
+  if (type === "none" || r.registrationDisabled) return { state: "none", label: "", action: "", caption: "", notice: "" };
+  const ownerClosed = raw.form?.messages?.registrationClosed?.message;
+  const ownerSold = raw.form?.messages?.ticketsUnavailable?.message;
+  if (["CLOSED_AUTOMATICALLY", "CLOSED_MANUALLY"].includes(r.status || "") || r.registrationPaused) return { state: "notice", label: "", action: "", caption: "", notice: ownerClosed || detailCopy("event.closedNotice", "Registration is closed.") };
+  if (type === "tickets" && r.tickets?.soldOut) return { state: "notice", label: "", action: "", caption: "", notice: ownerSold || detailCopy("event.soldOutNotice", "Tickets are sold out.") };
+  if (r.status === "SCHEDULED_RSVP") return { state: "scheduled", label: detailCopy("event.rsvpCta", "RSVP"), action: "", caption: detailCopy("event.opensCaption", "RSVP opens {date}.").replace("{date}", r.rsvp?.startDate ? formatWeekdayDateTime(new Date(r.rsvp.startDate)) : ""), notice: "" };
+  if (r.status === "OPEN_RSVP_WAITLIST_ONLY") return { state: "waitlist", label: detailCopy("event.waitlistCta", "Join Waitlist"), action: "himi.open", caption: detailCopy("event.fullCaption", "This event is full."), notice: "" };
+  if (r.status === "OPEN_TICKETS" || type === "tickets") return { state: "tickets", label: detailCopy("event.ticketsCta", "Buy Tickets"), action: "openTickets", caption: "", notice: "" };
+  if (r.status === "OPEN_EXTERNAL" || type === "external") return registrationUrlOf(e)
+    ? { state: "external", label: detailCopy("event.externalCta", "Register"), action: "openRegistration", caption: "", notice: "" }
+    : { state: "none", label: "", action: "", caption: "", notice: "" };
+  if (type === "rsvp" && r.status === "OPEN_RSVP") return { state: "rsvp", label: detailCopy("event.rsvpCta", "RSVP"), action: "himi.open", caption: "", notice: "" };
+  if (r.status === "OPEN_RSVP" || (type === "rsvp" && !r.status)) return { state: "rsvp", label: detailCopy("event.rsvpCta", "RSVP"), action: "himi.open", caption: "", notice: "" };
+  void now;
+  return { state: "none", label: "", action: "", caption: "", notice: "" };
+}
+
+/** External registration URL / event page URL from the raw payload ("" when absent). */
+export function registrationUrlOf(e: WixEvent): string {
+  const raw = e as unknown as {
+    registration?: { external?: { registration?: string; url?: string } };
+    eventPageUrl?: { base?: string; path?: string } | string;
+  };
+  const external = raw.registration?.external?.registration ?? raw.registration?.external?.url;
+  if (typeof external === "string" && /^https?:\/\//i.test(external)) return external;
+  return eventPageUrlOf(e);
+}
+
+/** The event's public page URL when the payload carries one ("" otherwise). */
+export function eventPageUrlOf(e: WixEvent): string {
+  const raw = e as unknown as { eventPageUrl?: { base?: string; path?: string } | string };
+  const page = raw.eventPageUrl;
+  if (typeof page === "string" && /^https?:\/\//i.test(page)) return page;
+  if (page && typeof page === "object" && typeof page.base === "string" && page.base) {
+    const path = typeof page.path === "string" ? page.path : "";
+    return `${page.base.replace(/\/$/, "")}${path && !path.startsWith("/") ? "/" : ""}${path}`;
+  }
+  return "";
+}

package/templates/community-club/tier5-src/_shared/himi-restaurants.ts

@@ -1,3 +1,4 @@
+import { descriptionBody } from "./rich-body.js";
 // Shared restaurants-menu shaping for himi workers (branded-lite `restaurants`
 // vertical): dish cards + menu categories derived from the Wix Restaurants
 // Menus hierarchy (menu → sections → items). Used by BOTH the menus worker
@@ -166,7 +167,7 @@ export function itemPriceVariants(item: WixItem): Array<{ id: string; variantId:
 
 /** HTML-stripped, whitespace-collapsed description snippet (≤ 90 chars). */
 export function descriptionSnippet(value: unknown, maxLength = 90): string {
-  const text = (typeof value === "string" ? value : "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  const text = descriptionBody(value).bodyText.replace(/\s+/g, " ").trim();
   return text.length > maxLength ? `${text.slice(0, maxLength - 1).trimEnd()}…` : text;
 }
 

package/templates/community-club/tier5-src/himi-blog-post/index.ts

@@ -1,7 +1,7 @@
 // Tier-5 bundle: Himi Blog post detail - reader content plus member actions.
 import { defineService } from "@himalaya/state";
 import { share as shareSheet } from "@himalaya/share";
-import { getPost, likePost, unlikePost, type WixPost } from "@himalaya/wix-blog";
+import { getPost, likePost, unlikePost, type WixPost, type WixPostWithContent } from "@himalaya/wix-blog";
 import { comments, BLOG_COMMENTS_APP_ID, blogCommentRow, listBlogComments, type WixBlogCommentRow } from "@himalaya/wix-comments";
 import { get, type DbEntity } from "@himalaya/local-db";
 import { isSavedId, toggleSavedId } from "../_shared/himi-blog-saved";
@@ -38,6 +38,7 @@ interface S {
   signInRequired: boolean; noSignIn: boolean; signInScreenId: string;
   status: "loading" | "ready" | "error";
   id: string;
+  commentResourceId: string;
   title: string;
   subtitle: string;
   /** Author byline ("By <name>") — resolved from the post payload's writer-ish
@@ -80,7 +81,7 @@ interface S {
   blogScreenId: string;
 }
 
-type PostWithExtras = WixPost & {
+type PostWithExtras = WixPostWithContent & {
   media?: { wixMedia?: { image?: { url?: string } }; embedMedia?: { thumbnail?: { url?: string } } };
   coverImage?: { image?: { url?: string }; url?: string };
   metrics?: { likeCount?: number; likes?: number; totalComments?: number; commentCount?: number; comments?: number };
@@ -219,6 +220,7 @@ const baseState: S = derive({
   ...NO_READ_SIGN_IN, signInScreenId: "himi_account",
   status: "loading",
   id: "",
+  commentResourceId: "",
   title: "",
   subtitle: "",
   byline: "",
@@ -265,6 +267,7 @@ async function cachedPostState(s: S, id: string): Promise<S> {
     ...s,
     status: "ready",
     id,
+    commentResourceId: "",
     title,
     subtitle: String(cached.meta ?? ""),
     excerpt: String(cached.excerpt ?? "").trim(),
@@ -294,19 +297,28 @@ async function loadPostState(s: S): Promise<S | undefined> {
   }
   try {
     const access = await readAccess();
-    const [postResult, commentsResult] = await Promise.allSettled([getPost(id, {}, { preserveAccessErrors: true }), listBlogComments(id)]);
-    if (postResult.status === "rejected") throw postResult.reason;
+    const response = await getPost(id, { fieldsets: ["RICH_CONTENT", "CONTENT_TEXT", "INTERNAL_ID"] }, { preserveAccessErrors: true });
+    await assertReadAccess(access);
+    if (version !== loadVersion) return undefined;
+    const post = response.post as PostWithExtras;
+    // Native Blog v3 Comments scopes by internalId, not the navigation UUID.
+    // A missing projection cannot establish that the post has no comments.
+    const commentResourceId = post.internalId?.trim() ?? "";
+    let commentsUnavailable = !commentResourceId;
+    let comments: CommentRow[] = [];
+    if (commentResourceId) {
+      try { comments = (await listBlogComments(commentResourceId)).map(toCommentRow); }
+      catch { commentsUnavailable = true; }
+    }
     await assertReadAccess(access);
     if (version !== loadVersion) return undefined;
-    const post = (((postResult.value as unknown as { post?: WixPost }).post) ?? postResult.value) as PostWithExtras;
-    const commentsUnavailable = commentsResult.status === "rejected";
-    const comments = commentsResult.status === "fulfilled" ? commentsResult.value.map(toCommentRow) : [];
     const cover = imageUrl(post);
     const title = post.title || "Untitled post";
     return derive({
       ...clean,
       status: "ready",
       id,
+      commentResourceId,
       title,
       subtitle: subtitle(post),
       byline: bylineOf(post),
@@ -398,9 +410,10 @@ const svc = defineService<S, {
     submitComment: async (s) => {
       const text = s.commentDraft.trim();
       if (!text) return derive({ ...s, actionMessage: copyParam("blogPost.commentValidation", "Write a comment first.") });
+      if (!s.commentResourceId) return derive({ ...s, actionMessage: copyParam("blogPost.commentsUnavailable", "Comments are unavailable right now.") });
       try {
         const { comment } = await comments.createComment({
-          comment: { appId: BLOG_COMMENTS_APP_ID, contextId: s.id, resourceId: s.id, content: { richContent: commentRichContent(text) } },
+          comment: { appId: BLOG_COMMENTS_APP_ID, contextId: s.commentResourceId, resourceId: s.commentResourceId, content: { richContent: commentRichContent(text) } },
         });
         const created = blogCommentRow(comment);
         // Named to avoid shadowing the `comments` namespace import in this same block scope.

package/templates/community-club/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/community-club/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 };