@wix/himalaya-cli 0.1583.0 → 0.1585.0

package/templates/gym-fitness/himalaya.content.json

@@ -70,6 +70,9 @@
     "himi_my_subscriptions": {
       "displayName": "My Subscriptions"
     },
+    "himi_notif_settings": {
+      "displayName": "Notif Settings"
+    },
     "himi_order": {
       "displayName": "Order"
     },

package/templates/gym-fitness/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/gym-fitness/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/gym-fitness/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/gym-fitness/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/gym-fitness/tier5-src/_shared/owner-editor-value.ts

@@ -0,0 +1,164 @@
+// [rico] #3371 — how an owner form reads a RichContentEditor out of `submit(s, values)`.
+//
+// The editor writes its Ricos document into the Form's value bag as a JSON STRING under its `name`,
+// on every change and again on blur. The value is ABSENT when the editor never became ready (the
+// engine page is not bundled, failed, or timed out): the stored body must then stay exactly as it is
+// (user decision, 2026-09-26 — save everything but the body). A document is written exactly as the
+// editor produced it: never re-encoded (encodeRichContent is the VIEWER's; it rewrites media ids and
+// drops nodes the owner never touched).
+// Inside the platform source this import is a relative path, so node test runs resolve it; an app's
+// copy imports "@himalaya/wix-rich-content".
+import { parseRicosJson, isPlainRicos, richContentOverLimits, type RicosDocument } from "@himalaya/wix-rich-content";
+
+export type EditorValue =
+  | { kind: "absent" }                                  // leave the stored body untouched
+  | { kind: "unchanged" }                               // byte-identical to the seed: nothing to write
+  | { kind: "doc"; doc: RicosDocument; json: string }   // write `doc`; `json` is the editor's own string
+  | { kind: "too_large" }                               // past the rich-content limits: save the rest, say why
+  | { kind: "invalid" };                                // not a Ricos document: refuse, write nothing
+
+const TEXT_ONLY = new Set(["PARAGRAPH", "TEXT", "HEADING", "BULLETED_LIST", "ORDERED_LIST", "LIST_ITEM", "BLOCKQUOTE", "CODE_BLOCK"]);
+/** No visible text and no non-text node (an image, a divider, an embed…): an empty body. */
+export function isEmptyDocument(doc: RicosDocument): boolean {
+  const empty = (nodes: RicosDocument["nodes"] | undefined): boolean => (nodes ?? []).every((n) =>
+    TEXT_ONLY.has(String(n?.type)) && !String(n.textData?.text ?? "").trim() && empty(n.nodes));
+  return empty(doc.nodes);
+}
+
+/** A Ricos JSON string checked as every viewer would: the limits first, then the shape. */
+function checkedDocument(raw: string): EditorValue {
+  // Every viewer renders a body past the limits as its fallback, so it is never written. One parse
+  // feeds both checks; a string past the byte limit is refused before it is parsed at all.
+  if (richContentOverLimits(raw, null) === "too_large") return { kind: "too_large" };
+  const doc = parseRicosJson(raw);
+  if (!doc) return { kind: "invalid" };
+  return richContentOverLimits(raw, doc) ? { kind: "too_large" } : { kind: "doc", doc, json: raw };
+}
+
+/** `raw` is `values[name]`; `seededJson` is the string the form published as the editor's seed. */
+export function editorValue(raw: unknown, seededJson: string): EditorValue {
+  if (typeof raw !== "string" || raw === "") return { kind: "absent" };
+  if (seededJson !== "" && raw === seededJson) return { kind: "unchanged" };
+  const checked = checkedDocument(raw);
+  // An empty editor over no body (a record that had none) writes nothing, rather than an empty document.
+  if (checked.kind === "doc" && seededJson === "" && isEmptyDocument(checked.doc)) return { kind: "unchanged" };
+  return checked;
+}
+
+// ── The per-field editor machinery every owner form shares (post body, event / product description,
+// FAQ answer). Each form keeps `<key>Json` (the seed), `<key>Pending` and `<key>Dirty` in its state.
+
+/** `<key>Pending`: until this run's load lands, the descriptor hides the editor — it seeds ONCE, so a
+ *  provisional editor the owner typed into would keep that text over the real document.
+ *  `<key>Dirty`: the editor's on_change fired since the field was loaded or saved. Once ready the bag
+ *  ALWAYS holds a document — the engine's own re-serialization of the seed, not byte-equal to it — so
+ *  only this says the owner edited the field. Every arm fires a pending on_change before it releases a
+ *  Form submit, so an edit made inside the debounce window is reported before the submit reads it. */
+export interface EditorGate { pending: boolean; dirty: boolean }
+
+/** What a live submit does with `values[name]`: only an edit the editor reported counts. */
+export function editorSubmitValue(raw: unknown, seededJson: string, gate: EditorGate): EditorValue {
+  return gate.pending || !gate.dirty ? { kind: "absent" } : editorValue(raw, seededJson);
+}
+
+/** A queued write's document. A replay runs in a FRESH worker with no editor, so the string is checked
+ *  again (shape and limits); "absent" when the item carries none. Never "unchanged": it was an edit. */
+export function queuedDocument(raw: unknown): EditorValue {
+  return typeof raw === "string" && raw !== "" ? checkedDocument(raw) : { kind: "absent" };
+}
+
+/** The editor's on_change: the field is now edited, and a confirmation of an earlier save is stale.
+ *  No timing window: an arm fires the pending on_change BEFORE it releases a submit, so any on_change
+ *  that arrives after a save carries an edit that save did not write. */
+export function editorChanged<S extends { status: string; savedMessage: string }>(s: S): Pick<S, "status" | "savedMessage"> {
+  return { status: s.status === "saved" ? "idle" : s.status, savedMessage: "" };
+}
+
+/** The offline cache's verdict on the stored body (`<key>Protected`): rich unless KNOWN plain. From the
+ *  document when the form knows it; otherwise plain only when the record was loaded as plain. A bundle
+ *  rolled back past the editor reads this flag to decide whether its plain field may overwrite the body. */
+export function cachedRichVerdict(doc: RicosDocument | null, knownPlain: boolean): "true" | "false" {
+  if (doc) return isPlainRicos(doc) ? "false" : "true";
+  return knownPlain ? "false" : "true";
+}
+
+/** The keys of one editor field that describe THIS run, never the last one: the seed (`<key>Json`),
+ *  the load gate (`<key>Pending`), the edit flag (`<key>Dirty`) and its counter (`<key>Edits`). A form
+ *  lists them in `defineService(name, { notHydrated })`, so a cold boot takes their DECLARED values: the
+ *  editor seeds once, and a persisted seed would be painted as its content and saved back over a newer
+ *  record. */
+export function editorRunKeys<K extends string>(key: K): [`${K}Json`, `${K}Pending`, `${K}Dirty`, `${K}Edits`] {
+  return [`${key}Json`, `${key}Pending`, `${key}Dirty`, `${key}Edits`];
+}
+
+/** Does the form already hold `target` with its editor run in progress? A `load` for it then keeps the form as
+ *  it is: on the way back to a warm worker (its refresh and onAppear) a re-read would race an edit in flight and
+ *  reset the reported edit, and the editor, which seeds once, would show another document than the state holds.
+ *  An edit form holds its record once the editor loaded; a create form holds a draft once the owner edited. */
+export function holdsLoadedForm(state: object, target: { id: string; mode: string }, key: string): boolean {
+  const s = state as Record<string, unknown>;
+  if (s.status === 'error' || s.error || s.mode !== target.mode || (s.id ?? '') !== target.id) return false;
+  return target.mode === 'create' ? s[`${key}Dirty`] === true || Number(s[`${key}Edits`] ?? 0) > 0 : s[`${key}Pending`] === false;
+}
+
+/** The same keys on a runtime that ignores `notHydrated` (a binary from before #3644, still served new
+ *  bundles over the air): reset them in place, before any action runs. A no-op where the runtime
+ *  honours the option (`himalaya.hydrationOptOut`). */
+export function resetHydratedEditorOnOlderRuntime(svc: unknown, key: string, pendingAtBoot: boolean, extra: Record<string, unknown> = {}): void {
+  if ((globalThis as { himalaya?: { hydrationOptOut?: unknown } }).himalaya?.hydrationOptOut === true) return;
+  const booted = (svc as { getState?: () => Record<string, unknown> | undefined }).getState?.();
+  if (!booted || typeof booted !== "object") return;
+  if (booted[`${key}Json`]) booted[`${key}Json`] = "";
+  booted[`${key}Pending`] = pendingAtBoot;
+  booted[`${key}Dirty`] = false;
+  booted[`${key}Edits`] = 0;
+  Object.assign(booted, extra);
+}
+
+/** What an awaited save leaves the field as, read from the LIVE state when it lands. An on_change that
+ *  arrived while the save was in flight (`<key>Edits` moved) is an edit the save did not write: the
+ *  field stays dirty and the save's confirmation is stale. Otherwise a save that wrote the field
+ *  re-bases it as saved. `live` is the service's state now (none, or one that never moved: the start state). */
+export function editorAfterSave(key: string, start: Record<string, unknown>, live: Record<string, unknown> | undefined, wrote: boolean):
+  { dirty: boolean; edits: number; editedDuringSave: boolean } {
+  const atStart = Number(start[`${key}Edits`] ?? 0);
+  const now = Number(live?.[`${key}Edits`] ?? atStart);
+  // Only a counter that MOVED ON counts; one behind the start is a host that does not apply results.
+  const editedDuringSave = now > atStart;
+  return editedDuringSave
+    ? { dirty: true, edits: now, editedDuringSave }
+    : { dirty: wrote ? false : Boolean(start[`${key}Dirty`]), edits: atStart, editedDuringSave };
+}
+
+/** The live state of a service handle, when the runtime gives one. */
+export function liveState(svc: unknown): Record<string, unknown> | undefined {
+  const st = (svc as { getState?: () => unknown } | undefined)?.getState?.();
+  return st && typeof st === "object" ? st as Record<string, unknown> : undefined;
+}
+
+/** An awaited action's result, laid over the LIVE state: only the keys the action CHANGED (against the
+ *  state it started from) are written, so anything the owner did while it awaited — an edit, a field in
+ *  the details sheet, closing the sheet — survives a save that lands after it, success or failure. A
+ *  key both changed goes to the action. Where the host gives no live state, the result as it is. */
+/** An awaited load's result, unless the form moved to another record while it read. On a warm return the host's bare
+ *  refresh and the screen's onAppear run together: after a save the refresh fetches the record just saved while the
+ *  onAppear of a create screen opens a blank form, and the refresh landing last turned the new form into that record's
+ *  edit. Nothing lands then (`undefined`, the runtime's no-op), nor from a load that changes nothing: started with the
+ *  same state as the onAppear, it would put back the record that one replaced. A load for the record the form still
+ *  holds lands as it is; so does any load where the host gives no live state. */
+export function landsOnLive<S extends object>(svc: unknown, start: S, result: S): S | undefined {
+  if (result === start) return undefined;
+  const now = liveState(svc);
+  if (!now || now === start) return result;
+  const s0 = start as Record<string, unknown>;
+  return now.id !== s0.id || now.mode !== s0.mode ? undefined : result;
+}
+
+export function settleOverLive<S extends object>(svc: unknown, start: S, result: S): S {
+  const now = liveState(svc) as S | undefined;
+  if (!now || now === start || now === result) return result;
+  const out = { ...now } as Record<string, unknown>;
+  const r = result as Record<string, unknown>, s0 = start as Record<string, unknown>;
+  for (const k of Object.keys(r)) if (!Object.is(r[k], s0[k])) out[k] = r[k];
+  return out as S;
+}

package/templates/gym-fitness/tier5-src/_shared/store-product-info.ts

@@ -0,0 +1,50 @@
+import type { StoreProduct } from "./himi-store.js";
+import { cleanTitle } from "./himi-text.js";
+import { descriptionBody } from "./rich-body.js";
+import { isEmptyDocument } from "./owner-editor-value.js";
+
+/** V3 returns only section ids and titles for `INFO_SECTION`; the rich and HTML bodies
+ *  are separate fields. `DESCRIPTION` keeps the product's own Ricos description. A V1
+ *  catalog ignores all of these. */
+export const PRODUCT_DETAIL_FIELDS = ["DESCRIPTION", "INFO_SECTION", "INFO_SECTION_DESCRIPTION", "INFO_SECTION_PLAIN_DESCRIPTION"] as const;
+
+export interface ProductInfoSection {
+  id: string;
+  title: string;
+  body: string;
+  bodyJson: string;
+  hasBodyJson: boolean;
+  noTitle: boolean;
+  expanded: boolean;
+  collapsed: boolean;
+}
+
+/** Keep authored order and bodies; retain expansion only where the source identity is unambiguous. */
+export function productInfoSections(product: StoreProduct, previous: ProductInfoSection[]): ProductInfoSection[] {
+  const expanded = new Map(previous.map(section => [section.id, section.expanded]));
+  const occurrences = new Map<string, number>();
+  const sections = [...(product.infoSections ?? []), ...(product.additionalInfoSections ?? [])];
+  const titles = sections.map(section => cleanTitle(section.title));
+  const titleCounts = new Map<string, number>();
+  const previousTitleCounts = new Map<string, number>();
+  for (const title of titles) titleCounts.set(title, (titleCounts.get(title) ?? 0) + 1);
+  for (const section of previous) previousTitleCounts.set(section.title, (previousTitleCounts.get(section.title) ?? 0) + 1);
+  return sections.flatMap((section, index) => {
+    const title = titles[index];
+    const sourceId = "uniqueName" in section ? section.uniqueName?.trim() : "";
+    const key = sourceId || title;
+    const occurrence = occurrences.get(key) ?? 0;
+    occurrences.set(key, occurrence + 1);
+    const id = `info:${key}:${occurrence}`;
+    const fallback = descriptionBody("plainDescription" in section ? section.plainDescription : "").bodyText;
+    const rich = descriptionBody(section.description, fallback);
+    const body = rich.bodyText.trim() ? rich.bodyText : fallback;
+    // The bounded encoder can keep an empty paragraph. It must not hide real plain instructions.
+    const bodyJson = rich.bodyJson && !isEmptyDocument(JSON.parse(rich.bodyJson)) ? rich.bodyJson : "";
+    if (!body && !bodyJson) return [];
+    // V1 supplies no section id: duplicate titles cannot safely carry expansion through a refresh.
+    const mayKeepExpanded = !!sourceId || (titleCounts.get(title) === 1 && (previousTitleCounts.get(title) ?? 0) < 2);
+    const opened = !title || (mayKeepExpanded && (expanded.get(id) ?? false));
+    return [{ id, title, body, bodyJson, hasBodyJson: !!bodyJson, noTitle: !title, expanded: opened, collapsed: !opened }];
+  });
+}

package/templates/gym-fitness/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/gym-fitness/tier5-src/himi-branded-lite-category/index.ts

@@ -1,3 +1,4 @@
+import { descriptionBody } from "../_shared/rich-body.js";
 // A category-scoped Shop gallery. Reuses Shop's card projection, filters, saved
 // products, view preferences and App Store price presentation; the route remains
 // himi_collection { id }. Never substitute the full catalog for a missing category.
@@ -117,12 +118,12 @@ const actions = {
         const category = (await getStoreCategory(id)).category;
         if (version !== loadVersion) return undefined;
         if (!category?.id && !category?.name) return derive({ ...s, ...presence("missing"), loadId: version });
-        header = { name: category.name ?? "", subtitle: categoryCount(category), description: category.description ?? "" };
+        header = { name: category.name ?? "", subtitle: categoryCount(category), description: descriptionBody(category.description).bodyText };
       } catch {
         const category = (await getCollection(id)).collection;
         if (version !== loadVersion) return undefined;
         if (!category) return derive({ ...s, ...presence("missing"), loadId: version });
-        header = { name: category.name ?? "", subtitle: "", description: category.description ?? "" };
+        header = { name: category.name ?? "", subtitle: "", description: descriptionBody(category.description).bodyText };
       }
     } catch (error) {
       if (version !== loadVersion) return undefined;