@wix/himalaya-cli 0.1613.0 → 0.1615.0

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

@@ -0,0 +1,950 @@
+// 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 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. 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, 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,
+} from "@himalaya/wix-bookings";
+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";
+import { get as getAppInfo } from "@himalaya/app-info";
+import {
+  distinctChoices, effectiveLocation, locationMenu, readSharedLocation, serviceLocationChoices, writeSharedLocation,
+  type LocationChoice, type LocationOptionRow,
+} from "../_shared/booking-location.js";
+import {
+  bySession, markWaitlisted, placesIn, placesOf, sessionControl, sessionKey, sessionOf, spotsLabel,
+  type MemberPlace, type Place, type Session,
+} from "../_shared/booking-session.js";
+
+// The session model is shared with the service screen opened from a row; re-exported for the tests.
+export { bySession, markWaitlisted, placesOf, sessionKey, sessionOf };
+export type { MemberPlace, Place, Session };
+
+/** How far past the selected day the list reaches. */
+export const AGENDA_DAYS = 28;
+/** 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"]);
+/** The `Agenda` wire shape: declared fields plus a flat string `extra` map for the row. */
+export interface AgendaEvent {
+  id: string;
+  title: string;
+  start: string;
+  end: string;
+  extra: Record<string, string>;
+}
+
+interface S extends LoadFlags {
+  firstWeekday: number;
+  today: string;
+  selectedDate: string;
+  rangeStart: string;
+  rangeEnd: string;
+  decorations: DayDecoration[];
+  events: AgendaEvent[];
+  scrollTo: 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 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;
+  /** The sheet session's service: View class reads its declared route (`nav`) from it. "" with no sheet. */
+  sheetServiceId: string;
+  /** …and its session (id and start), so the service screen opens on it. */
+  sheetSessionId: string;
+  sheetStart: string;
+  // The location picker (two or more locations only): `locationMenu()` in booking-location.ts.
+  locationOptions: LocationOptionRow[];
+  locationLabel: string;
+  locationA11y: string;
+  hasLocationMenu: boolean;
+  noLocationMenu: boolean;
+  /** A location is chosen: the pin turns accent and the line under the title names it. */
+  locationActive: boolean;
+  noLocationActive: boolean;
+  locationSheetOpen: boolean;
+  /** A location is chosen and has no session in the loaded days: its own empty state. */
+  locationEmpty: boolean;
+  notLocationEmpty: boolean;
+}
+
+const flag = (on: boolean): string => (on ? "true" : "");
+
+/** "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;
+  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(" · ");
+
+/** One session → one Agenda row. Exactly one of the trailing controls is visible. `lastOfDay`: the
+ *  day's last row draws no divider — the next day's header band starts right under it. */
+export function eventOf(s: Session, place: MemberPlace | undefined, lastOfDay = false): AgendaEvent {
+  const { control, closedLabel } = sessionControl(s, place);
+  const course = s.kind === "course";
+  const time = timeLabel(s.start);
+  return {
+    id: s.key,
+    title: s.title,
+    start: s.start,
+    end: s.end,
+    extra: {
+      serviceId: s.serviceId,
+      // Choose Time opens on THIS session: two of a class can start at the same time.
+      sessionId: s.sessionId,
+      time,
+      length: lengthLabel(s.start, s.end),
+      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(control !== "book"),
+      hideWaitlist: flag(control !== "waitlist"),
+      hideCourse: flag(control !== "course"),
+      hideBooked: flag(control !== "booked"),
+      hideOnWaitlist: flag(control !== "waitlisted"),
+      hideClosed: flag(control !== "closed"),
+      closedLabel,
+      lastOfDay: flag(lastOfDay),
+    },
+  };
+}
+
+/** The first and last cell any month grid of `day`'s month can have, padding included. */
+function monthGrid(day: string): { start: string; end: string } {
+  const d = toDate(day);
+  if (!d) return { start: day, end: day };
+  return { start: dayKey(new Date(d.getFullYear(), d.getMonth(), 1 - 6)), end: dayKey(new Date(d.getFullYear(), d.getMonth() + 1, 6)) };
+}
+
+/** One dot per day that has a session — "something is on", not how much — and the visible
+ *  days before today dimmed and unselectable: the agenda is what is still to come. */
+export function decorationsOf(sessions: Session[], today: string, rangeStart: string, rangeEnd: string): DayDecoration[] {
+  const out: DayDecoration[] = [];
+  const dimmed = new Set<string>();
+  const dim = (from: string, to: string) => {
+    for (let day = from; day && day < today && day <= to; day = dayKey(addDays(day, 1))) {
+      if (!dimmed.has(day)) { dimmed.add(day); out.push({ date: day, disabled: true }); }
+    }
+  };
+  // Bounded by the visible days: a page a year back dims its 7-42 cells, not a year.
+  dim(rangeStart, rangeEnd);
+  // And this month's grid: an older binary (no week mode) draws it on first open, while it
+  // reports nothing until the member pages.
+  dim(monthGrid(today).start, today);
+  for (const date of [...new Set(sessions.filter((s) => s.day >= today).map((s) => s.day))].sort()) out.push({ date, dotCount: 1 });
+  return out;
+}
+
+/** The days to load: the visible days (never before today) through AGENDA_DAYS past the
+ *  selected day, so the list under the calendar always has its full reach. */
+export function windowFor(today: string, rangeStart: string, rangeEnd: string, selected: string): { start: string; end: string } {
+  const start = rangeStart > today ? rangeStart : today;
+  const from = selected > today ? selected : today;
+  // Through the last cell of the selected day's month grid as well, which is what an older
+  // binary draws before it has reported any page: every dot on it is then real.
+  const end = [rangeEnd, dayKey(addDays(from, AGENDA_DAYS)), monthGrid(from).end].reduce((a, b) => (b > a ? b : a));
+  return { start, end };
+}
+
+/** Where the selection goes when the calendar pages away from it: the first day of the
+ *  page (the 1st of the titled month in month view — the grid's first cell is padding),
+ *  or today when that is on the page. A page wholly before today has no day to select (past
+ *  days are disabled), so `current` stays selected and the list keeps showing from it. */
+export function selectionForRange(today: string, rangeStart: string, rangeEnd: string, current = today): string {
+  const { first, last } = titledDays(rangeStart, rangeEnd);
+  if (today >= first && today <= last) return today;
+  return last < today ? current : first;
+}
+
+/** The days a page is about: the whole week, or a month grid's TITLED month — its padding cells
+ *  belong to the neighbouring months. */
+export function titledDays(rangeStart: string, rangeEnd: string): { first: string; last: string } {
+  let first = rangeStart;
+  let last = rangeEnd;
+  const span = Math.round((Date.parse(rangeEnd) - Date.parse(rangeStart)) / 86_400_000);
+  if (span > 7) {
+    // A month grid: its padding cells belong to the neighbouring months. Today counts only when
+    // it is in the TITLED month — a today in the trailing padding would move the selection, and
+    // with it the grid, a month forward.
+    const d = toDate(rangeStart);
+    if (d) {
+      const month = rangeStart.endsWith("-01") ? d : new Date(d.getFullYear(), d.getMonth() + 1, 1);
+      first = dayKey(month);
+      last = dayKey(new Date(month.getFullYear(), month.getMonth() + 1, 0));
+    }
+  }
+  return { first, last };
+}
+
+/** The month grid (whole weeks) of `day`'s month, as a calendar draws it. */
+function monthGridOf(day: string, firstWeekday: number): { start: string; end: string } | undefined {
+  const d = toDate(day);
+  if (!d) return undefined;
+  const fw = (((firstWeekday % 7) + 7) % 7) as Weekday;
+  const start = weekOf(new Date(d.getFullYear(), d.getMonth(), 1), fw)[0];
+  const end = weekOf(new Date(d.getFullYear(), d.getMonth() + 1, 0), fw)[6];
+  return start && end ? { start, end } : undefined;
+}
+
+/** Does the selection survive a page change? Inside the page's TITLED days, yes — a selection in a
+ *  month grid's padding belongs to the neighbouring month. Today stays selected on any page that
+ *  shows it: opening a week that straddles two months into the month holding most of it must not
+ *  move the agenda off today. */
+export function keepsSelection(cur: { today: string; selectedDate: string }, start: string, end: string): boolean {
+  const page = titledDays(start, end);
+  if (cur.selectedDate >= page.first && cur.selectedDate <= page.last) return true;
+  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;
+let sessions: Session[] = [];
+let places = new Map<string, MemberPlace>();
+let loadedWindow = { start: "", end: "" };
+let member: MemberAccess | undefined;
+let sheetKey = "";
+/** The location the member chose (here, on Services or on Choose Time): "" is every location. */
+let chosenLocation = { id: "", label: "" };
+let locationSheet = false;
+/** Until when a scroll report is ignored: a tap's (or a page's) jump is still settling, and a
+ *  report the list sent before it must not move the selection back. */
+let quietUntil = 0;
+/** Bumped by a location change: the list's target becomes "day|n", so the renderer applies it again
+ *  even when the day is the same one — rows above it came or went, and the offset no longer shows
+ *  it. Cleared by the list's own scroll and a calendar tap, whose plain day the renderer compares
+ *  with what it reported (an echo of the member's own scroll never moves the list). */
+let scrollNonce = 0;
+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;
+  // Every page, not the first 100: a class past the first page would silently be missing. Bounded,
+  // so a misbehaving paging answer cannot loop forever.
+  const all: WixService[] = [];
+  for (let page = 0; page < 10; page++) {
+    const res = await queryServices({ query: { paging: { limit: 100, offset: page * 100 } } } as never);
+    const batch = res.services ?? [];
+    all.push(...batch);
+    if (batch.length < 100) break;
+  }
+  services = all.filter((svc) => {
+    const raw = svc as WixService & { type?: string; hidden?: boolean };
+    return !!svc.id && SESSION_TYPES.has((raw.type ?? "").toUpperCase()) && raw.hidden !== true;
+  });
+  return services;
+}
+
+/** Every session of every class service in [start, end]. Each service is its own
+ *  call — the proven single-service availability query — so one service failing (a draft,
+ *  a removed schedule) costs its own rows, never the whole agenda. */
+async function sessionsIn(start: string, end: string): Promise<Session[]> {
+  const list = await sessionServices();
+  const from = new Date(`${start}T00:00:00`).toISOString();
+  const to = new Date(`${dayKey(addDays(end, 1))}T00:00:00`).toISOString();
+  const settled = await Promise.allSettled(list.map((svc) => queryServiceAvailability(svc.id, from, to, { bookable: false })));
+  const failures = settled.filter((r) => r.status === "rejected").length;
+  if (list.length && failures === list.length) throw (settled[0] as PromiseRejectedResult).reason;
+  const out: Session[] = [];
+  settled.forEach((r, i) => {
+    if (r.status !== "fulfilled") return;
+    for (const entry of r.value.availabilityEntries ?? []) {
+      const session = sessionOf(entry, list[i]);
+      if (session) out.push(session);
+    }
+  });
+  return ordered(out);
+}
+
+/** Sessions once each, by start then title — the list's order. */
+function ordered(list: Session[]): Session[] {
+  const seen = new Set<string>();
+  return list
+    .filter((s) => (seen.has(s.key) ? false : (seen.add(s.key), true)))
+    .sort((a, b) => Date.parse(a.start) - Date.parse(b.start) || compareText(a.title, b.title));
+}
+
+/** Is `owner` — the member a place was loaded for — still the one signed in, to the same account
+ *  and business? Asked right before a write, so a sign-out or a switch since the load never
+ *  writes for the wrong person. */
+async function sameMember(owner: MemberAccess | undefined): Promise<boolean> {
+  if (!owner?.email) return false;
+  return assertMemberAccess(owner).then(() => true, () => false);
+}
+
+/** The member's name for a waitlist registration, when their member record has one. The
+ *  email alone registers; the name is what the business sees on its waitlist. */
+async function memberName(): Promise<{ firstName?: string; lastName?: string }> {
+  // A failed profile read registers by email alone rather than failing the join.
+  const res = await getMyMember({ fieldsets: ["FULL"] }).catch(() => undefined);
+  const contact = res?.member?.contact as { firstName?: string; lastName?: string } | undefined;
+  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 });
+
+/** The locations the member can choose from: every class and course service's own locations, then
+ *  any the loaded sessions name that no service lists, and the location chosen on another screen
+ *  (Services, Choose Time) even when nothing here is at it — so the choice is kept, and its empty
+ *  state says so, rather than silently showing everything. */
+export function agendaLocations(list: readonly WixService[], inWindow: readonly Session[], chosen: { id: string; label: string }): LocationChoice[] {
+  return distinctChoices([
+    ...list.flatMap((svc) => serviceLocationChoices(svc.locations)),
+    ...inWindow.map((x) => ({ key: x.locationKey, label: x.location, sub: x.locationSub })),
+    ...(chosen.id && chosen.label ? [{ key: chosen.id, label: chosen.label, sub: "" }] : []),
+  ]);
+}
+
+/** The day the list scrolls to for `selected`: that day, else the next one with a session, else the
+ *  last one (a day after every loaded session still shows the list's end, not an empty page). */
+export function scrollDayFor(days: readonly string[], selected: string): string {
+  return days.find((d) => d >= selected) ?? days[days.length - 1] ?? "";
+}
+
+/** Rebuild everything the screen reads from the module state. */
+function derive(s: S): S {
+  const choices = agendaLocations(services ?? [], sessions, chosenLocation);
+  const locationKey = effectiveLocation(choices, chosenLocation.id);
+  // From today on (the loaded days never start before it), at the chosen location. The list is
+  // one run of days: a tap on the calendar SCROLLS it to a day, and scrolling it moves the
+  // selection, so it never starts at the selected day (the days above it would vanish).
+  const shown = sessions.filter((x) => x.day >= s.today && (!locationKey || x.locationKey === locationKey));
+  const events = rowsOk === false ? [] : shown.map((x, i) => eventOf(x, places.get(x.key), shown[i + 1]?.day !== x.day));
+  const sheet = sessions.find((x) => x.key === sheetKey);
+  const sheetPlace = sheet ? places.get(sheet.key)?.place ?? "" : "";
+  const loaded = s.status === "ready" && rowsOk !== false && !!services;
+  const locationEmpty = loaded && !!locationKey && shown.length === 0;
+  return {
+    ...s,
+    ...locationMenu(choices, chosenLocation.id),
+    locationSheetOpen: locationSheet,
+    locationEmpty,
+    notLocationEmpty: !locationEmpty,
+    // The dots follow the location too: a day with a session only elsewhere has none.
+    decorations: decorationsOf(shown, s.today, s.rangeStart, s.rangeEnd),
+    events,
+    scrollTo: ((day) => (day && scrollNonce && suffixOk !== false ? `${day}|${scrollNonce}` : day))(scrollDayFor([...new Set(shown.map((x) => x.day))], s.selectedDate)),
+    // The only thing an update-required screen says: no tap or page clears it.
+    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 || events.length === 0,
+    ...emptyFlags(loaded && services!.length === 0, loaded && services!.length > 0 && events.length === 0 && !locationEmpty),
+    sheetOpen: !!sheet && !!sheetPlace,
+    sheetTitle: sheet?.title ?? "",
+    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 || calendarBusy,
+    sheetServiceId: sheet?.serviceId ?? "",
+    sheetSessionId: sheet?.sessionId ?? "",
+    sheetStart: sheet?.start ?? "",
+  };
+}
+
+/** Leave a waitlist. The registration id comes from the load; a place known only by its
+ *  WAITING_LIST status asks the session's waitlist for it, and a registration Wix no longer lists
+ *  is released through the member cancel of its booking. */
+async function leave(place: MemberPlace, session: Session, owner: MemberAccess | undefined): Promise<void> {
+  let registrationId = place.registrationId ?? "";
+  if (!registrationId && session.sessionId) {
+    const lists = await listWaitlists([session.sessionId]);
+    for (const list of lists.list ?? []) {
+      for (const r of list.registrations ?? []) if (r.bookingId === place.bookingId && r.id) registrationId = r.id;
+    }
+    // The lookup awaited: still the member the place belongs to?
+    if (!(await sameMember(owner))) throw memberAccessChanged();
+  }
+  if (registrationId && session.sessionId) await leaveWaitlist(registrationId, session.sessionId);
+  else await cancelBookingAsMember(place.bookingId, place.revision);
+}
+
+/** The first runtime whose Android Agenda keeps a worker-bound event's `extra` — every field a row
+ *  shows, and every flag that hides its other actions. An older Android binary would draw each
+ *  row blank with all its actions at once, so it is asked to update instead. Checked at run time,
+ *  not as a descriptor floor: a release takes its highest screen floor as its own. */
+export const AGENDA_MIN_ANDROID_BINARY = "1.6.0";
+let rowsOk: boolean | undefined;
+/** A `scrollTo` of "day|nonce" jumps again to the same day (after a location change). A native
+ *  renderer before 1.8.0 reads the whole value as the day and finds no row, so it gets the plain
+ *  day: the list then does not re-land on an unchanged day, but it does reach a new one. */
+export const AGENDA_SCROLL_SUFFIX_MIN_BINARY = "1.8.0";
+let suffixOk: boolean | undefined;
+
+async function rowsSupported(): Promise<boolean> {
+  const info = await getAppInfo().catch(() => undefined);
+  const native = !!info && (info.platform === "ios" || info.platform === "android" || info.platform === "macos");
+  suffixOk = !native || atLeast(info!.binaryVersion, AGENDA_SCROLL_SUFFIX_MIN_BINARY);
+  if (!info || info.platform !== "android") return true;
+  return atLeast(info.binaryVersion, AGENDA_MIN_ANDROID_BINARY);
+}
+
+const READY = { status: "ready" as const, error: "", signInRequired: false, notErrored: true, notLoading: true, busy: false, noSignIn: true };
+
+type View = Pick<S, "today" | "rangeStart" | "rangeEnd" | "selectedDate" | "firstWeekday">;
+/** The page and day the member asked for LAST. Every action records it before its first await,
+ *  so a read that lands after a newer page or day tap shows that view, not the one it started
+ *  from — paging back before the forward read lands must end on the user's last page. */
+let wanted: View | undefined;
+
+/** Record what the member asked for and return the state that shows it. */
+function ask(s: S, view: Partial<View>): S {
+  wanted = { ...(wanted ?? { today: s.today, rangeStart: s.rangeStart, rangeEnd: s.rangeEnd, selectedDate: s.selectedDate, firstWeekday: s.firstWeekday }), ...view };
+  // The initial state carries no date; an action that lands before `load` still needs today.
+  if (!wanted.today) wanted = { ...wanted, today: dayKey(new Date()) };
+  return { ...s, ...wanted };
+}
+
+/** The longest run of days the list grows to before a far page replaces it. */
+export const AGENDA_MAX_DAYS = 120;
+
+/** The days to read when `need` is not loaded: the loaded days GROWN to reach it when the two touch
+ *  (the member scrolled or paged on — the rows above them must stay, or the list jumps under their
+ *  finger), else `need` alone (a far page). Capped at AGENDA_MAX_DAYS. */
+export function grownWindow(loaded: { start: string; end: string }, need: { start: string; end: string }): { start: string; end: string } {
+  if (!loaded.start || need.start > dayKey(addDays(loaded.end, 1)) || need.end < dayKey(addDays(loaded.start, -1))) return need;
+  const start = loaded.start < need.start ? loaded.start : need.start;
+  const end = loaded.end > need.end ? loaded.end : need.end;
+  const span = Math.round((Date.parse(end) - Date.parse(start)) / 86_400_000);
+  return span > AGENDA_MAX_DAYS ? need : { start, end };
+}
+
+const covers = (win: { start: string; end: string }, need: { start: string; end: string }): boolean =>
+  !!win.start && win.start <= need.start && win.end >= need.end;
+const needOf = (s: S) => windowFor(s.today, s.rangeStart, s.rangeEnd, s.selectedDate);
+
+/** Bumped by every READ: a read that a newer read overtook stands down (returns `undefined`), and
+ *  the newer one commits. An action the loaded days already cover reads nothing and bumps nothing,
+ *  so a day tap never discards a reload in flight. */
+let loadSeq = 0;
+
+/** Load the window the state needs, unless it is already loaded. `force` reloads it (the
+ *  screen re-appeared: the member may have just booked on the Choose Time screen). Resolves to
+ *  `undefined` when a newer read started while this one awaited. */
+async function ensureLoaded(base: S, force = false): Promise<S | undefined> {
+  const s = { ...base, ...wanted };
+  if (rowsOk === false) return derive(s);
+  const need = needOf(s);
+  // Days already loaded mean the last read succeeded (a failure clears them), so the screen is
+  // ready — whatever the state this action was dispatched with still said: a calendar's first
+  // page report can finish its read while `load`, dispatched with "loading", still waits.
+  if (covers(loadedWindow, need) && !force) return derive({ ...s, ...READY });
+  const seq = ++loadSeq;
+  const win = covers(loadedWindow, need) ? loadedWindow : grownWindow(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 {
+    // A window grown to reach new days reads only those days, and keeps what it has: a scroll that
+    // extends the list must not re-read weeks of every class (and the member's bookings) each time.
+    // A forced reload (the screen re-appeared) and a far page read the whole window.
+    const grown = !force && win !== need && !!loadedWindow.start && win.start <= loadedWindow.start && win.end >= loadedWindow.end;
+    const parts = grown
+      ? [
+        ...(win.start < loadedWindow.start ? [{ start: win.start, end: dayKey(addDays(loadedWindow.start, -1)) }] : []),
+        ...(win.end > loadedWindow.end ? [{ start: dayKey(addDays(loadedWindow.end, 1)), end: win.end }] : []),
+      ]
+      : [win];
+    const reads = await Promise.all(parts.map(async (part) => {
+      const inPart = await sessionsIn(part.start, part.end);
+      const { who: reader, found } = await placesIn(part.start, part.end, inPart);
+      return { inPart, reader, found };
+    }));
+    const nextSessions = grown ? ordered([...sessions, ...reads.flatMap((r) => r.inPart)]) : reads[0]!.inPart;
+    const nextPlaces = grown ? new Map([...places, ...reads.flatMap((r) => [...r.found])]) : reads[0]!.found;
+    const who = reads[0]?.reader ?? member;
+    if (seq !== loadSeq) return undefined;
+    // The new days were read for another member than the loaded ones (a sign-out or a switch while
+    // the member scrolled): never mix two members' places — read the whole window for this one.
+    if (grown && reads.some((r) => (r.reader?.email ?? "") !== (member?.email ?? ""))) return ensureLoaded({ ...s, ...wanted }, true);
+    const now = { ...s, ...wanted };
+    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(fresh({ ...now, ...READY })) : ensureLoaded(fresh(now));
+    }
+    sessions = nextSessions;
+    places = nextPlaces;
+    member = who;
+    loadedWindow = win;
+    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(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",
+      empty: "No classes from this day on.",
+      error: "The schedule couldn't be loaded.",
+      signIn: "Sign in to see the schedule.",
+      sample: () => [] as Session[],
+    });
+    sessions = [];
+    places = new Map();
+    loadedWindow = { start: "", end: "" };
+    return derive(fresh({ ...now, ...flags }));
+  }
+}
+
+function argOf(p: unknown, key: string): string {
+  const a = p as Record<string, unknown> | undefined;
+  const v = a?.[key] ?? (a?.args as Record<string, unknown> | undefined)?.[key] ?? (a?.params as Record<string, unknown> | undefined)?.[key];
+  // Numbers too: every renderer sends onMonthChange's year/month as numbers.
+  return typeof v === "string" ? v.trim() : typeof v === "number" && Number.isFinite(v) ? String(v) : "";
+}
+
+const eventIdOf = (p: unknown): string => argOf(p, "eventId") || argOf(p, "id");
+
+/** Clock-free, so a template builds to the same release every time: `load` — or the
+ *  first `ask` before it — fills in today and this week. */
+function initial(): S {
+  return {
+    ...LOADING, firstWeekday: 0, today: "", selectedDate: "", rangeStart: "", rangeEnd: "",
+    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, sheetServiceId: "", sheetSessionId: "", sheetStart: "",
+    locationOptions: [], locationLabel: "", locationA11y: "", hasLocationMenu: false, noLocationMenu: true,
+    locationActive: false, noLocationActive: true, locationSheetOpen: false, locationEmpty: false, notLocationEmpty: true,
+  };
+}
+
+/** How long a jump the worker asked for (a calendar tap, a page, a location) takes to settle. */
+export const JUMP_SETTLE_MS = 900;
+const settleJump = () => { quietUntil = Date.now() + JUMP_SETTLE_MS; };
+
+/** A selected day with no session moves to the next day that has one ON THE SAME PAGE (the week
+ *  or month on screen), so the calendar and the list name the same day — the same rule on every
+ *  platform. With none left on the page the day stays selected, and the list shows the sessions
+ *  after it. Never off the page: that would page the calendar away under the member's finger. */
+async function settled(next: S | undefined): Promise<S | undefined> {
+  // The day the list scrolls to (a location change adds a "|n" suffix that re-applies it).
+  const day = next?.scrollTo.split("|")[0] ?? "";
+  if (!next || next.status !== "ready" || !day || day === next.selectedDate) return next;
+  if (day < next.selectedDate || day > titledDays(next.rangeStart, next.rangeEnd).last) return next;
+  return ensureLoaded(ask(next, { selectedDate: day }));
+}
+
+/** How the app opens its sign-in screen, from the appear params ("" = push). */
+let signInPresentation: "" | "sheet" | "full_screen" = "";
+/** The app's sign-in screen (`signInScreenId` appear param): Branded Lite's `himi_sign_in` by
+ *  default; an app with no such screen names its own (salon-spa: the Profile tab, `himi_account`). */
+let signInScreenId = "himi_sign_in";
+
+const svc = defineService<S, {
+  load: (s: S, p?: unknown) => Promise<S | undefined>;
+  retry: (s: S) => Promise<S | undefined>;
+  selectDate: (s: S, p?: unknown) => Promise<S | undefined>;
+  rangeChanged: (s: S, p?: unknown) => Promise<S | undefined>;
+  monthChanged: (s: S, p?: unknown) => Promise<S | undefined>;
+  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>;
+  visibleDate: (s: S, p?: unknown) => Promise<S | undefined>;
+  openLocations: (s: S) => S;
+  closeLocations: (s: S) => S;
+  selectLocation: (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,
+  // nor reopen the location sheet.
+  notHydrated: ["resultOpen", "resultOpenB", "resultText", "resultOk", "resultInfo", "locationSheetOpen"],
+  state: initial(),
+  actions: {
+    load: async (s, p) => {
+      stashCopy(p);
+      const presentation = argOf(p, "signInPresentation");
+      if (presentation === "sheet" || presentation === "full_screen") signInPresentation = presentation;
+      const signInScreen = argOf(p, "signInScreenId");
+      if (/^[a-z][a-z0-9_]{0,63}$/.test(signInScreen)) signInScreenId = signInScreen;
+      const fw = Number(argOf(p, "firstWeekday") || s.firstWeekday);
+      const today = dayKey(new Date());
+      // First appearance: open on this week. A re-appearance keeps the member's place and
+      // reloads, so a session booked on Choose Time comes back marked "Booked".
+      // This worker has read nothing yet: open on this week. Not the state's own status — a cold
+      // boot restores the last run's snapshot ("ready", last week's page) into a fresh worker.
+      const first = !loadedWindow.start;
+      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(newView(s), { firstWeekday: fw, today, selectedDate: today, rangeStart: week[0], rangeEnd: week[6] })
+        : ask(newView(s), { firstWeekday: fw, today });
+      // The location chosen on any bookings screen, read again on every appearance: Services or
+      // Choose Time may have changed it since.
+      chosenLocation = await readSharedLocation();
+      rowsOk ??= await rowsSupported();
+      if (!rowsOk) return derive({ ...asked, ...READY });
+      return first ? settled(await ensureLoaded(asked)) : ensureLoaded(asked, 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) => {
+      const date = argOf(p, "date");
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || date === (wanted ?? s).selectedDate) return s;
+      // Past days are not selectable — also before the load has dimmed them on the calendar.
+      if (date < ((wanted ?? s).today || dayKey(new Date()))) return s;
+      settleJump();
+      scrollNonce = 0;
+      // A month grid's padding day (iOS draws them) belongs to the next month, and the grid moves
+      // there without reporting a page: move this page with it, so paging back is still a change.
+      const cur = wanted ?? s;
+      const span = Math.round((Date.parse(cur.rangeEnd) - Date.parse(cur.rangeStart)) / 86_400_000);
+      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 settled(await ensureLoaded(ask(newView(s), { selectedDate: date, rangeStart: grid.start, rangeEnd: grid.end })));
+      }
+      return settled(await ensureLoaded(ask(newView(s), { selectedDate: date })));
+    },
+    rangeChanged: async (s, p) => {
+      const start = argOf(p, "startDate"), end = argOf(p, "endDate");
+      const cur = wanted ?? s;
+      if (!start || !end || (start === cur.rangeStart && end === cur.rangeEnd)) return s;
+      // The selection follows the page, so the list under the calendar describes the days
+      // 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);
+      // The calendar following the list's scroll pages too, and keeps its selection: only a page
+      // that moves the selection jumps the list.
+      if (!keep) { settleJump(); scrollNonce = 0; }
+      // A page that only followed the selection (the list's scroll moved it) is not a view change:
+      // a result on screen stays, as it does for the scroll itself.
+      return keep
+        ? ensureLoaded(ask(s, { rangeStart: start, rangeEnd: end, selectedDate }))
+        : settled(await 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.
+    monthChanged: async (s, p) => {
+      const year = Number(argOf(p, "year")), month = Number(argOf(p, "month"));
+      if (!year || !month) return s;
+      const first = new Date(year, month - 1, 1);
+      const start = weekOf(first, (s.firstWeekday % 7) as Weekday)[0];
+      const last = weekOf(new Date(year, month, 0), (s.firstWeekday % 7) as Weekday)[6];
+      const cur = wanted ?? 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);
+      if (!keep) settleJump();
+      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(newView(s));
+    },
+    closeSheet: (s) => {
+      if (busy) return s;
+      sheetKey = "";
+      return derive(s);
+    },
+    viewSession: (s) => {
+      const session = sessions.find((x) => x.key === sheetKey);
+      sheetKey = "";
+      return session
+        ? navigate(derive(s), { screenId: "himi_service", args: { id: session.serviceId, sessionId: session.sessionId, start: session.start } })
+        : 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> => {
+      const place = places.get(sheetKey);
+      // Read with `place`: a reload that lands meanwhile replaces both together.
+      const owner = member;
+      const session = sessions.find((x) => x.key === sheetKey);
+      const leaving = place?.place === "waitlisted";
+      if (!place || !session || busy || calendarBusy || (!leaving && !place.revision)) return s;
+      busy = true;
+      try {
+        if (!(await sameMember(owner))) throw memberAccessChanged();
+        if (leaving) await leave(place, session, owner);
+        else await cancelBookingAsMember(place.bookingId, place.revision);
+        places.delete(sheetKey);
+        sheetKey = "";
+        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 }), ...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 = keepResult(await ensureLoaded(svc.getState() as S, true));
+          busy = false;
+          return next ? derive(next) : undefined;
+        }
+        busy = false;
+        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), ...result(failed, false) });
+      }
+    },
+    joinWaitlist: async (s, p): Promise<S | undefined> => {
+      const key = eventIdOf(p);
+      const session = sessions.find((x) => x.key === key);
+      // A place already held (just joined, or booked) is never joined again.
+      if (!session || busy || places.get(key)) return s;
+      const owner = member;
+      busy = true;
+      try {
+        // One person's email and name: the member is read before AND after the name, and the
+        // registration goes out only when both reads, and the member the places were loaded for, agree.
+        const before = await memberAccess().catch(() => undefined);
+        if (!before?.email) {
+          busy = false;
+          // As a modal it only closes, and this screen loads again (its re-appearance reload).
+          return navigate(s, signInPresentation
+            ? { screenId: signInScreenId, presentation: signInPresentation, args: { mode: "signin", modal: "1" } }
+            : { screenId: signInScreenId, args: { mode: "signin", returnScreenId: "himi_agenda" } });
+        }
+        const name = await memberName();
+        const current = await memberAccess().catch(() => undefined);
+        const same = (a: MemberAccess | undefined, b: MemberAccess | undefined) => !!a?.email && a.email === b?.email && a.scope === b?.scope;
+        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 = keepResult(await ensureLoaded(svc.getState() as S, true));
+          busy = false;
+          return next ? derive(next) : undefined;
+        }
+        const res = await registerToWaitlist(session.sessionId, { email: current!.email, ...name });
+        // 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 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 }), ...result(joined, true) });
+      } catch {
+        busy = false;
+        return derive({ ...(svc.getState() as S), ...result(copyParam("agenda.waitlistFailed", "Couldn't join the waitlist. Try again."), false) });
+      }
+    },
+    // The list's scroll (`onVisibleDateChange`): the day the member reads becomes the selected day,
+    // so the calendar (and its week or month) follows the list. Not a view action — a result on
+    // screen stays. The list's scroll target follows too, so a return from a session's screen comes
+    // back to this day; the renderer does not scroll for its own day (it is where the list is).
+    visibleDate: async (s, p) => {
+      const date = argOf(p, "date");
+      const cur = wanted ?? s;
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || date === cur.selectedDate) return s;
+      // A report from before a jump the worker asked for: the jump wins.
+      if (Date.now() < quietUntil) return s;
+      if (date < (cur.today || dayKey(new Date()))) return s;
+      scrollNonce = 0;
+      return ensureLoaded(ask(s, { selectedDate: date }));
+    },
+    openLocations: (s) => {
+      locationSheet = true;
+      return derive({ ...s, ...wanted });
+    },
+    closeLocations: (s) => {
+      if (!locationSheet) return s;
+      locationSheet = false;
+      return derive({ ...s, ...wanted });
+    },
+    // A row of the location sheet: "" is every location. Kept for Services and Choose Time too.
+    selectLocation: async (s, p): Promise<S | undefined> => {
+      const id = argOf(p, "locationId");
+      const choice = agendaLocations(services ?? [], sessions, chosenLocation).find((c) => c.key === id);
+      chosenLocation = id && choice ? { id, label: choice.label } : { id: "", label: "" };
+      locationSheet = false;
+      settleJump();
+      // Rows above the selected day may have come or gone: the list must land on it again.
+      scrollNonce += 1;
+      // Not awaited (it never throws): the new list shows at once, whatever the store does.
+      void writeSharedLocation(chosenLocation);
+      return settled(derive(newView({ ...s, ...wanted })));
+    },
+  },
+});
+export { svc };