@wix/himalaya-cli 0.1582.0 → 0.1584.0

package/templates/beauty-salon/himalaya.content.json

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

package/templates/beauty-salon/tier5-src/_shared/booking-location.ts

@@ -0,0 +1,147 @@
+// The member's chosen booking location, shared by the Services, Agenda and Choose Time
+// screens (Branded Lite bookings). Each screen has its own worker, so the choice lives in the
+// on-device store: one `booking_prefs` row, read when a screen loads and written when the member
+// picks a location. A bundle in an app that has not granted `local_database` (or has no
+// `booking_prefs` entity) falls back to "All locations" on every screen — every call is wrapped.
+//
+// Keys: a business location's id (the same id a Wix availability slot carries in
+// `location.id`), else "name|address" for a location with no id. "" is "All locations".
+
+import { get, upsert, type DbEntity } from "@himalaya/local-db";
+import { copyParam, copyTemplate } from "./himi-copy.js";
+
+export const BOOKING_PREFS_ENTITY = "booking_prefs";
+const LOCATION_ROW = "location";
+
+/** The shared choice: a location key ("" = every location) and the label it was chosen under. */
+export interface SharedLocation { id: string; label: string }
+
+export const ALL_LOCATIONS: SharedLocation = { id: "", label: "" };
+
+/** How long a screen's load waits for the store before it shows every location. */
+const READ_TIMEOUT_MS = 800;
+
+/** `promise`, or a rejection after `ms` where the host has a timer: a store call the native bridge
+ *  never answers must not hang a screen's load. Timer-less hosts get the raw promise. */
+function bounded<T>(promise: Promise<T>, ms: number): Promise<T> {
+  const host = globalThis as { setTimeout?: (fn: () => void, ms: number) => unknown; clearTimeout?: (timer: unknown) => void };
+  if (typeof host.setTimeout !== "function") return promise;
+  return new Promise<T>((resolve, reject) => {
+    const timer = host.setTimeout!(() => reject(new Error(`timed out after ${ms}ms`)), ms);
+    promise.then(
+      (v) => { try { host.clearTimeout?.(timer); } catch { /* best-effort */ } resolve(v); },
+      (e) => { try { host.clearTimeout?.(timer); } catch { /* best-effort */ } reject(e); },
+    );
+  });
+}
+
+/** The shared choice, or `undefined` when the store could not answer (no capability, no entity, a
+ *  bridge that never replied) — distinct from a stored "All locations", so a screen can keep its own
+ *  choice when the shared one is unknown rather than reset it. */
+export async function readSharedLocationResult(): Promise<SharedLocation | undefined> {
+  try {
+    const row = (await bounded(get(BOOKING_PREFS_ENTITY, LOCATION_ROW), READ_TIMEOUT_MS)) as { locationId?: unknown; locationLabel?: unknown } | null;
+    const id = typeof row?.locationId === "string" ? row.locationId : "";
+    const label = typeof row?.locationLabel === "string" ? row.locationLabel : "";
+    return { id, label };
+  } catch (err) {
+    console.warn("booking_prefs: the shared location could not be read", err);
+    return undefined;
+  }
+}
+
+/** The shared choice, "All locations" when it cannot be read. */
+export async function readSharedLocation(): Promise<SharedLocation> {
+  return (await readSharedLocationResult()) ?? ALL_LOCATIONS;
+}
+
+export async function writeSharedLocation(location: SharedLocation): Promise<void> {
+  try {
+    // Bounded like the read: a bridge that never answers must not hold a screen's action open.
+    await bounded(upsert(BOOKING_PREFS_ENTITY, { id: LOCATION_ROW, locationId: location.id, locationLabel: location.label } as DbEntity), READ_TIMEOUT_MS);
+  } catch { /* capability not granted: the choice stays on this screen */ }
+}
+
+/** One location a screen can filter by. */
+export interface LocationChoice { key: string; label: string; sub: string }
+
+type WixLocationLike = { id?: unknown; name?: unknown; formattedAddress?: unknown; address?: unknown; locationType?: unknown };
+
+/** A Wix location (a slot's `location`, or a service location's `business` / `custom` part) as a
+ *  choice. A location with neither a name nor an address has no key: it is not offered.
+ *
+ *  The key is what every bookings screen compares by, so it must come out the same from a service
+ *  location and from a slot at it: a BUSINESS location by its id (a slot carries that id); any other
+ *  place by its address, or its name when it has none — a custom place's slot carries no id, so the
+ *  service's custom id would match none of its sessions. `business` defaults to the slot's own
+ *  `locationType`. */
+export function locationChoice(loc: WixLocationLike | undefined, business?: boolean): LocationChoice {
+  const name = typeof loc?.name === "string" ? loc.name.trim() : "";
+  const rawAddress = loc?.formattedAddress ?? (loc?.address as { formattedAddress?: unknown } | undefined)?.formattedAddress;
+  const address = typeof rawAddress === "string" ? rawAddress.trim() : "";
+  const id = typeof loc?.id === "string" ? loc.id : "";
+  if (!name && !address) return { key: "", label: "", sub: "" };
+  const isBusiness = business ?? (loc?.locationType === "OWNER_BUSINESS" || loc?.locationType === "BUSINESS");
+  const key = isBusiness && id ? id : address ? `addr:${address.toLowerCase()}` : `name:${name.toLowerCase()}`;
+  return { key, label: name || address, sub: name && address ? address : "" };
+}
+
+/** The keys of a Wix service's own locations (business and custom), in the service's order. */
+export function serviceLocationChoices(locations: unknown): LocationChoice[] {
+  if (!Array.isArray(locations)) return [];
+  const out: LocationChoice[] = [];
+  for (const raw of locations) {
+    const l = (raw ?? {}) as { type?: unknown; business?: Record<string, unknown>; custom?: Record<string, unknown>; calculatedAddress?: Record<string, unknown> };
+    const business = l.type === "BUSINESS" || !!l.business;
+    const part = business ? l.business : l.custom;
+    const choice = locationChoice(part ? { ...part, address: part.address ?? l.calculatedAddress } : undefined, business);
+    if (choice.key && !out.some((c) => c.key === choice.key)) out.push(choice);
+  }
+  return out;
+}
+
+/** Distinct choices in first-seen order. */
+export function distinctChoices(choices: Iterable<LocationChoice>): LocationChoice[] {
+  const out: LocationChoice[] = [];
+  for (const c of choices) if (c.key && !out.some((o) => o.key === c.key)) out.push(c);
+  return out;
+}
+
+/** A row of the location sheet ("All locations" first). `id` "" is "All locations". */
+export interface LocationOptionRow {
+  id: string; label: string; sub: string; hasSub: boolean; noSub: boolean;
+  selected: boolean; notSelected: boolean; a11y: string;
+}
+
+/** The location menu's bound fields for a screen offering `choices` with `selectedKey` chosen.
+ *  Two or more choices show the menu; a selected key that is no longer offered reads as
+ *  "All locations" (the caller filters nothing for it either — see `effectiveLocation`). */
+export function locationMenu(choices: LocationChoice[], selectedKey: string): {
+  locationOptions: LocationOptionRow[]; locationLabel: string; locationA11y: string;
+  hasLocationMenu: boolean; noLocationMenu: boolean; locationActive: boolean; noLocationActive: boolean;
+} {
+  // bookingCommon.*: every bookings screen forwards that prefix, so a copy pack reaches each picker.
+  const all = copyParam("bookingCommon.allLocations", "All locations");
+  const key = effectiveLocation(choices, selectedKey);
+  const label = key ? (choices.find((c) => c.key === key)?.label ?? all) : all;
+  const menu = choices.length >= 2;
+  return {
+    locationOptions: menu ? [{ key: "", label: all, sub: "" }, ...choices].map((c) => {
+      const selected = c.key === key;
+      return { id: c.key, label: c.label, sub: c.sub, hasSub: !!c.sub, noSub: !c.sub, selected, notSelected: !selected,
+        a11y: [c.label, c.sub, selected ? copyParam("bookingCommon.selected", "Selected") : ""].filter(Boolean).join(", ") };
+    }) : [],
+    locationLabel: label,
+    locationA11y: copyTemplate("bookingCommon.locationLabel", "Location, {label}", { label }),
+    hasLocationMenu: menu,
+    noLocationMenu: !menu,
+    locationActive: menu && !!key,
+    noLocationActive: !(menu && !!key),
+  };
+}
+
+/** The key a screen filters by: the chosen one while the screen offers it (and offers a choice
+ *  at all), else "" — a location from another screen this one does not have filters nothing. */
+export function effectiveLocation(choices: LocationChoice[], selectedKey: string): string {
+  return selectedKey && choices.length >= 2 && choices.some((c) => c.key === selectedKey) ? selectedKey : "";
+}

package/templates/beauty-salon/tier5-src/_shared/booking-session.ts

@@ -0,0 +1,222 @@
+// One bookable session of a CLASS or COURSE service, and the member's place in it — shared by the
+// Agenda (one row per session) and the service screen opened from an Agenda row, so the two show the
+// same state and offer the same control for the same session.
+import { addDays, dayKey } from "@himalaya/time";
+import { listWaitlists, queryBookings, type WixAvailabilityEntry, type WixBooking, type WixService } from "@himalaya/wix-bookings";
+import { copyParam, copyTemplate } from "./himi-copy.js";
+import { slotStartInstant } from "./himi-bookings.js";
+import { formatServicePrice } from "./wix-service-price.js";
+import { assertMemberAccess, memberAccess, type MemberAccess } from "./member-access.js";
+import { locationChoice } from "./booking-location.js";
+
+/** A booking in one of these no longer holds a place. */
+const RELEASED = new Set(["CANCELED", "CANCELLED", "DECLINED"]);
+
+export type Place = "booked" | "waitlisted" | "";
+
+/** One session as the screen needs it. `key` is the row's identity: the Wix session id when the
+ *  entry has one — two sessions of a class at the same time are two rows — else service + start. */
+export interface Session {
+  key: string;
+  /** The Wix session id — what a waitlist registers against. "" when the entry has none. */
+  sessionId: string;
+  serviceId: string;
+  /** A class session is booked on its own; a course session belongs to a course booked whole. */
+  kind: "class" | "course";
+  title: string;
+  /** The service's fixed price ("₪60"), "" when it has none to show (varied, custom, free). */
+  price: string;
+  start: string; // ISO instant with offset
+  end: string;
+  day: string; // LOCAL day key
+  staff: string;
+  location: string;
+  /** The location as a filter choice (`booking-location.ts`): key "" when it has no name or address. */
+  locationKey: string;
+  locationSub: string;
+  total: number;
+  open: number;
+  bookable: boolean;
+  /** The session's waitlist: its size (0 = it has none) and the places left on it. */
+  waitlistTotal: number;
+  /** A booking policy closes it (too early, too late, online booking off): no Book, no Waitlist. */
+  policyClosed: boolean;
+  /** The ONLY policy reason is that booking has not opened yet ("Not open yet", not "Closed"). */
+  tooEarly: boolean;
+  waitlistOpen: number;
+}
+
+export interface MemberPlace { bookingId: string; revision: string; place: Place; registrationId?: string; confirmed?: boolean }
+
+const count = (v: unknown): number => {
+  const n = Number(v ?? 0);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+};
+
+/** A slot's instant as an ISO string WITH an offset — iOS parses wire dates strictly. */
+function instantIso(slot: { startDate?: string; timezone?: unknown }, field: "startDate" | "endDate"): string {
+  const ms = slotStartInstant({ startDate: (slot as Record<string, unknown>)[field] as string | undefined, timezone: slot.timezone });
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : "";
+}
+
+export const sessionKey = (serviceId: string, startIso: string): string => `${serviceId}|${Date.parse(startIso)}`;
+
+/** A raw availability entry → a Session, or null when it has no usable start. */
+export function sessionOf(entry: WixAvailabilityEntry, service: WixService): Session | null {
+  const slot = (entry.slot ?? {}) as Record<string, unknown> & { startDate?: string; endDate?: string; timezone?: unknown };
+  const start = instantIso(slot, "startDate");
+  if (!start) return null;
+  const end = instantIso(slot, "endDate") || start;
+  const raw = entry as unknown as {
+    totalSpots?: number; openSpots?: number; waitingList?: { totalSpots?: number; openSpots?: number };
+    bookingPolicyViolations?: { tooEarlyToBook?: boolean; tooLateToBook?: boolean; bookOnlineDisabled?: boolean; validSubmissionRequired?: boolean };
+  };
+  const policy = raw.bookingPolicyViolations;
+  const tooLate = policy?.tooLateToBook === true, offline = policy?.bookOnlineDisabled === true;
+  const tooEarly = policy?.tooEarlyToBook === true;
+  // A session that also needs a form submitted is not just "not open yet": it never opens for the app.
+  const needsForm = policy?.validSubmissionRequired === true;
+  const resource = slot.resource as { name?: string } | undefined;
+  const location = slot.location as { id?: string; name?: string; formattedAddress?: string } | undefined;
+  const choice = locationChoice(location);
+  const serviceId = String(slot.serviceId ?? service.id ?? "");
+  const sessionId = typeof slot.sessionId === "string" ? slot.sessionId : "";
+  return {
+    key: sessionId || sessionKey(serviceId, start),
+    sessionId,
+    serviceId,
+    kind: ((service as WixService & { type?: string }).type ?? "").toUpperCase() === "COURSE" ? "course" : "class",
+    title: service.name ?? "",
+    price: formatServicePrice(service),
+    start, end,
+    day: dayKey(start),
+    staff: resource?.name?.trim() ?? "",
+    location: (location?.name || location?.formattedAddress || "").trim(),
+    locationKey: choice.key,
+    locationSub: choice.sub,
+    total: count(raw.totalSpots),
+    open: count(raw.openSpots),
+    bookable: entry.bookable !== false,
+    waitlistTotal: count(raw.waitingList?.totalSpots),
+    waitlistOpen: count(raw.waitingList?.openSpots),
+    policyClosed: tooEarly || tooLate || offline || needsForm,
+    tooEarly: tooEarly && !tooLate && !offline && !needsForm,
+  };
+}
+
+/** The member's bookings in the window → their place, keyed by the booking's session id when it
+ *  names one, else by service + start. `bySession` turns that into each row's own key. */
+export function placesOf(bookings: WixBooking[], email: string): Map<string, MemberPlace> {
+  const out = new Map<string, MemberPlace>();
+  for (const b of bookings) {
+    if (!b.id || b.contactDetails?.email?.trim().toLowerCase() !== email) continue;
+    const status = (b.status || "").toUpperCase();
+    if (RELEASED.has(status)) continue;
+    const slot = b.bookedEntity?.slot;
+    const serviceId = slot?.serviceId ?? "";
+    const start = b.startDate || (slot ? instantIso(slot, "startDate") : "");
+    if (!serviceId || !start) continue;
+    // Its session when the booking names one, so a parallel session is not marked too.
+    const bookedSession = (slot as { sessionId?: unknown } | undefined)?.sessionId;
+    out.set(typeof bookedSession === "string" && bookedSession ? bookedSession : sessionKey(serviceId, start), {
+      bookingId: b.id,
+      revision: String((b as WixBooking & { revision?: string | number }).revision ?? ""),
+      place: status === "WAITING_LIST" ? "waitlisted" : "booked",
+      confirmed: status === "CONFIRMED",
+    });
+  }
+  return out;
+}
+
+/** Each session's place, under the session's own key: by its session id, else by service + start. */
+export function bySession(found: Map<string, MemberPlace>, inWindow: Session[]): Map<string, MemberPlace> {
+  const out = new Map<string, MemberPlace>();
+  for (const x of inWindow) {
+    const place = (x.sessionId ? found.get(x.sessionId) : undefined) ?? found.get(sessionKey(x.serviceId, x.start));
+    if (place) out.set(x.key, place);
+  }
+  return out;
+}
+
+/** "4 spots left", "1 spot left", or "Full". Empty when the site reports no capacity, and for a
+ *  course: a session's open spots do not say whether the course has room. */
+export function spotsLabel(s: Session): string {
+  if (s.kind === "course" || s.total <= 0) return "";
+  if (s.open <= 0) return copyParam("agenda.full", "Full");
+  return s.open === 1 ? copyParam("agenda.spotLeft", "1 spot left") : copyTemplate("agenda.spotsLeft", "{n} spots left", { n: s.open });
+}
+
+/** The one control a session offers the member, as the Agenda row shows it. */
+export type SessionControl = "book" | "waitlist" | "course" | "booked" | "waitlisted" | "closed";
+
+/** Which control `s` offers to a member holding `place`, and — for "closed" — why ("Full",
+ *  "Not open yet", "Closed"). A course is booked whole on its service screen: "course". */
+export function sessionControl(s: Session, place: MemberPlace | undefined): { control: SessionControl; closedLabel: string; full: boolean } {
+  const mine = place?.place ?? "";
+  const course = s.kind === "course";
+  const full = s.total > 0 && s.open <= 0;
+  const closedLabel = full ? copyParam("agenda.full", "Full")
+    : s.tooEarly ? copyParam("agenda.notOpenYet", "Not open yet") : copyParam("agenda.closed", "Closed");
+  if (mine === "booked") return { control: "booked", closedLabel, full };
+  if (mine === "waitlisted") return { control: "waitlisted", closedLabel, full };
+  if (course) return { control: "course", closedLabel, full };
+  if (s.bookable && !full && !s.policyClosed) return { control: "book", closedLabel, full };
+  // Availability is capacity AND policy: a full session the policy closes is not joinable either.
+  if (full && s.waitlistOpen > 0 && !!s.sessionId && !s.policyClosed) return { control: "waitlist", closedLabel, full };
+  return { control: "closed", closedLabel, full };
+}
+
+/** Mark the places that are WAITLIST registrations, with the registration id leaving needs.
+ *  A registration's booking is an ordinary pending booking, so the booking alone cannot say
+ *  "on the waitlist" — only the session's waitlist can, and only sessions with one are asked. */
+export function markWaitlisted(found: Map<string, MemberPlace>, sessionsByKey: Map<string, Session>, lists: { waitingResource?: string; registrations?: { id?: string; bookingId?: string }[] }[]): void {
+  const byBooking = new Map<string, string>();
+  for (const list of lists) for (const r of list.registrations ?? []) if (r.bookingId && r.id) byBooking.set(r.bookingId, r.id);
+  for (const [key, place] of found) {
+    const registrationId = byBooking.get(place.bookingId);
+    if (registrationId && sessionsByKey.has(key)) found.set(key, { ...place, place: "waitlisted", registrationId });
+  }
+}
+
+/** The signed-in member's bookings in the window, with the member they were read for: the two
+ *  are committed together, so a write checks against the member its place belongs to. A visitor
+ *  has none; a read that fails fails the load. */
+export async function placesIn(start: string, end: string, inWindow: Session[], attempt = 0): Promise<{ who: MemberAccess | undefined; found: Map<string, MemberPlace> }> {
+  const who = await memberAccess().catch(() => undefined);
+  if (!who?.email) return { who, found: new Map() };
+  try {
+    const from = new Date(`${start}T00:00:00`).toISOString();
+    const to = new Date(`${dayKey(addDays(end, 1))}T00:00:00`).toISOString();
+    // Every page, not the first 100: a booking past it would read Book again. Bounded.
+    const bookings: WixBooking[] = [];
+    for (let page = 0; page < 5; page++) {
+      const res = await queryBookings({ query: { filter: { "contactDetails.email": { $eq: who.email }, startDate: { $gte: from, $lt: to } }, paging: { limit: 100, offset: page * 100 } } } as never);
+      const batch = res.bookings ?? [];
+      bookings.push(...batch);
+      if (batch.length < 100) break;
+    }
+    // The same member still? A sign-out or a switch during the read must not paint one member's
+    // bookings for another (the shared member-bookings read checks the same way).
+    await assertMemberAccess(who);
+    const found = bySession(placesOf(bookings, who.email), inWindow);
+    const byKey = new Map(inWindow.map((x) => [x.key, x] as const));
+    const waitlisted = [...found.keys()].map((k) => byKey.get(k)).filter((x): x is Session => !!x && x.waitlistTotal > 0 && !!x.sessionId);
+    if (waitlisted.length) {
+      // Only the session's waitlist can tell a waitlist place from a pending booking. If it cannot
+      // be read, that place is neither Booked nor free: the load fails (error state, Retry) rather
+      // than offer Book or Waitlist on a session the member already holds.
+      markWaitlisted(found, byKey, (await listWaitlists(waitlisted.map((x) => x.sessionId))).list ?? []);
+      // The lookup awaited too: still the same member?
+      await assertMemberAccess(who);
+    }
+    return { who, found };
+  } catch (err) {
+    // A failed read is not "no bookings": showing Book on a session the member holds invites a
+    // duplicate. It fails the load (the error state, with Retry), as My Bookings does.
+    if ((err as { name?: string } | null)?.name !== "MemberAccessChanged") throw err;
+    // A sign-out or a switch during the read: read again, for whoever is signed in now — never
+    // commit them with places nobody read for them. A second switch fails the load.
+    if (attempt < 1) return placesIn(start, end, inWindow, attempt + 1);
+    throw err;
+  }
+}

package/templates/beauty-salon/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/beauty-salon/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/beauty-salon/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/beauty-salon/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;
+}