@wix/himalaya-cli 0.1530.0 → 0.1532.0

package/templates/beauty-salon/tier5-src/himi-branded-lite-agenda/index.ts

@@ -1,22 +1,28 @@
-// himi-branded-lite-agenda — the Bookings Agenda: every upcoming CLASS session of the site,
-// under a collapsible week/month calendar.
+// himi-branded-lite-agenda — the Bookings Agenda: every upcoming CLASS and COURSE session of the
+// site, under a collapsible week/month calendar.
 //
 // Everyone sees the whole schedule. A signed-in member also sees their own place in it: a
 // session they booked reads "Booked", one they wait for reads "On waitlist", and each opens
-// a sheet to view the session or cancel / leave. A full session with waitlist room offers
-// "Waitlist"; a full one without, or one outside the booking window, says so instead of
-// offering a Book that would fail.
+// a sheet to add it to the calendar, view the class, or cancel / leave. A full session with
+// waitlist room offers "Join Waitlist"; a full one without, or one outside the booking window,
+// says so ("Full", "Not open yet", "Closed") instead of offering a Book that would fail.
 //
 // Appointment services are left out on purpose: their availability is every free slot of
-// the day, which is a booking grid, not an agenda of things that happen. Courses are left out
-// too: a course is booked as a whole, never one session, and Wix serves its sessions through
-// the course flow rather than the class availability this screen reads.
+// the day, which is a booking grid, not an agenda of things that happen. Course sessions are
+// listed, tagged "Course", but a course is booked as a whole on its service screen, never one
+// session: its row offers "View Course", and shows no spots (a session's open spots do not say
+// whether the course has room).
+//
+// Action results (joined, cancelled, left, added to the calendar, or a failure) show in a
+// non-modal sheet above the tab bar, so a member scrolled far down the list still sees them.
 //
 // The calendar marks every day with a session (one dot) and today (its own ring). The list
 // starts at the selected day, so a day with nothing on it shows the next sessions instead
 // of an empty page — the agenda answers "what is on from here".
 import { defineService, navigate } from "@himalaya/state";
-import { addDays, dayKey, toDate, weekOf, type DayDecoration, type Weekday } from "@himalaya/time";
+import { addDays, dayKey, dayLabel, timeLabel, toDate, weekOf, type DayDecoration, type Weekday } from "@himalaya/time";
+import { createEvent, getPermissionStatus, requestPermission } from "@himalaya/calendar";
+import { open } from "@himalaya/open-url";
 import {
   cancelBookingAsMember, isBookingPolicyViolation, leaveWaitlist, listWaitlists, queryBookings, queryServiceAvailability,
   queryServices, registerToWaitlist, type WixAvailabilityEntry, type WixBooking, type WixService,
@@ -25,6 +31,7 @@ import { getMyMember } from "@himalaya/wix-members";
 import { LOADING, loadFailed, type LoadFlags } from "../_shared/branded-load-state.js";
 import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
 import { slotStartInstant } from "../_shared/himi-bookings.js";
+import { formatServicePrice } from "../_shared/wix-service-price.js";
 import { compareText } from "../_shared/engine-intl.js";
 import { assertMemberAccess, memberAccess, memberAccessChanged, type MemberAccess } from "../_shared/member-access.js";
 import { atLeast } from "../_shared/member-account-routes.js";
@@ -32,8 +39,9 @@ import { get as getAppInfo } from "@himalaya/app-info";
 
 /** How far past the selected day the list reaches. */
 export const AGENDA_DAYS = 28;
-/** Services whose sessions are fixed events, each booked on its own. */
-const SESSION_TYPES = new Set(["CLASS"]);
+/** Services whose sessions are fixed events: a class's are each booked on their own, a course's
+ *  are listed but the course is booked as a whole (on its service screen). */
+const SESSION_TYPES = new Set(["CLASS", "COURSE"]);
 /** A booking in one of these no longer holds a place. */
 const RELEASED = new Set(["CANCELED", "CANCELLED", "DECLINED"]);
 
@@ -46,7 +54,11 @@ export interface Session {
   /** 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
@@ -59,6 +71,8 @@ export interface Session {
   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;
 }
 
@@ -87,18 +101,38 @@ interface S extends LoadFlags {
   decorations: DayDecoration[];
   events: AgendaEvent[];
   scrollTo: string;
-  emptyText: string;
-  message: string;
   signedIn: boolean;
   /** An older Android binary: its Agenda drops each row's fields, so the list is replaced by a
    *  line asking to update. */
   updateRequired: boolean;
-  /** The list is hidden while loading or failed, and when an update is required. */
+  /** The update-required line — a state of the screen, not an action's result. */
+  updateMessage: string;
+  /** The list is hidden while loading or failed, when an update is required, and when it is empty. */
   listHidden: boolean;
+  /** Loaded, and the site has no class or course at all. */
+  noClasses: boolean;
+  /** Loaded, the site has classes, but none from the selected day to the end of the loaded days. */
+  nothingAhead: boolean;
+  /** The negations a `hiddenPath` reads: each empty state shows only when its own flag is set. */
+  notNoClasses: boolean;
+  notNothingAhead: boolean;
+  // The result sheet: one action's outcome, non-modal, above the tab bar. Two slots that take turns
+  // (A = resultOpen, B = resultOpenB): each new result presents in the other one, so it gets its own
+  // eight-second countdown rather than the rest of the previous result's.
+  resultOpen: boolean;
+  resultOpenB: boolean;
+  resultText: string;
+  /** It went through (a check) … */
+  resultOk: boolean;
+  /** … or it did not, or needs the member (an info mark). Exactly one is false while open. */
+  resultInfo: boolean;
   // The session sheet (Booked / On waitlist).
   sheetOpen: boolean;
   sheetTitle: string;
   sheetWhen: string;
+  sheetMeta: string;
+  /** Add to Calendar is for a booked session only. */
+  sheetHideCalendar: boolean;
   sheetHideCancel: boolean;
   sheetHideLeave: boolean;
   sheetBusy: boolean;
@@ -106,24 +140,19 @@ interface S extends LoadFlags {
 
 const flag = (on: boolean): string => (on ? "true" : "");
 
-/** "14:30" in the device's 24h/12h convention-neutral form the reference uses. */
-function clock(iso: string): string {
-  const d = toDate(iso);
-  if (!d) return "";
-  return `${d.getHours()}:${String(d.getMinutes()).padStart(2, "0")}`;
-}
-
-/** "(1h)", "(30m)", "(1h 30m)" — the length under the time. */
+/** "1 hr", "45 min", "1 hr 30 min" — the length under the time. */
 export function lengthLabel(start: string, end: string): string {
   const mins = Math.round((Date.parse(end) - Date.parse(start)) / 60_000);
   if (!Number.isFinite(mins) || mins <= 0) return "";
   const h = Math.floor(mins / 60), m = mins % 60;
-  const body = h && m
-    ? copyTemplate("agenda.lengthHoursMinutes", "{h}h {m}m", { h, m })
-    : h ? copyTemplate("agenda.lengthHours", "{h}h", { h }) : copyTemplate("agenda.lengthMinutes", "{m}m", { m });
-  return `(${body})`;
+  return h && m
+    ? copyTemplate("agenda.lengthHoursMinutes", "{h} hr {m} min", { h, m })
+    : h ? copyTemplate("agenda.lengthHours", "{h} hr", { h }) : copyTemplate("agenda.lengthMinutes", "{m} min", { m });
 }
 
+/** The parts that are known, joined by a middle dot: "Omer Levi · Studio Zen". */
+const joined = (...parts: string[]): string => parts.filter(Boolean).join(" · ");
+
 /** 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 });
@@ -140,9 +169,13 @@ export function sessionOf(entry: WixAvailabilityEntry, service: WixService): Ses
   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 };
+    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 { name?: string; formattedAddress?: string } | undefined;
   const serviceId = String(slot.serviceId ?? service.id ?? "");
@@ -151,7 +184,9 @@ export function sessionOf(entry: WixAvailabilityEntry, service: WixService): Ses
     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() ?? "",
@@ -161,7 +196,8 @@ export function sessionOf(entry: WixAvailabilityEntry, service: WixService): Ses
     bookable: entry.bookable !== false,
     waitlistTotal: count(raw.waitingList?.totalSpots),
     waitlistOpen: count(raw.waitingList?.openSpots),
-    policyClosed: policy?.tooEarlyToBook === true || policy?.tooLateToBook === true || policy?.bookOnlineDisabled === true,
+    policyClosed: tooEarly || tooLate || offline || needsForm,
+    tooEarly: tooEarly && !tooLate && !offline && !needsForm,
   };
 }
 
@@ -199,22 +235,26 @@ export function bySession(found: Map<string, MemberPlace>, inWindow: Session[]):
   return out;
 }
 
-/** "1/12" booked-of-capacity, or "Full". Empty when the site reports no capacity. */
-function capacityLabel(s: Session): string {
-  if (s.total <= 0) return "";
+/** "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. */
+function spotsLabel(s: Session): string {
+  if (s.kind === "course" || s.total <= 0) return "";
   if (s.open <= 0) return copyParam("agenda.full", "Full");
-  return `${s.total - s.open}/${s.total}`;
+  return s.open === 1 ? copyParam("agenda.spotLeft", "1 spot left") : copyTemplate("agenda.spotsLeft", "{n} spots left", { n: s.open });
 }
 
-/** One session → one Agenda row. Exactly one of the trailing states is visible. */
+/** One session → one Agenda row. Exactly one of the trailing controls is visible. */
 export function eventOf(s: Session, place: MemberPlace | undefined): AgendaEvent {
   const mine = place?.place ?? "";
+  const course = s.kind === "course";
   const full = s.total > 0 && s.open <= 0;
-  const canBook = !mine && s.bookable && !full && !s.policyClosed;
+  // A course is booked whole on its service screen: its sessions offer View Course, never Book.
+  const canBook = !course && !mine && s.bookable && !full && !s.policyClosed;
   // Availability is capacity AND policy: a full session the policy closes is not joinable either.
-  const canWait = !mine && full && s.waitlistOpen > 0 && !!s.sessionId && !s.policyClosed;
-  const closed = !mine && !canBook && !canWait;
-  const capacity = capacityLabel(s);
+  const canWait = !course && !mine && full && s.waitlistOpen > 0 && !!s.sessionId && !s.policyClosed;
+  const viewCourse = course && !mine;
+  const closed = !course && !mine && !canBook && !canWait;
+  const time = timeLabel(s.start);
   return {
     id: s.key,
     title: s.title,
@@ -224,19 +264,24 @@ export function eventOf(s: Session, place: MemberPlace | undefined): AgendaEvent
       serviceId: s.serviceId,
       // Choose Time opens on THIS session: two of a class can start at the same time.
       sessionId: s.sessionId,
-      time: clock(s.start),
+      time,
       length: lengthLabel(s.start, s.end),
-      staff: s.staff ? copyTemplate("agenda.withStaff", "With {name}", { name: s.staff }) : "",
-      capacity,
-      noCapacity: flag(!capacity),
-      location: s.location,
-      noLocation: flag(!s.location),
+      meta: joined(s.staff, s.location),
+      availability: joined(s.price, spotsLabel(s)),
+      isCourse: flag(course),
+      notCourse: flag(!course),
+      detailsA11y: s.staff
+        ? copyTemplate("agenda.detailsA11y", "{title}, {time}, with {staff}", { title: s.title, time, staff: s.staff })
+        : [s.title, time].filter(Boolean).join(", "),
+      bookA11y: copyTemplate("agenda.bookA11y", "Book {title}, {time}", { title: s.title, time }),
       hideBook: flag(!canBook),
       hideWaitlist: flag(!canWait),
+      hideCourse: flag(!viewCourse),
       hideBooked: flag(mine !== "booked"),
       hideOnWaitlist: flag(mine !== "waitlisted"),
       hideClosed: flag(!closed),
-      closedLabel: full ? copyParam("agenda.full", "Full") : copyParam("agenda.closed", "Closed"),
+      closedLabel: full ? copyParam("agenda.full", "Full")
+        : s.tooEarly ? copyParam("agenda.notOpenYet", "Not open yet") : copyParam("agenda.closed", "Closed"),
     },
   };
 }
@@ -328,6 +373,20 @@ export function keepsSelection(cur: { today: string; selectedDate: string }, sta
   return !!cur.today && cur.selectedDate === cur.today && cur.today >= start && cur.today <= end;
 }
 
+function calendarStamp(ms: number): string {
+  return new Date(ms).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+
+/** The Google Calendar template page for a session — the fallback when the device calendar is
+ *  refused or creates nothing. `encodeURIComponent`, never URLSearchParams: the iOS / macOS
+ *  worker engine (JavaScriptCore) does not provide it (see himi-events-detail). */
+export function calendarFallbackUrl(session: Pick<Session, "title" | "location" | "staff">, start: number, end: number): string {
+  const parts = ["action=TEMPLATE", `text=${encodeURIComponent(session.title)}`, `dates=${calendarStamp(start)}/${calendarStamp(end)}`];
+  if (session.location) parts.push(`location=${encodeURIComponent(session.location)}`);
+  if (session.staff) parts.push(`details=${encodeURIComponent(session.staff)}`);
+  return `https://calendar.google.com/calendar/render?${parts.join("&")}`;
+}
+
 // ── loading ──────────────────────────────────────────────────────────────────
 
 let services: WixService[] | null = null;
@@ -337,6 +396,9 @@ let loadedWindow = { start: "", end: "" };
 let member: MemberAccess | undefined;
 let sheetKey = "";
 let busy = false;
+/** An Add to Calendar flow is running (a permission prompt, a save, the calendar page). Its own
+ *  flag, not `busy`: the session sheet must still close while it runs. */
+let calendarBusy = false;
 
 async function sessionServices(): Promise<WixService[]> {
   if (services) return services;
@@ -452,28 +514,65 @@ async function memberName(): Promise<{ firstName?: string; lastName?: string }>
   return { firstName: contact?.firstName || undefined, lastName: contact?.lastName || undefined };
 }
 
+type ResultFields = Pick<S, "resultOpen" | "resultOpenB" | "resultText" | "resultOk" | "resultInfo">;
+/** The result sheet fields as the actions last SET them — not as the service last committed them:
+ *  an action's result counts from the moment it is made, before the action's own state commits, so
+ *  a read landing in between cannot copy the older fields over it. */
+let lastResult: ResultFields = { resultOpen: false, resultOpenB: false, resultText: "", resultOk: false, resultInfo: false };
+
+/** `next`, with the result sheet fields as they are NOW: a read that ran while a result was closed
+ *  (or a newer one opened) must not commit the older result fields it started from. */
+function keepResult(next: S | undefined): S | undefined {
+  if (!next) return next;
+  return { ...next, ...lastResult };
+}
+
+/** Which result slot presented last: the next result takes the other one. */
+let resultSeq = 0;
+
+/** One action's outcome, for the result sheet: `ok` when it went through. */
+function result(text: string, ok: boolean): ResultFields {
+  const b = ++resultSeq % 2 === 0;
+  lastResult = { resultOpen: !b, resultOpenB: b, resultText: text, resultOk: ok, resultInfo: !ok };
+  return lastResult;
+}
+const NO_RESULT = { resultOpen: false, resultOpenB: false } as const;
+/** A view action (load, a day or page change, opening the session sheet) closes any result on
+ *  screen. A write still in flight still says its outcome when it lands: the member started it, and
+ *  its row may not be on the page they moved to, so the sheet is their only confirmation. */
+function newView(s: S): S {
+  lastResult = { ...lastResult, ...NO_RESULT };
+  return { ...s, ...NO_RESULT };
+}
+
+const emptyFlags = (noClasses: boolean, nothingAhead: boolean) =>
+  ({ noClasses, nothingAhead, notNoClasses: !noClasses, notNothingAhead: !nothingAhead });
+
 /** Rebuild everything the screen reads from the module state. */
 function derive(s: S): S {
   const events = rowsOk === false ? [] : sessions.filter((x) => x.day >= s.selectedDate).map((x) => eventOf(x, places.get(x.key)));
   const sheet = sessions.find((x) => x.key === sheetKey);
   const sheetPlace = sheet ? places.get(sheet.key)?.place ?? "" : "";
+  const loaded = s.status === "ready" && rowsOk !== false && !!services;
   return {
     ...s,
     decorations: decorationsOf(sessions, s.today, s.rangeStart, s.rangeEnd),
     events,
     scrollTo: events[0] ? dayKey(events[0].start) : "",
-    emptyText: copyParam("agenda.emptyText", "No classes from this day on."),
     // The only thing an update-required screen says: no tap or page clears it.
-    ...(rowsOk === false ? { message: copyParam("agenda.updateRequired", "Update the app to see the class schedule.") } : {}),
+    updateMessage: rowsOk === false ? copyParam("agenda.updateRequired", "Update the app to see the class schedule.") : "",
     signedIn: !!member?.email,
     updateRequired: rowsOk === false,
-    listHidden: s.busy === true || rowsOk === false,
+    listHidden: s.busy === true || rowsOk === false || events.length === 0,
+    ...emptyFlags(loaded && services!.length === 0, loaded && services!.length > 0 && events.length === 0),
     sheetOpen: !!sheet && !!sheetPlace,
     sheetTitle: sheet?.title ?? "",
-    sheetWhen: sheet ? `${clock(sheet.start)} ${lengthLabel(sheet.start, sheet.end)}`.trim() : "",
+    sheetWhen: sheet ? joined(dayLabel(sheet.start, { absolute: true }), timeLabel(sheet.start), lengthLabel(sheet.start, sheet.end)) : "",
+    sheetMeta: sheet ? joined(sheet.staff, sheet.location) : "",
+    sheetHideCalendar: sheetPlace !== "booked",
     sheetHideCancel: sheetPlace !== "booked",
     sheetHideLeave: sheetPlace !== "waitlisted",
-    sheetBusy: busy,
+    sheetBusy: busy || calendarBusy,
   };
 }
 
@@ -544,6 +643,10 @@ async function ensureLoaded(base: S, force = false): Promise<S | undefined> {
   if (covers(loadedWindow, need) && !force) return derive({ ...s, ...READY });
   const seq = ++loadSeq;
   const win = covers(loadedWindow, need) ? loadedWindow : need;
+  // A result that an action produced while this read ran (Add to Calendar, a failed cancel) is
+  // newer than the state this read started from: the commit keeps it rather than closing it.
+  const resultAt = resultSeq;
+  const fresh = (x: S): S => (resultSeq === resultAt ? x : keepResult(x) ?? x);
   try {
     const nextSessions = await sessionsIn(win.start, win.end);
     const { who, found: nextPlaces } = await placesIn(win.start, win.end, nextSessions);
@@ -552,18 +655,18 @@ async function ensureLoaded(base: S, force = false): Promise<S | undefined> {
     if (!covers(win, needOf(now))) {
       // The member paged past what this read covers while it ran. The days already loaded may
       // cover where they are now (they paged back); otherwise read those.
-      return covers(loadedWindow, needOf(now)) ? derive({ ...now, ...READY }) : ensureLoaded(now);
+      return covers(loadedWindow, needOf(now)) ? derive(fresh({ ...now, ...READY })) : ensureLoaded(fresh(now));
     }
     sessions = nextSessions;
     places = nextPlaces;
     member = who;
     loadedWindow = win;
-    return derive({ ...now, ...READY, message: "" });
+    return derive(fresh({ ...now, ...READY }));
   } catch (err) {
     if (seq !== loadSeq) return undefined;
     const now = { ...s, ...wanted };
     // The member paged back to days already loaded while this read failed: those still stand.
-    if (!covers(win, needOf(now)) && covers(loadedWindow, needOf(now))) return derive({ ...now, ...READY });
+    if (!covers(win, needOf(now)) && covers(loadedWindow, needOf(now))) return derive(fresh({ ...now, ...READY }));
     // Only the flags: the schedule is not a row collection, and a failed load keeps no rows.
     const { sessions: _rows, emptyText: _empty, ...flags } = loadFailed("sessions", err, {
       prefix: "agenda",
@@ -575,7 +678,7 @@ async function ensureLoaded(base: S, force = false): Promise<S | undefined> {
     sessions = [];
     places = new Map();
     loadedWindow = { start: "", end: "" };
-    return derive({ ...now, ...flags });
+    return derive(fresh({ ...now, ...flags }));
   }
 }
 
@@ -593,8 +696,9 @@ const eventIdOf = (p: unknown): string => argOf(p, "eventId") || argOf(p, "id");
 function initial(): S {
   return {
     ...LOADING, firstWeekday: 0, today: "", selectedDate: "", rangeStart: "", rangeEnd: "",
-    decorations: [], events: [], scrollTo: "", emptyText: "", message: "", signedIn: false, updateRequired: false, listHidden: true,
-    sheetOpen: false, sheetTitle: "", sheetWhen: "", sheetHideCancel: true, sheetHideLeave: true, sheetBusy: false,
+    decorations: [], events: [], scrollTo: "", signedIn: false, updateRequired: false, updateMessage: "", listHidden: true,
+    ...emptyFlags(false, false), resultOpen: false, resultOpenB: false, resultText: "", resultOk: false, resultInfo: false,
+    sheetOpen: false, sheetTitle: "", sheetWhen: "", sheetMeta: "", sheetHideCalendar: true, sheetHideCancel: true, sheetHideLeave: true, sheetBusy: false,
   };
 }
 
@@ -610,9 +714,13 @@ const svc = defineService<S, {
   openSheet: (s: S, p?: unknown) => S;
   closeSheet: (s: S) => S;
   viewSession: (s: S) => S;
+  closeResult: (s: S, p?: unknown) => S;
+  addToCalendar: (s: S) => Promise<S>;
   cancelBooking: (s: S) => Promise<S | undefined>;
   joinWaitlist: (s: S, p?: unknown) => Promise<S | undefined>;
 }>("himiBrandedAgenda", {
+  // An action's result belongs to that visit: a cold start must not replay it from saved state.
+  notHydrated: ["resultOpen", "resultOpenB", "resultText", "resultOk", "resultInfo"],
   state: initial(),
   actions: {
     load: async (s, p) => {
@@ -629,14 +737,16 @@ const svc = defineService<S, {
       const week = weekOf(today, (((fw % 7) + 7) % 7) as Weekday);
       // Re-read the catalog when the screen shows again: classes are added, renamed and removed.
       if (!first) services = null;
+      // A result from before the screen was left is not news when it shows again.
       const asked = first
-        ? ask(s, { firstWeekday: fw, today, selectedDate: today, rangeStart: week[0], rangeEnd: week[6] })
-        : ask(s, { firstWeekday: fw, today });
+        ? ask(newView(s), { firstWeekday: fw, today, selectedDate: today, rangeStart: week[0], rangeEnd: week[6] })
+        : ask(newView(s), { firstWeekday: fw, today });
       rowsOk ??= await rowsSupported();
-      if (!rowsOk) return derive({ ...asked, ...READY, message: copyParam("agenda.updateRequired", "Update the app to see the class schedule.") });
+      if (!rowsOk) return derive({ ...asked, ...READY });
       return ensureLoaded(asked, !first);
     },
-    retry: async (s) => { services = null; return ensureLoaded({ ...s, ...LOADING }, true); },
+    // A view action: it closes the result, as every other one does through `newView`.
+    retry: async (s) => { services = null; return ensureLoaded(newView({ ...s, ...LOADING }), true); },
     // Each compares with the member's LAST ask, not `s`: a read still in flight has not put the
     // previous page into `s` yet, and paging back to that page is still a change.
     selectDate: async (s, p) => {
@@ -651,9 +761,9 @@ const svc = defineService<S, {
       const page = titledDays(cur.rangeStart, cur.rangeEnd);
       if (span > 7 && (date < page.first || date > page.last)) {
         const grid = monthGridOf(date, s.firstWeekday);
-        if (grid) return ensureLoaded(ask({ ...s, message: "" }, { selectedDate: date, rangeStart: grid.start, rangeEnd: grid.end }));
+        if (grid) return ensureLoaded(ask(newView(s), { selectedDate: date, rangeStart: grid.start, rangeEnd: grid.end }));
       }
-      return ensureLoaded(ask({ ...s, message: "" }, { selectedDate: date }));
+      return ensureLoaded(ask(newView(s), { selectedDate: date }));
     },
     rangeChanged: async (s, p) => {
       const start = argOf(p, "startDate"), end = argOf(p, "endDate");
@@ -663,7 +773,7 @@ const svc = defineService<S, {
       // on screen rather than a week the user has paged away from.
       const keep = keepsSelection(cur, start, end);
       const selectedDate = keep ? cur.selectedDate : selectionForRange(cur.today || dayKey(new Date()), start, end, cur.selectedDate);
-      return ensureLoaded(ask({ ...s, message: "" }, { rangeStart: start, rangeEnd: end, selectedDate }));
+      return ensureLoaded(ask(newView(s), { rangeStart: start, rangeEnd: end, selectedDate }));
     },
     // An older binary has no week mode and reports only the month. Its grid then spans the
     // month's whole weeks; load those, so dots still show on every visible day.
@@ -677,13 +787,13 @@ const svc = defineService<S, {
       if (!start || !last || (start === cur.rangeStart && last === cur.rangeEnd)) return s;
       const keep = keepsSelection(cur, start, last);
       const selectedDate = keep ? cur.selectedDate : selectionForRange(cur.today || dayKey(new Date()), start, last, cur.selectedDate);
-      return ensureLoaded(ask(s, { rangeStart: start, rangeEnd: last, selectedDate }));
+      return ensureLoaded(ask(newView(s), { rangeStart: start, rangeEnd: last, selectedDate }));
     },
     openSheet: (s, p) => {
       const key = eventIdOf(p);
       if (!places.get(key)) return s;
       sheetKey = key;
-      return derive({ ...s, message: "" });
+      return derive(newView(s));
     },
     closeSheet: (s) => {
       if (busy) return s;
@@ -695,6 +805,62 @@ const svc = defineService<S, {
       sheetKey = "";
       return session ? navigate(derive(s), { screenId: "himi_service", args: { id: session.serviceId } }) : derive(s);
     },
+    // From one slot's own close or dismissal (`slot`: "a" | "b"), or both when it names none.
+    closeResult: (s, p) => {
+      const slot = argOf(p, "slot");
+      const closed = slot === "a" ? { resultOpen: false } : slot === "b" ? { resultOpenB: false } : NO_RESULT;
+      lastResult = { ...lastResult, ...closed };
+      if (slot === "a") return s.resultOpen ? { ...s, resultOpen: false } : s;
+      if (slot === "b") return s.resultOpenB ? { ...s, resultOpenB: false } : s;
+      return s.resultOpen || s.resultOpenB ? { ...s, ...NO_RESULT } : s;
+    },
+    // Add a booked session to the device calendar — the event screen's flow: ask for write access,
+    // create the event, and fall back to the Google Calendar template page when the calendar is
+    // refused or creates nothing. Nothing is written to Wix.
+    addToCalendar: async (s): Promise<S> => {
+      const session = sessions.find((x) => x.key === sheetKey);
+      if (!session || places.get(session.key)?.place !== "booked" || busy || calendarBusy) return s;
+      // One calendar flow at a time. The sheet is left as it is while the flow runs (a reload that
+      // lands meanwhile must not close it — on iOS the calendar page is presented on it), and the
+      // member may close it, view the class, or open another session's sheet. Meanwhile its Add to
+      // Calendar and Cancel are inert (`calendarBusy`); a sheet opened during the flow reads them as
+      // disabled (sheetBusy). At the end the flow closes the sheet only if it is still this
+      // session's. Not `busy`: closeSheet must still work while the flow runs.
+      calendarBusy = true;
+      const start = Date.parse(session.start);
+      const end = Date.parse(session.end) > start ? Date.parse(session.end) : start + 60 * 60 * 1000;
+      const fallback = async (failed: string, failedFallback: string): Promise<ResultFields> => {
+        const opened = await open(calendarFallbackUrl(session, start, end), "in_app_browser").then((r) => r.opened, () => false);
+        // On iOS the in-app browser is presented ON the session sheet; closing the sheet now would
+        // close the browser with it. The sheet stays, and the member closes it after the browser.
+        // So the flow leaves an open sheet open; only a sheet that did not get the page is closed.
+        if (!opened && sheetKey === session.key) sheetKey = "";
+        return result(opened ? copyParam("agenda.calendarOpened", "Opened your calendar.") : copyParam(failed, failedFallback), false);
+      };
+      let outcome: ResultFields;
+      try {
+        let permission = await getPermissionStatus();
+        if (permission !== "granted" && permission !== "limited") permission = await requestPermission("writeOnly");
+        if (permission !== "granted" && permission !== "limited") {
+          outcome = await fallback("agenda.calendarDenied", "The app cannot use your calendar. Allow it in Settings.");
+        } else {
+          const created = await createEvent({ title: session.title, start, end, location: session.location, notes: session.staff });
+          if (created.id) {
+            if (sheetKey === session.key) sheetKey = "";
+            outcome = result(copyParam("agenda.calendarAdded", "Added to your calendar."), true);
+          } else {
+            outcome = await fallback("agenda.calendarFailed", "Could not add this class to your calendar.");
+          }
+        }
+      } catch {
+        // A calendar that throws (EventKit refusing the save) gets the same fallback as one that
+        // creates nothing: the calendar page, which `fallback` opens without throwing.
+        outcome = await fallback("agenda.calendarFailed", "Could not add this class to your calendar.");
+      } finally {
+        calendarBusy = false;
+      }
+      return derive({ ...(svc.getState() as S), ...outcome });
+    },
     // Cancel a booking (the MEMBER cancel, so Wix enforces the business's cancellation
     // policy), or leave a waitlist (which also releases the pending booking it created).
     cancelBooking: async (s): Promise<S | undefined> => {
@@ -703,7 +869,7 @@ const svc = defineService<S, {
       const owner = member;
       const session = sessions.find((x) => x.key === sheetKey);
       const leaving = place?.place === "waitlisted";
-      if (!place || !session || busy || (!leaving && !place.revision)) return s;
+      if (!place || !session || busy || calendarBusy || (!leaving && !place.revision)) return s;
       busy = true;
       try {
         if (!(await sameMember(owner))) throw memberAccessChanged();
@@ -711,24 +877,24 @@ const svc = defineService<S, {
         else await cancelBookingAsMember(place.bookingId, place.revision);
         places.delete(sheetKey);
         sheetKey = "";
-        const message = leaving ? copyParam("agenda.leftWaitlist", "You left the waitlist.") : copyParam("agenda.cancelDone", "Booking cancelled.");
+        const done = leaving ? copyParam("agenda.leftWaitlist", "You left the waitlist.") : copyParam("agenda.cancelDone", "Booking cancelled.");
         // Reload against the state as it is NOW: the member may have paged while the write ran.
         const next = await ensureLoaded(svc.getState() as S, true);
         busy = false;
-        return derive({ ...(next ?? { ...(svc.getState() as S), ...wanted }), message });
+        return derive({ ...(next ?? { ...(svc.getState() as S), ...wanted }), ...result(done, true) });
       } catch (err) {
         sheetKey = "";
         if ((err as { name?: string } | null)?.name === "MemberAccessChanged") {
           // Someone else (or nobody) since the load: show their schedule; nothing is cancelled.
-          const next = await ensureLoaded(svc.getState() as S, true);
+          const next = keepResult(await ensureLoaded(svc.getState() as S, true));
           busy = false;
           return next ? derive(next) : undefined;
         }
         busy = false;
-        const message = isBookingPolicyViolation(err)
+        const failed = isBookingPolicyViolation(err)
           ? copyParam("agenda.cancelPolicy", "It's too late to cancel in the app. Contact the business.")
           : copyParam("agenda.cancelFailed", "That didn't go through. Try again.");
-        return derive({ ...(svc.getState() as S), message });
+        return derive({ ...(svc.getState() as S), ...result(failed, false) });
       }
     },
     joinWaitlist: async (s, p): Promise<S | undefined> => {
@@ -755,7 +921,7 @@ const svc = defineService<S, {
         if (!same(before, current) || !same(owner, current)) {
           // Another member since the load — or the load was a visitor's, so their places were never
           // read: show their schedule first; nothing is registered.
-          const next = await ensureLoaded(svc.getState() as S, true);
+          const next = keepResult(await ensureLoaded(svc.getState() as S, true));
           busy = false;
           return next ? derive(next) : undefined;
         }
@@ -763,13 +929,13 @@ const svc = defineService<S, {
         // Marked at once, so until a reload lands the row reads On waitlist and offers no second
         // join — whether this reload commits or a newer page overtakes it.
         places.set(key, { bookingId: res?.booking?.id ?? "", revision: "", place: "waitlisted", registrationId: res?.registrationId, confirmed: false });
-        const message = copyParam("agenda.joinedWaitlist", "You're on the waitlist.");
+        const joined = copyParam("agenda.joinedWaitlist", "You're on the waitlist.");
         const next = await ensureLoaded(svc.getState() as S, true);
         busy = false;
-        return derive({ ...(next ?? { ...(svc.getState() as S), ...wanted }), message });
+        return derive({ ...(next ?? { ...(svc.getState() as S), ...wanted }), ...result(joined, true) });
       } catch {
         busy = false;
-        return derive({ ...(svc.getState() as S), message: copyParam("agenda.waitlistFailed", "Couldn't join the waitlist. Try again.") });
+        return derive({ ...(svc.getState() as S), ...result(copyParam("agenda.waitlistFailed", "Couldn't join the waitlist. Try again."), false) });
       }
     },
   },