@wix/himalaya-cli 0.1581.0 → 0.1583.0

package/templates/yoga-studio/tier5-src/himi-branded-lite-agenda/index.ts

@@ -36,53 +36,24 @@ 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"]);
-/** 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;
-  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;
-};
-
 /** The `Agenda` wire shape: declared fields plus a flat string `extra` map for the row. */
 export interface AgendaEvent {
   id: string;
@@ -138,6 +109,22 @@ interface S extends LoadFlags {
   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" : "");
@@ -155,107 +142,11 @@ export function lengthLabel(start: string, end: string): string {
 /** 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 });
-  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 { name?: string; formattedAddress?: string } | undefined;
-  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(),
-    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. */
-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 });
-}
-
-/** 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 ?? "";
+/** 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 full = s.total > 0 && s.open <= 0;
-  // 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 = !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,
@@ -276,14 +167,14 @@ export function eventOf(s: Session, place: MemberPlace | undefined): AgendaEvent
         ? 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")
-        : s.tooEarly ? copyParam("agenda.notOpenYet", "Not open yet") : copyParam("agenda.closed", "Closed"),
+      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),
     },
   };
 }
@@ -397,6 +288,17 @@ 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. */
@@ -438,67 +340,17 @@ async function sessionsIn(start: string, end: string): Promise<Session[]> {
       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 out
+  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));
 }
 
-/** 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. */
-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;
-  }
-}
-
 /** 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. */
@@ -550,23 +402,53 @@ function newView(s: S): S {
 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 events = rowsOk === false ? [] : sessions.filter((x) => x.day >= s.selectedDate).map((x) => eventOf(x, places.get(x.key)));
+  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,
-    decorations: decorationsOf(sessions, s.today, s.rangeStart, s.rangeEnd),
+    ...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: events[0] ? dayKey(events[0].start) : "",
+    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),
+    ...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)) : "",
@@ -576,6 +458,8 @@ function derive(s: S): S {
     sheetHideLeave: sheetPlace !== "waitlisted",
     sheetBusy: busy || calendarBusy,
     sheetServiceId: sheet?.serviceId ?? "",
+    sheetSessionId: sheet?.sessionId ?? "",
+    sheetStart: sheet?.start ?? "",
   };
 }
 
@@ -602,8 +486,16 @@ async function leave(place: MemberPlace, session: Session, owner: MemberAccess |
  *  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);
 }
@@ -624,6 +516,20 @@ function ask(s: S, view: Partial<View>): S {
   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);
@@ -645,15 +551,34 @@ async function ensureLoaded(base: S, force = false): Promise<S | undefined> {
   // 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 : need;
+  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 {
-    const nextSessions = await sessionsIn(win.start, win.end);
-    const { who, found: nextPlaces } = await placesIn(win.start, win.end, nextSessions);
+    // 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
@@ -701,10 +626,28 @@ function initial(): S {
     ...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: "",
+    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" = "";
 
@@ -721,9 +664,14 @@ const svc = defineService<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.
-  notHydrated: ["resultOpen", "resultOpenB", "resultText", "resultOk", "resultInfo"],
+  // 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) => {
@@ -744,9 +692,12 @@ const svc = defineService<S, {
       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 ensureLoaded(asked, !first);
+      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); },
@@ -757,6 +708,8 @@ const svc = defineService<S, {
       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;
@@ -764,9 +717,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(newView(s), { selectedDate: date, rangeStart: grid.start, rangeEnd: grid.end }));
+        if (grid) return settled(await ensureLoaded(ask(newView(s), { selectedDate: date, rangeStart: grid.start, rangeEnd: grid.end })));
       }
-      return ensureLoaded(ask(newView(s), { selectedDate: date }));
+      return settled(await ensureLoaded(ask(newView(s), { selectedDate: date })));
     },
     rangeChanged: async (s, p) => {
       const start = argOf(p, "startDate"), end = argOf(p, "endDate");
@@ -776,7 +729,14 @@ 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(newView(s), { rangeStart: start, rangeEnd: end, 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.
@@ -790,6 +750,7 @@ 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);
+      if (!keep) settleJump();
       return ensureLoaded(ask(newView(s), { rangeStart: start, rangeEnd: last, selectedDate }));
     },
     openSheet: (s, p) => {
@@ -806,7 +767,9 @@ const svc = defineService<S, {
     viewSession: (s) => {
       const session = sessions.find((x) => x.key === sheetKey);
       sheetKey = "";
-      return session ? navigate(derive(s), { screenId: "himi_service", args: { id: session.serviceId } }) : derive(s);
+      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) => {
@@ -941,6 +904,42 @@ const svc = defineService<S, {
         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 };