@wix/himalaya-cli 0.1613.0 → 0.1615.0

package/templates/salon-spa/tier5-src/himi-booking-time/index.ts

@@ -0,0 +1,1712 @@
+import { paymentSetupMessage } from "../_shared/payment-setup.js";
+import { withOnlineWrites, offlineWritesEnabled } from "../_shared/online-actions.js";
+// Tier-5 bundle: himi-booking — availability and member booking.
+import { defineService as registerService, navigate } from "@himalaya/state";
+// Local-day keying + shared day/time labelling. `addDays` below stays local and
+// UTC-based on purpose: it bounds the availability QUERY window, which is an
+// instant range, not a calendar day.
+import { addDays as addLocalDays, dayKey, dayLabel, timeLabel, toDate } from "@himalaya/time";
+import { dispatch } from "@himalaya/dispatch";
+import { bookSchedule, bookSlot, getService, queryServiceAvailability, registerToWaitlist, type WixBookingSlotFull, type WixSelectedPaymentOption, type WixService } from "@himalaya/wix-bookings";
+import { createCheckout, createOrder } from "@himalaya/wix-ecom";
+import { createRedirectSession, type WixSlot } from "@himalaya/wix-redirects";
+import { isPaymentSetupFailure, payCashierOrder } from "@himalaya/checkout";
+import { hostedCheckoutOpener, isHostedWorker } from "../_shared/hosted-checkout.js";
+import { session as wixPlatformSession } from "@himalaya/wix-platform";
+import { displayName, getMyData, type WixMyData } from "@himalaya/wix-users";
+import { formatServicePrice, serviceIsChargeable } from "../_shared/wix-service-price.js";
+import { stashCopy, copyParam, copyPlural, copyTemplate } from "../_shared/himi-copy.js";
+import { upsert as dbUpsert, remove as dbRemove, enqueue as dbEnqueue, type DbEntity } from "@himalaya/local-db";
+import { locationChoice, readSharedLocationResult, writeSharedLocation } from "../_shared/booking-location.js";
+import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
+import { emitHostEvent, hostEventInstant } from "../_shared/host-events.js";
+import { availabilityBeyond, courseReadWindows, courseSessionsAvailability, courseWindowOpen, slotIdAt } from "../_shared/himi-bookings.js";
+import { wixMediaUrl, WIX_DETAIL_IMAGE, WIX_LIST_IMAGE } from "@himalaya/wix-media";
+import { mayUseRegularBookingCheckout } from "../_shared/iap-attendance.js";
+import { ATTENDANCE_INITIAL, ATTENDANCE_NOT_HYDRATED, createAttendancePurchase, type AttendancePurchaseFields } from "../_shared/iap-attendance-purchase.js";
+import { resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
+
+// Offline-first (data-offline): booking a slot is WRITE-BEHIND against the
+// `member_bookings` entity (the same rows the My Bookings worker reads). The
+// booking is written to the local store OPTIMISTICALLY so My Bookings repaints
+// from cache immediately, then the Wix write is attempted; if it can't reach the
+// bridge/network the mutation is ENQUEUED for replay on reconnect. Every local-db
+// call is wrapped (try/catch) so a build that ships without the `local_database`
+// grant behaves exactly as before (online-only, no cache/queue).
+const ENTITY = "member_bookings";
+async function cachePut(row: DbEntity): Promise<void> { try { await dbUpsert(ENTITY, row); } catch { /* capability not granted */ } }
+async function cacheDrop(id: string): Promise<void> { try { await dbRemove(ENTITY, id); } catch { /* capability not granted */ } }
+async function queueWrite(actionId: string, params: Record<string, string>): Promise<void> { try { await dbEnqueue(actionId, params); } catch { /* capability not granted */ } }
+
+/** One bookable slot row. Every row is a real slot.
+ *
+ *  #3276 — the screen used to render the WHOLE 14-day window as one flat agenda
+ *  (the day heading riding on each day's first row), capped at 24 rows, with the
+ *  sign-in card under all of it. It now shows ONE day at a time: `days` feeds a
+ *  day strip, `slots` holds only the selected day's rows, and the strip is the
+ *  heading — so rows no longer carry a per-row one. */
+interface SlotRow {
+  id: string;
+  /** Local calendar-day key (`YYYY-MM-DD`) the slot starts on. */
+  dayKey: string;
+  /** Day label carried for the selected-line copy, on every row. */
+  day: string;
+  /** Compact day label for the strip chip ("Sun 27"). */
+  dayChip: string;
+  title: string;
+  subtitle: string;
+  badge: string;
+  noBadge: boolean;
+  badgeWarning: boolean;
+  badgeNeutral: boolean;
+  selectable: boolean;
+  notSelectable: boolean;
+  selected: boolean;
+  notSelected: boolean;
+  /** The slot's start (ISO), for ordering and the pill label. */
+  start: string;
+  /** The staff member (`slot.resource`): id, else name; "" when the slot names none. */
+  staffKey: string;
+  staffName: string;
+  /** The slot's location key (id, else name + address) and its labels; "" when it has none. */
+  locKey: string;
+  locLabel: string;
+  locSub: string;
+  /** The location as every bookings screen keys it (`booking-location.ts`): what the shared
+   *  choice of Services and the Agenda names. "" when it has none. */
+  locPlace: string;
+}
+
+/** One time in a staff group: a pill with three looks. */
+interface TimePill {
+  id: string;
+  label: string;
+  badge: string;
+  hasBadge: boolean;
+  noBadge: boolean;
+  a11y: string;
+  available: boolean;
+  notAvailable: boolean;
+  picked: boolean;
+  notPicked: boolean;
+  unavailable: boolean;
+  notUnavailable: boolean;
+}
+
+/** The selected day's times for one staff member (or the times that name no one). */
+interface StaffGroup {
+  id: string;
+  name: string;
+  image: string;
+  hasImage: boolean;
+  noImage: boolean;
+  noStaffHeader: boolean;
+  hasStaffHeader: boolean;
+  times: TimePill[];
+}
+
+/** One row of the location sheet. `id` "" is "All locations". */
+interface LocationOption {
+  id: string;
+  label: string;
+  sub: string;
+  hasSub: boolean;
+  noSub: boolean;
+  selected: boolean;
+  notSelected: boolean;
+  a11y: string;
+}
+
+interface S extends AttendancePurchaseFields {
+  status: "loading" | "ready";
+  id: string;
+  serviceName: string;
+  serviceLine: string;
+  /** Service header — image + price + duration from getService (previously
+   *  discarded); each collapses when the catalog carries none. */
+  serviceImage: string;
+  hasServiceImage: boolean;
+  noServiceImage: boolean;
+  servicePrice: string;
+  serviceDuration: string;
+  /** True when the service carries a positive price — a PAID service routes the
+   *  booking through the hosted Wix bookings checkout (GPV) instead of the free
+   *  bookSlot rung. Set from the service payload during load. */
+  serviceIsPaid: boolean;
+  coursePaymentOption: WixSelectedPaymentOption | "";
+  courseAvailable: boolean;
+  isCourse: boolean;
+  notCourse: boolean;
+  scheduleId: string;
+  courseStart: string;
+  courseEnd: string;
+  /** Day-strip chips: every day of the window (a day with no times shows a zero
+   *  count rather than being silently skipped), in the FilterChips option shape. */
+  days: DayOption[];
+  /** The day whose slots are shown — defaults to the first day that has any. */
+  selectedDay: string;
+  /** Full heading for the selected day ("Today", "Mon, Sep 28"). */
+  selectedDayLabel: string;
+  /** Only the selected day's slots. */
+  slots: SlotRow[];
+  /** Copy for a selected day with no times; "" when the day has slots. */
+  dayEmptyText: string;
+  hasDaySlots: boolean;
+  noDaySlots: boolean;
+  /** No times anywhere in the window — the day strip and heading step aside
+   *  for the screen-level empty state. */
+  noWindowSlots: boolean;
+  selectedSlotId: string;
+  selectedLine: string;
+  emptyText: string;
+  message: string;
+  successMessage: string;
+  hasSuccess: boolean;
+  noSuccess: boolean;
+  errored: boolean;
+  notErrored: boolean;
+  isLoading: boolean;
+  notLoading: boolean;
+  hasSlots: boolean;
+  noEmpty: boolean;
+  hasSelected: boolean;
+  noSelected: boolean;
+  /** #3276 — the sign-in/register card belongs to the moment of booking: hidden
+   *  for a member, and for a visitor until they have picked a time. */
+  hideSignIn: boolean;
+  hideTimeSignIn: boolean;
+  hideCourseSignIn: boolean;
+  hideWaitlistSignIn: boolean;
+  canBook: boolean;
+  cannotBook: boolean;
+  hideTimeBook: boolean;
+  hideCourseBook: boolean;
+  hideWaitlistBook: boolean;
+  hideDayPicker: boolean;
+  hideDaySlots: boolean;
+  hideDayEmpty: boolean;
+  showChoosePrompt: boolean;
+  hideChoosePrompt: boolean;
+  isMember: boolean;
+  notMember: boolean;
+  identityLine: string;
+  authTitle: string;
+  authBody: string;
+  email: string;
+  password: string;
+  firstName: string;
+  lastName: string;
+  isRegistering: boolean;
+  notRegistering: boolean;
+  bookingInFlight: boolean;
+  notBooking: boolean;
+  bookingsScreenId: string;
+  /** First day of the day strip (`YYYY-MM-DD`): today, or the first two weeks with times. */
+  windowStart: string;
+  /** The location filter: "" is every location. */
+  locationId: string;
+  locationLabel: string;
+  locationA11y: string;
+  locationOptions: LocationOption[];
+  locationSheetOpen: boolean;
+  /** Two or more locations: the trailing side of the day row opens the sheet. */
+  hasLocationMenu: boolean;
+  noLocationMenu: boolean;
+  /** Exactly one location with a name or an address: its name, not tappable. */
+  singleLocation: string;
+  hasSingleLocation: boolean;
+  noSingleLocation: boolean;
+  /** The selected day's times, grouped by staff member. */
+  groups: StaffGroup[];
+  /** The selected day has no time to book (the window has some). */
+  dayEmpty: boolean;
+  hasDayTimes: boolean;
+  /** Nothing to book in the next 90 days: one message under the header. */
+  noUpcoming: boolean;
+  hasUpcoming: boolean;
+  /** The result of a tap, in a sheet above the tab bar: a booking stays until closed, other
+   *  results close by themselves. */
+  resultText: string;
+  resultSticky: boolean;
+  resultAuto: boolean;
+  resultIsBooking: boolean;
+  resultNotBooking: boolean;
+  /** A course has no times: its messages stay on the screen, under its button. */
+  courseMessage: string;
+}
+
+/** One day-strip chip — the `FilterChips` option shape `dateStrip` binds. */
+interface DayOption {
+  id: string;
+  label: string;
+  count: number;
+  hasSlots: boolean;
+}
+
+let slotsById = new Map<string, WixBookingSlotFull>();
+let waitlistIds = new Set<string>();
+let regularCheckoutAllowed = false;
+let regularServicePrice = "";
+let lastReady: S | undefined;
+const applePurchase = createAttendancePurchase({ kind: "bookingsService", prefix: "time", pollAction: "himiBookingTime.iapPoll", onChange: () => { void svc.iapPublish(); } });
+/** Every slot row in the window, across all days. Kept out of worker state so
+ *  the state the host receives holds one day's rows, not the whole window. */
+let allRows: SlotRow[] = [];
+
+/** Days the strip offers, from today. */
+// No row cap. The old flat list capped the WHOLE window at 24 rows, which
+// silently dropped every day after the first one or two — times a customer
+// could neither see nor book. Worker state now carries one day's rows, so the
+// bound that list needed is gone, and the availability query has no paging.
+const WINDOW_DAYS = 14;
+/** How far ahead the screen looks for a first time, and for "Check Next Availability". */
+const HORIZON_DAYS = 90;
+const DAY_MS = 86_400_000;
+
+/** The service record of the last load (its type and waitlist policy shape new rows). */
+let lastService: WixService | undefined;
+/** The selected day's times that cannot be booked (full, too early, too late), by day. They show
+ *  greyed. Read with `bookable: false` for one day at a time, because that response is large. */
+let greyByDay = new Map<string, SlotRow[]>();
+/** Staff photos from the service's `staffMemberDetails`, by staff id and by name. */
+let staffPhotos = { byId: new Map<string, string>(), byName: new Map<string, string>() };
+/** True while a tap books. A second tap, or a tap during a booking, sends nothing. */
+let bookingLock = false;
+
+/** A course booking created by an earlier tap whose checkout or payment did not finish. It stays
+ *  on Wix, so the next tap pays for THIS booking instead of creating a second one for the same
+ *  customer. `ordered` once its order exists: the order is what holds the place. Cleared once a
+ *  booking goes through. */
+let pendingCourseBooking: { scheduleId: string; email: string; ordered?: boolean; booking: { id?: string; startDate?: string; endDate?: string } } | null = null;
+
+/** A course occupies one place for its whole schedule, so it can be booked only while its
+ * booking window is open and EVERY upcoming session still has room — not just the next one
+ * (_shared/himi-bookings.ts, the same rule the service screen's button uses). */
+/** Whether this customer may book the course now. Once an order of theirs holds a place (`held`),
+ *  counting places would refuse them their own, so only the booking window is checked again. */
+async function courseOpenTo(service: WixService, now: Date, held: boolean): Promise<boolean> {
+  return held ? !!service.schedule?.id && courseWindowOpen(service, now.getTime()) : courseIsBookable(service, now);
+}
+
+async function courseIsBookable(service: WixService, now: Date): Promise<boolean> {
+  const current = now.getTime();
+  if (!service.schedule?.id || !courseWindowOpen(service, current)) return false;
+  const read = courseReadWindows(service, current);
+  const reads = read.windows.map(([from, to]) =>
+    queryServiceAvailability(service.id, isoDate(new Date(from)), isoDate(new Date(to)), { bookable: false }));
+  const entries = (await Promise.all(reads)).flatMap((res) => res.availabilityEntries ?? []);
+  const course = courseSessionsAvailability(entries, current, read.complete);
+  return course.found && course.bookable;
+}
+
+/** The service screen opens this screen with `course: "true"` for a course. When the service
+ *  record then fails to load, the screen errors instead of listing the course's sessions as
+ *  single times (where a booking would take one session, not the whole course). */
+const courseInput = (() => {
+  const course = (globalThis as { himalaya?: { input?: { course?: unknown } } }).himalaya?.input?.course;
+  return course === true || course === "true";
+})();
+
+function inputId(): string {
+  // WS-C — `himalaya.input.id` is the PRIMARY contract: hosts thread the row's
+  // `id` nav param (himi.open { screenId: "himi_time", id }) into worker input.
+  // The screenId-slice below is #570 back-compat for pre-params releases with
+  // baked `himi_time_<id>` screenIds — do not author against this.
+  // `serviceId` is the same thing under the name a HOST uses to open this screen (the deep-entry
+  // contract: Branded Lite README, "Opening at a booking").
+  const input = (globalThis as { himalaya?: { input?: { id?: unknown; serviceId?: unknown; screenId?: unknown } } }).himalaya?.input;
+  if (typeof input?.id === "string" && input.id) return input.id;
+  if (typeof input?.serviceId === "string" && input.serviceId) return input.serviceId;
+  const screenId = typeof input?.screenId === "string" ? input.screenId : "";
+  return screenId.startsWith("himi_time_") ? screenId.slice("himi_time_".length) : "";
+}
+
+/** The time a host opened this screen at (`himalaya.input.start`, ISO 8601), or "". Every load
+ *  preselects that slot (or opens on its day) until the member picks a day or a time themselves —
+ *  not just the first, because the boot load and the screen's own `load` can overlap. */
+/** Counts the customer's picks. A load that sees it move ran while they picked a time. */
+let selectionRevision = 0;
+// Each guest tap that asks the session first: only the newest answers, so two quick taps whose
+// reads come back out of order never pick the older time or open a second sign-in.
+let sessionTaps = 0;
+
+let pendingStart = (() => {
+  const start = (globalThis as { himalaya?: { input?: { start?: unknown } } }).himalaya?.input?.start;
+  return typeof start === "string" && Number.isFinite(Date.parse(start)) ? start : "";
+})();
+/** The exact session a host opened this screen at (`himalaya.input.sessionId`), when it names one:
+ *  two sessions of a class can start at the same instant, and `start` alone picks the first. */
+/** A host's `start` past the two-week window, kept for the life of this worker: a pick on that day
+ *  clears `pendingStart`, yet the reload after the guest sign-in step must still read it. */
+const farStart = pendingStart;
+let pendingSession = (() => {
+  const id = (globalThis as { himalaya?: { input?: { sessionId?: unknown } } }).himalaya?.input?.sessionId;
+  return typeof id === "string" ? id.trim() : "";
+})();
+
+function strOf(arg: unknown): string {
+  if (typeof arg === "string") return arg;
+  const a = arg as { value?: string; text?: string } | undefined;
+  return a?.value ?? a?.text ?? "";
+}
+
+/** Bound an identity probe to a real budget: reject after `ms` so the callers'
+ *  catch-arms fall back (guest identity) instead of pinning the skeleton behind
+ *  a hung dispatch. Load awaits probeMember BEFORE availability, so an unbounded
+ *  probe used to stall the whole screen. Tier-5 JSC workers are timer-less
+ *  (no setTimeout is installed there); where no timer exists we degrade to the
+ *  raw promise — the WebView/web-worker hosts (where the hang was observed)
+ *  do expose one. */
+function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  const host = globalThis as {
+    setTimeout?: (fn: () => void, ms: number) => unknown;
+    clearTimeout?: (timer: unknown) => void;
+  };
+  if (typeof host.setTimeout !== "function") return promise;
+  return new Promise<T>((resolve, reject) => {
+    const timer = host.setTimeout!(() => reject(new Error(`timed out after ${ms}ms`)), ms);
+    const settle = () => { try { host.clearTimeout?.(timer); } catch { /* best-effort */ } };
+    promise.then(
+      (value) => { settle(); resolve(value); },
+      (error) => { settle(); reject(error instanceof Error ? error : new Error(String(error))); },
+    );
+  });
+}
+
+function isoDate(date: Date): string {
+  return date.toISOString();
+}
+
+function fmtRange(start?: string, end?: string): { day: string; title: string; subtitle: string } {
+  const s = toDate(start);
+  if (!s) return { day: "", title: "Available time", subtitle: "" };
+  const endTime = timeLabel(end);
+  return {
+    // "Today" / "Tomorrow" / "Mon, Jun 9" — the shared relative window, so this
+    // screen's headings read the same as every other agenda in the app.
+    day: dayLabel(s),
+    title: timeLabel(s),
+    subtitle: endTime ? `Until ${endTime}` : "Bookable slot",
+  };
+}
+
+/** Service price/duration/image display fields (getService previously discarded
+ *  them).
+ *
+ *  Price and currency come from `_shared/wix-service-price.ts`, the one door #816
+ *  introduced so these four workers could not drift. This one was left behind: it kept
+ *  its own probe of `payment.price` / `payment.currency`, which the live Bookings v2
+ *  payload does not have — the fixed price is nested at
+ *  `payment.fixed.price.{value,currency}`. The amount still resolved via the top-level
+ *  fallback, but the currency fell through to the hardcoded `"USD"`, so a real ILS site
+ *  rendered `$120` for a ₪120 service — on the CONFIRM screen, the last thing a customer
+ *  reads before committing. Measured on a live site, where the list screen (already
+ *  migrated) said ₪120 and this one said $120 for the same service. */
+function serviceHeaderFields(service: unknown): { image: string; price: string; duration: string; paid: boolean } {
+  const raw = (service ?? {}) as { duration?: unknown };
+  const price = formatServicePrice(service);
+  // `paid` routes the PAYMENT branch (see bookSelected), so it is a money decision, not a
+  // display one. `serviceAmount() > 0` is the wrong predicate for it: that returns
+  // undefined for VARIED/CUSTOM, which are chargeable services with no single figure — so
+  // a booking for one went down the free branch, booked and never charged. #816 shipped
+  // that shape and review caught it here.
+  const paid = serviceIsChargeable(service);
+  const minutes = typeof raw.duration === "number" ? raw.duration : (typeof raw.duration === "string" && raw.duration.trim() ? Number(raw.duration) : 0);
+  let duration = "";
+  if (minutes && !Number.isNaN(minutes)) {
+    if (minutes < 60) duration = `${minutes} min`;
+    else {
+      const hours = Math.floor(minutes / 60);
+      const rest = minutes % 60;
+      duration = rest ? `${hours} hr ${rest} min` : `${hours} hr`;
+    }
+  }
+  return { image: serviceImageUrl(service), price, duration, paid };
+}
+
+function serviceImageUrl(value: unknown): string {
+  if (typeof value === "string") return wixMediaUrl(value, WIX_DETAIL_IMAGE);
+  if (!value || typeof value !== "object") return "";
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const url = serviceImageUrl(item);
+      if (url) return url;
+    }
+    return "";
+  }
+  const node = value as Record<string, unknown>;
+  for (const direct of [node.url, node.src, node.imageUrl, node.imageSrc]) {
+    const url = wixMediaUrl(direct, WIX_DETAIL_IMAGE);
+    if (url) return url;
+  }
+  for (const key of ["image", "thumbnail", "mediaItem", "mainMedia", "main", "media", "items", "photos", "gallery", "coverImage"]) {
+    const url = serviceImageUrl(node[key]);
+    if (url) return url;
+  }
+  return "";
+}
+
+/** The day id out of a chip-selection payload: FilterChips' onChange contract is
+ *  `{ selectedIds }` on every renderer; the string / `{ dayId }` / `{ id }` arms
+ *  keep direct dispatches working. A re-tap of the active chip emits `[]`. */
+function chosenDay(arg: unknown): string {
+  if (typeof arg === "string") return arg;
+  const a = arg as { selectedIds?: unknown; dayId?: unknown; id?: unknown } | undefined;
+  const ids = a?.selectedIds;
+  if (Array.isArray(ids)) return typeof ids[0] === "string" ? ids[0] : "";
+  if (typeof ids === "string") return ids;
+  if (typeof a?.dayId === "string") return a.dayId;
+  return typeof a?.id === "string" ? a.id : "";
+}
+
+/** A slot's location: a key to compare by (id, else name + address) and its labels. A location
+ *  with neither a name nor an address has no key: it is not offered and not counted. */
+function locationOf(slot: WixBookingSlotFull): { key: string; label: string; sub: string } {
+  const loc = (slot.location ?? {}) as { id?: unknown; name?: unknown; formattedAddress?: unknown; locationType?: unknown };
+  const name = typeof loc.name === "string" ? loc.name.trim() : "";
+  const address = typeof loc.formattedAddress === "string" ? loc.formattedAddress.trim() : "";
+  const id = typeof loc.id === "string" ? loc.id : "";
+  if (loc.locationType === "CUSTOMER") return { key: id || "customer", label: copyParam("bookingCommon.clientPlace", "Client's place"), sub: "" };
+  if (!name && !address) return { key: "", label: "", sub: "" };
+  return { key: id || `${name}|${address}`, label: name || address, sub: name && address ? address : "" };
+}
+
+function staffOf(slot: WixBookingSlotFull): { key: string; name: string } {
+  const resource = (slot.resource ?? {}) as { id?: unknown; name?: unknown };
+  const name = typeof resource.name === "string" ? resource.name.trim() : "";
+  const id = typeof resource.id === "string" ? resource.id : "";
+  return { key: id || name, name };
+}
+
+/** The rows for one availability response. A class lists its full sessions too (greyed, or a
+ *  waitlist). Two slots at the same instant with different staff get distinct ids. */
+function slotRows(entries: ReadonlyArray<{ slot?: WixBookingSlotFull; bookable?: boolean; openSpots?: number; waitingList?: { openSpots?: number } }>, service: WixService | undefined): { rows: SlotRow[]; slots: Map<string, WixBookingSlotFull>; waitlist: Set<string> } {
+  const slots = new Map<string, WixBookingSlotFull>();
+  const waitlist = new Set<string>();
+  const rows: SlotRow[] = [];
+  const used = new Set<string>();
+  // Group by LOCAL calendar day, not by the formatted heading: two
+  // distinct days can render the same text, and a UTC-derived key can
+  // name a different day than the heading beside it.
+  const classService = service?.type === "CLASS";
+  for (const [index, entry] of entries
+    .filter((candidate) => candidate.slot?.startDate && (candidate.bookable !== false || (classService && candidate.openSpots === 0)))
+    .entries()) {
+    const slot = entry.slot as WixBookingSlotFull;
+    const key = dayKey(slot.startDate);
+    if (!key) continue;
+    const staff = staffOf(slot);
+    const base = String(slot.sessionId ?? slot.startDate ?? `slot-${index}`);
+    const slotId = used.has(base) ? `${base}#${staff.key || index}` : base;
+    used.add(slotId);
+    const openSpots = classService && typeof entry.openSpots === "number" && entry.openSpots >= 0 ? entry.openSpots : undefined;
+    const isWaitlist = openSpots === 0 && service?.bookingPolicy?.waitlistPolicy?.enabled === true &&
+      typeof entry.waitingList?.openSpots === "number" && entry.waitingList.openSpots > 0;
+    const selectable = (entry.bookable !== false && openSpots !== 0) || isWaitlist;
+    if (isWaitlist) waitlist.add(slotId);
+    else if (selectable) slots.set(slotId, slot);
+    const label = fmtRange(slot.startDate, slot.endDate);
+    const loc = locationOf(slot);
+    rows.push({
+      id: slotId,
+      dayKey: key,
+      day: label.day,
+      dayChip: dayLabel(slot.startDate, { format: "compact" }),
+      title: label.title,
+      subtitle: label.subtitle,
+      badge: openSpots == null ? "" : openSpots > 0
+        ? copyPlural("time.spotsLeft", "{n, plural, one {# spot left} other {# spots left}}", openSpots)
+        : isWaitlist ? copyParam("time.waitlistBadge", "Waitlist") : copyParam("time.fullBadge", "Full"),
+      noBadge: openSpots == null,
+      badgeWarning: openSpots != null && openSpots > 0 && openSpots <= 3,
+      badgeNeutral: openSpots == null || openSpots === 0 || openSpots > 3,
+      selectable,
+      notSelectable: !selectable,
+      selected: false,
+      notSelected: true,
+      start: slot.startDate ?? "",
+      staffKey: staff.key,
+      staffName: staff.name,
+      locKey: loc.key,
+      locLabel: loc.label,
+      locSub: loc.sub,
+      locPlace: locationChoice(slot.location as Parameters<typeof locationChoice>[0]).key,
+    });
+  }
+  return { rows, slots, waitlist };
+}
+
+/** The unbookable times of one day's `bookable: false` response that are still ahead (full,
+ *  too early or too late to book). Never a past time, and never one the window already lists. */
+function greyRows(entries: ReadonlyArray<{ slot?: WixBookingSlotFull; bookable?: boolean }>, day: string, known: SlotRow[], now: number): SlotRow[] {
+  const seen = new Set(known.map((row) => `${row.start}|${row.staffKey}`));
+  const unbookable = entries.filter((entry) => entry.bookable === false && entry.slot?.startDate
+    && Date.parse(entry.slot.startDate) > now && dayKey(entry.slot.startDate) === day)
+    .map((entry) => ({ ...entry, bookable: true }));
+  return slotRows(unbookable, undefined).rows
+    .filter((row) => !seen.has(`${row.start}|${row.staffKey}`))
+    .map((row) => ({ ...row, id: `grey:${row.id}`, selectable: false, notSelectable: true }));
+}
+
+/** Earliest day first. A plain string compare: `YYYY-MM-DD` keys sort as text, and a worker on
+ *  a watch engine has no locale-aware string compare. */
+function byDay(a: SlotRow, b: SlotRow): number {
+  return a.dayKey < b.dayKey ? -1 : a.dayKey > b.dayKey ? 1 : 0;
+}
+
+function locationMatches(row: SlotRow, locationId: string): boolean {
+  return !locationId || row.locKey === locationId;
+}
+
+/** Every distinct location of the window's times (the greyed ones read so far included), in the
+ *  order they first appear. */
+function windowLocations(): Array<{ key: string; label: string; sub: string; place: string }> {
+  const seen = new Map<string, { key: string; label: string; sub: string; place: string }>();
+  for (const row of [...allRows, ...[...greyByDay.values()].flat()]) if (row.locKey && !seen.has(row.locKey)) seen.set(row.locKey, { key: row.locKey, label: row.locLabel, sub: row.locSub, place: row.locPlace });
+  return [...seen.values()];
+}
+
+function staffPhoto(key: string, name: string): string {
+  return staffPhotos.byId.get(key) ?? (name ? staffPhotos.byName.get(name.toLowerCase()) : undefined) ?? "";
+}
+
+function readStaffPhotos(service: WixService | undefined): void {
+  const byId = new Map<string, string>();
+  const byName = new Map<string, string>();
+  for (const member of service?.staffMemberDetails?.staffMembers ?? []) {
+    const url = wixMediaUrl(member?.mainMedia?.image?.url, WIX_LIST_IMAGE);
+    if (!url) continue;
+    const m = member as { staffMemberId?: string; resourceId?: string; name?: string };
+    if (m.staffMemberId) byId.set(m.staffMemberId, url);
+    if (m.resourceId) byId.set(m.resourceId, url);
+    if (m.name) byName.set(m.name.trim().toLowerCase(), url);
+  }
+  staffPhotos = { byId, byName };
+}
+
+/** The selected day's times after the location filter, grouped by staff member. Groups are ordered
+ *  by their first time (ties by name); a group's times by start. Times that name no staff member
+ *  share one group with no header. */
+function groupsOf(s: S): StaffGroup[] {
+  const day = [...allRows, ...(greyByDay.get(s.selectedDay) ?? [])]
+    .filter((row) => row.dayKey === s.selectedDay && locationMatches(row, s.locationId))
+    .sort((a, b) => Date.parse(a.start) - Date.parse(b.start));
+  const anyStaff = day.some((row) => row.staffKey);
+  const groups = new Map<string, { name: string; rows: SlotRow[] }>();
+  for (const row of day) {
+    const key = anyStaff ? row.staffKey : "";
+    const group = groups.get(key) ?? { name: row.staffName, rows: [] };
+    group.rows.push(row);
+    groups.set(key, group);
+  }
+  return [...groups.entries()]
+    .sort(([ka, a], [kb, b]) => (!ka ? 1 : !kb ? -1 : 0) || Date.parse(a.rows[0]!.start) - Date.parse(b.rows[0]!.start) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+    .map(([key, group]) => {
+      const image = key ? staffPhoto(key, group.name) : "";
+      return {
+        id: key || "none",
+        name: group.name,
+        image,
+        hasImage: !!image,
+        noImage: !image,
+        noStaffHeader: !key,
+        hasStaffHeader: !!key,
+        times: group.rows.map((row) => {
+          const picked = row.selectable && row.id === s.selectedSlotId;
+          const available = row.selectable && !picked;
+          const label = row.title;
+          const named = group.name
+            ? copyTemplate("time.slotLabel", "{time} with {staff}", { time: label, staff: group.name })
+            : label;
+          const a11y = row.selectable
+            ? [named, row.badge, picked ? copyParam("bookingCommon.selected", "Selected") : ""].filter(Boolean).join(", ")
+            : copyTemplate("time.slotUnavailable", "{time}, unavailable", { time: label });
+          return {
+            id: row.id,
+            label,
+            badge: row.badge,
+            hasBadge: !!row.badge,
+            noBadge: !row.badge,
+            a11y,
+            available,
+            notAvailable: !available,
+            picked,
+            notPicked: !picked,
+            unavailable: !row.selectable,
+            notUnavailable: row.selectable,
+          };
+        }),
+      };
+    });
+}
+
+/** Every day of the window from `now` (local), plus any day a slot lands on
+ *  outside it, sorted — each with its slot count. */
+function daysOf(rows: SlotRow[], now: Date = new Date()): DayOption[] {
+  const counts = new Map<string, number>();
+  const labels = new Map<string, string>();
+  for (const row of rows) {
+    counts.set(row.dayKey, (counts.get(row.dayKey) ?? 0) + 1);
+    if (!labels.has(row.dayKey)) labels.set(row.dayKey, row.dayChip);
+  }
+  for (let offset = 0; offset < WINDOW_DAYS; offset++) {
+    const at = addLocalDays(now, offset);
+    const key = at ? dayKey(at) : "";
+    // Compact ("Sun 27"), not the full heading: these are pills in a strip.
+    if (key && !labels.has(key)) labels.set(key, dayLabel(at, { format: "compact" }));
+  }
+  return [...labels.keys()].sort().map((key) => {
+    const count = counts.get(key) ?? 0;
+    return { id: key, label: labels.get(key) ?? key, count, hasSlots: count > 0 };
+  });
+}
+
+/** Show `day`: its heading. `derive` fills its rows from the current selection and location. */
+function withDay(s: S, day: string): S {
+  const rows = allRows.filter((row) => row.dayKey === day);
+  const noon = day ? new Date(`${day}T12:00:00`) : null;
+  return {
+    ...s,
+    selectedDay: day,
+    selectedDayLabel: rows[0]?.day ?? (noon && !Number.isNaN(noon.getTime()) ? dayLabel(noon) : ""),
+    slots: rows.map((row) => ({ ...row, selected: row.id === s.selectedSlotId, notSelected: row.id !== s.selectedSlotId })),
+  };
+}
+
+/** The day strip, the day's rows, the staff groups and the location row, from the window's rows,
+ *  the selected day and the location filter. Only for a loaded list of times (not a course). */
+function timesView(s: S): Pick<S, "days" | "slots" | "groups" | "locationOptions" | "locationLabel" | "locationA11y" | "hasLocationMenu" | "noLocationMenu" | "singleLocation" | "hasSingleLocation" | "noSingleLocation"> {
+  const all = copyParam("time.allLocations", "All locations");
+  const shown = s.status === "ready" && !s.isCourse && !s.errored && !!s.windowStart;
+  const locations = shown ? windowLocations() : [];
+  const visible = allRows.filter((row) => locationMatches(row, s.locationId));
+  const label = s.locationId ? (locations.find((l) => l.key === s.locationId)?.label ?? all) : all;
+  const single = locations.length === 1 ? locations[0]!.label : "";
+  return {
+    days: shown ? daysOf(visible, new Date(`${s.windowStart}T12:00:00`)) : s.days,
+    slots: shown
+      ? visible.filter((row) => row.dayKey === s.selectedDay).map((row) => ({ ...row, selected: row.id === s.selectedSlotId, notSelected: row.id !== s.selectedSlotId }))
+      : s.slots,
+    groups: shown ? groupsOf(s) : [],
+    locationOptions: locations.length >= 2 ? [{ key: "", label: all, sub: "" }, ...locations].map((l) => {
+      const selected = l.key === s.locationId;
+      return { id: l.key, label: l.label, sub: l.sub, hasSub: !!l.sub, noSub: !l.sub, selected, notSelected: !selected,
+        a11y: [l.label, l.sub, selected ? copyParam("bookingCommon.selected", "Selected") : ""].filter(Boolean).join(", ") };
+    }) : [],
+    locationLabel: label,
+    locationA11y: copyTemplate("time.locationLabel", "Location, {label}", { label }),
+    hasLocationMenu: locations.length >= 2,
+    noLocationMenu: locations.length < 2,
+    singleLocation: single,
+    hasSingleLocation: !!single,
+    noSingleLocation: !single,
+  };
+}
+
+function derive(input: S): S {
+  const s: S = { ...input, ...timesView(input) };
+  const regular = regularCheckoutAllowed || applePurchase.usesRegularPlatform();
+  // `hasSlots` is the WHOLE window (it drives the screen-level empty state); the
+  // selected day having none is a per-day line, not an empty screen.
+  const hasSlots = s.days.some((d) => d.hasSlots) || s.slots.length > 0;
+  const hasDaySlots = s.slots.length > 0;
+  const timesShown = s.status === "ready" && !s.isCourse && !s.errored;
+  // Nothing to BOOK in the 90 days: a class's full sessions alone (grey rows) are no upcoming session.
+  const noUpcoming = timesShown && !allRows.some((row) => row.selectable);
+  const dayEmpty = timesShown && !noUpcoming && !s.slots.some((row) => row.selectable);
+  const resultText = s.isCourse ? "" : (s.successMessage || s.message);
+  const hasSelected = s.isCourse ? !!s.scheduleId && s.courseAvailable : !!s.selectedSlotId;
+  const selectedWaitlist = !s.isCourse && waitlistIds.has(s.selectedSlotId);
+  const hasSuccess = !!s.successMessage;
+  const canBook = regular && s.isMember && hasSelected && !s.bookingInFlight && !hasSuccess;
+  const showChoosePrompt = regular && !s.isCourse && s.isMember && hasSlots && !hasSelected && !s.bookingInFlight && !hasSuccess;
+  const isRegistering = !!s.isRegistering;
+  const next: S = {
+    ...s,
+    _poll: undefined,
+    servicePrice: regular ? regularServicePrice : "",
+    // A course is booked whole, not from the 14-day window of times, so it has no window line.
+    serviceLine: s.status === "ready" ? [s.serviceDuration, regular ? regularServicePrice : ""].filter(Boolean).join(" · ") : s.serviceLine,
+    message: regular && !regularCheckoutAllowed && s.message === copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") ? "" : s.message,
+    hasSlots,
+    // A waitlist pick or a course is not an in-app purchase: neither enables the Apple button.
+    ...applePurchase.fields(hasSelected && !selectedWaitlist && !s.isCourse),
+    hasSelected,
+    noSelected: !hasSelected,
+    // The shared sign-in card: no sign-in for a course this screen cannot sell (as below).
+    hideSignIn: s.isMember || !hasSelected || (s.isCourse && !regular),
+    hideTimeSignIn: s.isMember || !hasSelected || s.isCourse || selectedWaitlist,
+    // A course has no in-app purchase path: where it cannot use the regular checkout, a guest is
+    // not sent to sign in for a button that will not be there.
+    hideCourseSignIn: s.isMember || !hasSelected || !s.isCourse || !regular,
+    hideWaitlistSignIn: s.isMember || !hasSelected || s.isCourse || !selectedWaitlist,
+    notCourse: !s.isCourse,
+    hasDaySlots,
+    noDaySlots: !hasDaySlots,
+    noWindowSlots: !hasSlots && !s.isCourse,
+    // Only a quiet DAY in a window that has times gets the per-day line; a
+    // window with no times at all is the screen-level empty state's job.
+    // The window (not the location filter) decides: a location with only greyed times keeps the
+    // strip, the location row and "Check Next Availability".
+    dayEmptyText: !dayEmpty || !s.selectedDay
+      ? ""
+      : copyParam("time.dayEmptyText", "Nothing available for this date."),
+    dayEmpty: dayEmpty && !!s.selectedDay,
+    hasDayTimes: !(dayEmpty && !!s.selectedDay),
+    noUpcoming,
+    hasUpcoming: !noUpcoming,
+    resultText,
+    resultSticky: !!resultText && !!s.successMessage,
+    resultAuto: !!resultText && !s.successMessage,
+    resultIsBooking: !!s.successMessage,
+    resultNotBooking: !s.successMessage,
+    courseMessage: s.isCourse ? (s.successMessage || s.message) : "",
+    hasSuccess,
+    noSuccess: !hasSuccess,
+    canBook,
+    cannotBook: !canBook,
+    hideTimeBook: !canBook || s.isCourse || selectedWaitlist,
+    hideCourseBook: !canBook || !s.isCourse,
+    // Joining a waitlist buys nothing, so it does not wait on the purchase route.
+    hideWaitlistBook: !s.isMember || !hasSelected || s.isCourse || !selectedWaitlist || s.bookingInFlight || hasSuccess,
+    hideDayPicker: s.isCourse || !timesShown || noUpcoming,
+    hideDaySlots: s.isCourse || s.groups.length === 0,
+    hideDayEmpty: s.isCourse || hasDaySlots,
+    showChoosePrompt,
+    hideChoosePrompt: !showChoosePrompt,
+    isLoading: s.status === "loading",
+    notLoading: s.status !== "loading",
+    noEmpty: s.status === "loading" || s.errored || hasSlots || s.isCourse,
+    notErrored: !s.errored,
+    notMember: !s.isMember,
+    notBooking: !s.bookingInFlight,
+    emptyText: hasSlots
+      ? ""
+      : (s.errored
+        ? copyParam("time.errorText", "Times could not be loaded.")
+        : copyParam("time.emptyText", "No bookable times in the next two weeks.")),
+    isRegistering,
+    notRegistering: !isRegistering,
+    authTitle: isRegistering
+      ? copyParam("time.authTitleRegister", "Create account to book")
+      : copyParam("time.authTitle", "Sign in to book"),
+    authBody: s.isCourse
+      ? copyParam("time.courseAuthBody", "Sign in to book the full course. Booking is saved to your member account.")
+      : isRegistering
+        ? copyParam("time.authBodyRegister", "Create a member account, then book the selected time on this screen.")
+        : copyParam("time.authBody", "You can browse times as a visitor. Booking is saved to a member account."),
+  };
+  if (next.status === "ready") lastReady = next;
+  return next;
+}
+
+async function probeMember(s: S): Promise<S> {
+  const storedEmail = await signedInEmail();
+  if (storedEmail) {
+    return derive({
+      ...s,
+      isMember: true,
+      identityLine: storedEmail,
+      email: storedEmail,
+      message: "",
+    });
+  }
+  try {
+    const data = await withTimeout(getMyData(), 2500);
+    const email = data.email || data.contactEmail || s.email;
+    return derive({
+      ...s,
+      isMember: true,
+      identityLine: displayName(data) || email || copyParam("time.signedIn", "Signed in"),
+      email,
+      message: "",
+    });
+  } catch {
+    return derive({
+      ...s,
+      isMember: false,
+      identityLine: copyParam("time.identityGuest", "Sign in to book this time."),
+    });
+  }
+}
+
+function contactName(dataLine: string): { first: string; last: string } {
+  const parts = dataLine.trim().split(/\s+/).filter(Boolean);
+  if (!parts.length) return { first: "Himi", last: "Member" };
+  if (parts.length === 1) return { first: parts[0], last: "Member" };
+  return { first: parts[0], last: parts.slice(1).join(" ") };
+}
+
+async function signedInEmail(): Promise<string> {
+  try {
+    const identity = await withTimeout(dispatch("himi.wix.memberIdentity") as Promise<unknown>, 1500);
+    const direct = identity as { email?: unknown } | null;
+    const wrapped = identity as { payload?: { email?: unknown } } | null;
+    const email = direct?.email ?? wrapped?.payload?.email;
+    return typeof email === "string" ? email : "";
+  } catch {
+    return "";
+  }
+}
+
+// A guest's picked time, kept for the sign-in it needs. Hosts key workers by account, so
+// signing in can start a new worker for this screen, with no selection. `himalaya.storage`
+// is shared by every worker of the app on every host, so a member's load of the same
+// service with nothing selected takes the pick back. Reading never clears it: a new worker's
+// boot load and appear load can run at once, and both must restore the same time. It goes
+// when the member picks a time or books, or after 30 minutes.
+const PENDING_PICK_KEY = "himi.booking.pendingPick.v1";
+const PENDING_PICK_TTL_MS = 30 * 60 * 1000;
+type StorageLike = { getItem(key: string): string | null; setItem(key: string, value: string): void };
+
+function appStorage(): StorageLike | undefined {
+  return (globalThis as { himalaya?: { storage?: StorageLike } }).himalaya?.storage;
+}
+
+function writePick(value: string): void {
+  try {
+    appStorage()?.setItem(PENDING_PICK_KEY, value);
+  } catch {
+    // No storage on this host: the pick lives only as long as this worker.
+  }
+}
+
+function rememberPick(serviceId: string, slotId: string): void {
+  writePick(JSON.stringify({ serviceId, slotId, at: Date.now() }));
+}
+
+function clearPick(): void {
+  writePick("");
+}
+
+/** The slot a guest picked for `serviceId` in the last 30 minutes, or "". */
+function readPick(serviceId: string): string {
+  let pick: { serviceId?: unknown; slotId?: unknown; at?: unknown } | null = null;
+  try {
+    pick = JSON.parse(appStorage()?.getItem(PENDING_PICK_KEY) || "null");
+  } catch {
+    // No storage, or a damaged entry: there is no pick to restore.
+  }
+  const fresh = typeof pick?.at === "number" && Date.now() - pick.at < PENDING_PICK_TTL_MS;
+  return fresh && pick?.serviceId === serviceId && typeof pick?.slotId === "string" ? pick.slotId : "";
+}
+
+// Wix Bookings appDefId — the catalogReference.appId that wraps a booking as an
+// ecom checkout line item, and the payment appId the native cashier settles under.
+const WIX_BOOKINGS_APP_ID = "13d21c63-b5ec-5912-8397-c3a5ddb27a97";
+
+// The site's metaSiteId, for the cashier payment config. Best-effort: the native
+// cashier can also resolve it from the app's signed Wix session, so an empty string
+// (no wix-platform arm / not yet minted) is tolerated rather than blocking the pay.
+async function resolveMsid(): Promise<string> {
+  try {
+    const st = await wixPlatformSession.signedInstanceStatus();
+    return st.msid ?? "";
+  } catch {
+    return "";
+  }
+}
+
+/** Read `day`'s unbookable times once (cached). A failure shows the bookable times only. */
+async function loadGreyDay(serviceId: string, day: string): Promise<void> {
+  if (!day || greyByDay.has(day)) return;
+  const from = new Date(`${day}T00:00:00`);
+  const until = new Date(from.getFullYear(), from.getMonth(), from.getDate() + 1);
+  if (Number.isNaN(from.getTime())) return;
+  try {
+    const res = await queryServiceAvailability(serviceId, isoDate(from), isoDate(until), { bookable: false });
+    greyByDay.set(day, greyRows(res.availabilityEntries ?? [], day, allRows, Date.now()));
+  } catch {
+    greyByDay.set(day, []);
+  }
+}
+
+/** The first two-week window from `from` with a time to book (at `locationId`, "" for any), up to
+ *  90 days after `now`: at most seven reads. `undefined` when there is none. */
+async function nextWindowWithTimes(serviceId: string, from: Date, now: Date, includeFull: boolean, service: WixService | undefined, locationId: string): Promise<{ built: ReturnType<typeof slotRows>; windowStart: string } | undefined> {
+  const horizon = now.getTime() + HORIZON_DAYS * DAY_MS;
+  for (let start = new Date(from.getFullYear(), from.getMonth(), from.getDate()); start.getTime() < horizon;
+    start = new Date(start.getFullYear(), start.getMonth(), start.getDate() + WINDOW_DAYS)) {
+    // Calendar days, as the step above: across a DST change 14 × 24 h would end the window an hour
+    // short of where the next one starts.
+    const until = new Date(Math.min(new Date(start.getFullYear(), start.getMonth(), start.getDate() + WINDOW_DAYS).getTime(), horizon));
+    const res = await queryServiceAvailability(serviceId, isoDate(new Date(Math.max(start.getTime(), now.getTime()))), isoDate(until), { bookable: !includeFull });
+    const built = slotRows(res.availabilityEntries ?? [], service);
+    if (built.rows.some((row) => row.selectable && locationMatches(row, locationId))) return { built, windowStart: dayKey(start) };
+  }
+  return undefined;
+}
+
+/** After a booking went through (or its checkout opened, which already holds a booking), the time
+ *  is no longer bookable here: it shows greyed and is no longer selected, so another tap on it cannot
+ *  send a second booking or charge. */
+function afterBooking(result: S, slotId: string): S {
+  const booked = !!result.successMessage || result.message === copyParam("time.checkoutOpened", "Complete your payment in the checkout to confirm this booking.");
+  if (!booked || !slotId || result.isCourse) return result;
+  allRows = allRows.map((row) => row.id === slotId ? { ...row, selectable: false, notSelectable: true } : row);
+  slotsById.delete(slotId);
+  waitlistIds.delete(slotId);
+  return derive({ ...result, selectedSlotId: "", selectedLine: "" });
+}
+
+/** The selection, kept only while its time is still in the window and at the chosen location: a
+ *  hidden pick would leave the in-app purchase button buying a time the screen no longer shows. */
+function visibleSelection(s: S): S {
+  const row = allRows.find((r) => r.id === s.selectedSlotId);
+  return row && row.selectable && locationMatches(row, s.locationId) ? s : { ...s, selectedSlotId: "", selectedLine: "" };
+}
+
+/** Counts day changes, so a slow read for an older day choice cannot move the screen back to it. */
+let dayRevision = 0;
+/** True while "Check Next Availability" searches; a second tap waits for the first. */
+let checkingNextLock = false;
+
+/** `{ slotId, signInScreenId, signInPresentation }` from a pill tap (or a bare slot id). */
+function tapped(arg: unknown): { slotId: string; signInScreenId: string; signInPresentation: "" | "sheet" | "full_screen" } {
+  if (typeof arg === "string") return { slotId: arg, signInScreenId: "", signInPresentation: "" };
+  const a = (arg ?? {}) as { slotId?: unknown; id?: unknown; signInScreenId?: unknown; signInPresentation?: unknown };
+  const slotId = typeof a.slotId === "string" ? a.slotId : typeof a.id === "string" ? a.id : "";
+  const presentation = a.signInPresentation === "sheet" || a.signInPresentation === "full_screen" ? a.signInPresentation : "";
+  return { slotId, signInScreenId: typeof a.signInScreenId === "string" ? a.signInScreenId : "", signInPresentation: presentation };
+}
+
+/** Select a bookable time, as a tap does: the pick-storage rules and the selection revision. */
+function selectSlotIn(s: S, slotId: string): S {
+  const selected = allRows.find((slot) => slot.id === slotId && slot.selectable);
+  if (selected) {
+    selectionRevision++;
+    pendingStart = "";
+    pendingSession = "";
+    if (s.isMember) clearPick();
+    else rememberPick(s.id, slotId);
+  }
+  return derive({
+    ...s,
+    selectedSlotId: selected ? slotId : s.selectedSlotId,
+    selectedLine: selected ? [selected.day, selected.title, selected.subtitle].filter(Boolean).join(" · ") : s.selectedLine,
+    message: "",
+    successMessage: "",
+    slots: s.slots.map((slot) => ({ ...slot, selected: slot.id === slotId, notSelected: slot.id !== slotId })),
+  });
+}
+
+const id = inputId();
+// A member's tap on a time books it, so pickSlot needs a connection too; a guest's tap only opens
+// the sign-in screen (or the sign-in card), which works offline.
+const defineService = withOnlineWrites(registerService, ["bookSelected", "buyApple", "signIn", "register", "pickSlot"], {
+  derive,
+  secretFields: ["password"],
+  requiresConnectivity: (action, state, arg) => action !== "pickSlot" || (state.isMember
+    && (regularCheckoutAllowed || applePurchase.usesRegularPlatform() || waitlistIds.has(tapped(arg).slotId))),
+});
+const svc = defineService<S, {
+  load: (s: S, arg?: unknown) => Promise<S>;
+  refreshMember: (s: S, arg?: unknown) => Promise<S>;
+  selectDay: (s: S, arg?: unknown) => Promise<S>;
+  selectSlot: (s: S, arg?: unknown) => S;
+  pickSlot: (s: S, arg?: unknown) => Promise<S | undefined>;
+  openLocations: (s: S) => S;
+  closeLocations: (s: S) => S;
+  selectLocation: (s: S, arg?: unknown) => Promise<S>;
+  checkNext: (s: S) => Promise<S>;
+  closeResult: (s: S) => S;
+  setEmail: (s: S, arg?: unknown) => S;
+  setPassword: (s: S, arg?: unknown) => S;
+  setFirstName: (s: S, arg?: unknown) => S;
+  setLastName: (s: S, arg?: unknown) => S;
+  showRegister: (s: S) => S;
+  showSignIn: (s: S) => S;
+  signIn: (s: S) => Promise<S>;
+  register: (s: S) => Promise<S>;
+  bookSelected: (s: S) => Promise<S>;
+  buyApple: (s: S) => Promise<S>;
+  setIapField: (s: S, arg?: unknown) => S;
+  iapPublish: (s: S) => S;
+  iapRefresh: (s: S) => Promise<S>;
+  iapPoll: (s: S) => Promise<S>;
+}>("himiBookingTime", {
+  notHydrated: [...ATTENDANCE_NOT_HYDRATED, "email", "password", "firstName", "lastName", "isMember", "canBook", "cannotBook"],
+  state: derive({
+    ...ATTENDANCE_INITIAL,
+    status: "loading",
+    id,
+    serviceName: "Choose a time",
+    serviceLine: "Next 14 days",
+    serviceImage: "",
+    hasServiceImage: false,
+    noServiceImage: true,
+    servicePrice: "",
+    serviceDuration: "",
+    serviceIsPaid: false,
+    coursePaymentOption: "",
+    courseAvailable: false,
+    isCourse: false,
+    notCourse: true,
+    scheduleId: "",
+    courseStart: "",
+    courseEnd: "",
+    days: [],
+    selectedDay: "",
+    selectedDayLabel: "",
+    slots: [],
+    dayEmptyText: "",
+    hasDaySlots: false,
+    noDaySlots: true,
+    noWindowSlots: true,
+    selectedSlotId: "",
+    selectedLine: "",
+    emptyText: "",
+    message: "",
+    successMessage: "",
+    hasSuccess: false,
+    noSuccess: true,
+    errored: false,
+    notErrored: true,
+    isLoading: true,
+    notLoading: false,
+    hasSlots: false,
+    noEmpty: true,
+    hasSelected: false,
+    noSelected: true,
+    hideSignIn: true,
+    hideTimeSignIn: true,
+    hideCourseSignIn: true,
+    hideWaitlistSignIn: true,
+    canBook: false,
+    cannotBook: true,
+    hideTimeBook: true,
+    hideCourseBook: true,
+    hideWaitlistBook: true,
+    hideDayPicker: true,
+    hideDaySlots: true,
+    hideDayEmpty: true,
+    showChoosePrompt: false,
+    hideChoosePrompt: true,
+    isMember: false,
+    notMember: true,
+    identityLine: "Sign in to book this time.",
+    authTitle: "Sign in to book",
+    authBody: "You can browse times as a visitor. Booking is saved to a member account.",
+    email: "",
+    password: "",
+    firstName: "",
+    lastName: "",
+    isRegistering: false,
+    notRegistering: true,
+    bookingInFlight: false,
+    notBooking: true,
+    bookingsScreenId: "himi_bookings",
+    windowStart: "",
+    locationId: "",
+    locationLabel: "All locations",
+    locationA11y: "",
+    locationOptions: [],
+    locationSheetOpen: false,
+    hasLocationMenu: false,
+    noLocationMenu: true,
+    singleLocation: "",
+    hasSingleLocation: false,
+    noSingleLocation: true,
+    groups: [],
+    dayEmpty: false,
+    hasDayTimes: true,
+    noUpcoming: false,
+    hasUpcoming: true,
+    resultText: "",
+    resultSticky: false,
+    resultAuto: false,
+    resultIsBooking: false,
+    resultNotBooking: true,
+    courseMessage: "",
+  }),
+  actions: {
+    iapPublish: (s) => derive(lastReady ?? s),
+    iapRefresh: async (): Promise<S> => { await applePurchase.refresh(); return derive(svc.getState()); },
+    iapPoll: async (): Promise<S> => { await applePurchase.poll(); return derive(svc.getState()); },
+    setIapField: (s, arg) => { applePurchase.change(arg); return derive(s); },
+    buyApple: async (s: S): Promise<S> => {
+      const slot = slotsById.get(s.selectedSlotId);
+      if (!slot || !s.isMember) return derive(s);
+      await applePurchase.buy({ key: s.selectedSlotId, slot: slot as unknown as Record<string, unknown> });
+      return derive(svc.getState());
+    },
+    load: async (s, arg): Promise<S> => {
+      const revisionAtStart = selectionRevision;
+      stashCopy(arg);
+      if (!s.id) return derive({ ...s, status: "ready", errored: true });
+      let next = derive({ ...s, status: "loading", errored: false, message: "", successMessage: "" });
+      next = await probeMember(next);
+      try {
+        const now = new Date();
+        const beyond = availabilityBeyond(now, farStart);
+        // Staff photos need STAFF_MEMBER_DETAILS; a token that may not read them still gets the service.
+        const serviceRes = await getService(s.id, { conditionalFields: ["STAFF_MEMBER_DETAILS"] })
+          .catch(() => getService(s.id))
+          .catch(() => ({ service: undefined }));
+        lastService = serviceRes.service;
+        readStaffPhotos(serviceRes.service);
+        if (courseInput && !serviceRes.service) {
+          slotsById = new Map();
+          allRows = [];
+          return derive({ ...next, status: "ready", errored: true, days: [], selectedDay: "", selectedDayLabel: "", slots: [] });
+        }
+        if (serviceRes.service?.type === "COURSE") {
+          slotsById = new Map();
+          waitlistIds = new Set();
+          allRows = [];
+          const header = serviceHeaderFields(serviceRes.service);
+          const schedule = serviceRes.service.schedule;
+          const scheduleId = schedule?.id ?? "";
+          // A reload after a cancelled payment: this customer's order may hold the last place.
+          const held = pendingCourseBooking?.ordered === true && pendingCourseBooking.scheduleId === scheduleId
+            && pendingCourseBooking.email === ((await signedInEmail()) || next.email);
+          const courseAvailable = await courseOpenTo(serviceRes.service, now, held);
+          // A course has no in-app purchase path: where a paid booking may not use the regular
+          // checkout (mayUseRegularBookingCheckout), it cannot be bought here.
+          regularServicePrice = header.price;
+          regularCheckoutAllowed = await mayUseRegularBookingCheckout(serviceRes.service);
+          return derive({
+            ...next,
+            status: "ready",
+            errored: false,
+            isCourse: true,
+            courseAvailable,
+            scheduleId,
+            courseStart: schedule?.firstSessionStart ?? "",
+            courseEnd: schedule?.lastSessionEnd ?? "",
+            days: [],
+            selectedDay: "",
+            slots: [],
+            selectedSlotId: "",
+            serviceName: serviceRes.service.name || copyParam("time.courseNameFallback", "Course"),
+            serviceLine: [header.duration, regularCheckoutAllowed ? header.price : ""].filter(Boolean).join(" · "),
+            serviceImage: header.image,
+            hasServiceImage: !!header.image,
+            noServiceImage: !header.image,
+            servicePrice: regularCheckoutAllowed ? header.price : "",
+            serviceDuration: header.duration,
+            serviceIsPaid: header.paid,
+            coursePaymentOption: serviceRes.service.payment?.options?.online ? "ONLINE"
+              : serviceRes.service.payment?.options?.inPerson ? "OFFLINE" : "",
+            selectedLine: schedule?.firstSessionStart && schedule?.lastSessionEnd
+              ? `${dayLabel(schedule.firstSessionStart)} – ${dayLabel(schedule.lastSessionEnd)}` : "",
+            message: !courseAvailable ? copyParam("time.courseUnavailable", "Course booking is unavailable right now.")
+              : regularCheckoutAllowed ? "" : copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable."),
+          });
+        }
+        const includeFull = serviceRes.service?.type === "CLASS";
+        const [first, target] = await Promise.all([
+          queryServiceAvailability(s.id, isoDate(now), isoDate(new Date(now.getTime() + WINDOW_DAYS * DAY_MS)), { bookable: !includeFull }),
+          // A host's start past the window (an Agenda session weeks out): its day alone, so it can
+          // be preselected. Its failure costs only that preselection.
+          beyond ? queryServiceAvailability(s.id, isoDate(beyond.from), isoDate(beyond.until), { bookable: !includeFull }).catch(() => ({ availabilityEntries: [] })) : undefined,
+        ]);
+        let built = slotRows([...(first.availabilityEntries ?? []), ...(target?.availabilityEntries ?? [])], serviceRes.service);
+        let windowStart = dayKey(now);
+        // Nothing to book in the first two weeks (a class's full sessions do not count), and nothing
+        // at a host's deep-linked start either: look further, two weeks at a time, up to 90 days. The
+        // strip then starts at the first two weeks with a time. Nothing in 90 days → "no upcoming
+        // sessions".
+        if (!built.rows.some((row) => row.selectable)) {
+          const later = await nextWindowWithTimes(s.id, new Date(now.getTime() + WINDOW_DAYS * DAY_MS), now, includeFull, serviceRes.service, "");
+          if (later) { built = later.built; windowStart = later.windowStart; }
+        }
+        slotsById = built.slots;
+        waitlistIds = built.waitlist;
+        const rows = built.rows;
+        allRows = rows;
+        greyByDay = new Map();
+        const days = daysOf(rows, new Date(`${windowStart}T12:00:00`));
+        const header = serviceHeaderFields(serviceRes.service);
+        regularServicePrice = header.price;
+        regularCheckoutAllowed = await mayUseRegularBookingCheckout(serviceRes.service);
+        await applePurchase.booking(s.id, serviceRes.service);
+        // A reload runs in the background when the screen shows again. A time the customer
+        // picked while it ran wins over the selection this load started from.
+        const chosen: S = selectionRevision !== revisionAtStart ? (svc.getState?.() ?? next) : next;
+        // A host's `start` (deep entry): that slot preselected, or — taken since — its day.
+        const wantedStart = pendingStart;
+        // The named session (a slot row's id IS its session id), else the slot at that instant. A
+        // named session that is gone is "taken since" — never another session at the same time.
+        const startRow = !wantedStart ? undefined
+          : pendingSession ? rows.find((r) => r.id === pendingSession && r.selectable)
+          : rows.find((r) => r.id === slotIdAt(slotsById, wantedStart) && r.selectable);
+        // The requested day even with no time left on it: "taken since" opens there, nothing selected.
+        const startDay = wantedStart ? days.find((d) => d.id === dayKey(wantedStart)) : undefined;
+        const selectionAlive = !!startRow || slotsById.has(chosen.selectedSlotId) || waitlistIds.has(chosen.selectedSlotId);
+        // A member with no live selection, and no host start, gets back the time they picked as a guest.
+        const picked = selectionAlive || wantedStart || !next.isMember ? undefined : rows.find((row) => row.id === readPick(s.id) && row.selectable);
+        // Keep the customer's day across a reload when it still has times;
+        // otherwise open on the first day that has any.
+        const keep = days.find((d) => d.id === chosen.selectedDay && d.hasSlots);
+        const initialDay = startRow?.dayKey ?? startDay?.id ?? picked?.dayKey ?? keep?.id ?? days.find((d) => d.hasSlots)?.id ?? days[0]?.id ?? "";
+        if (!includeFull && initialDay) await loadGreyDay(s.id, initialDay);
+        // A location with no times left in the window goes back to "All locations".
+        // A location with no times left (greyed ones included) goes back to "All locations", and so
+        // does a filter that would hide the time this load restores (a host's start, a guest's pick).
+        const restored = startRow ?? picked;
+        // The location chosen on any bookings screen (this one writes its choices there too), matched
+        // by the key they all share; this screen's own choice only when the store cannot answer. A
+        // pooled worker re-shown later otherwise kept an older choice than Services' newer one.
+        // A place the other screens cannot name (the client's own place) is never written there, so
+        // this screen keeps it rather than lose it to the shared value.
+        const shared = await readSharedLocationResult();
+        const own = windowLocations().find((l) => l.key === chosen.locationId);
+        const preferred = own && !own.place ? own.key
+          : shared ? (shared.id ? windowLocations().find((l) => l.place === shared.id)?.key ?? "" : "") : chosen.locationId;
+        const locationId = windowLocations().some((l) => l.key === preferred) && (!restored || locationMatches(restored, preferred))
+          ? preferred : "";
+        return derive(withDay({
+          ...next,
+          days,
+          windowStart,
+          locationId,
+          selectedSlotId: startRow ? startRow.id : selectionAlive ? chosen.selectedSlotId : picked?.id ?? "",
+          selectedLine: startRow ? [startRow.day, startRow.title, startRow.subtitle].filter(Boolean).join(" · ")
+            : selectionAlive ? chosen.selectedLine
+              : picked ? [picked.day, picked.title, picked.subtitle].filter(Boolean).join(" · ") : "",
+          status: "ready",
+          errored: false,
+          serviceName: serviceRes.service?.name || copyParam("time.serviceNameFallback", "Choose a time"),
+          serviceLine: [header.duration, regularCheckoutAllowed ? header.price : ""].filter(Boolean).join(" · "),
+          serviceImage: header.image,
+          hasServiceImage: !!header.image,
+          noServiceImage: !header.image,
+          servicePrice: regularCheckoutAllowed ? header.price : "",
+          serviceDuration: header.duration,
+          serviceIsPaid: header.paid,
+          // A guest's pick restored after sign-in stays picked: the member taps it to book. The
+          // screen never books from a load (two loads can run at once right after a sign-in).
+          // Where nothing can be bought here, a tap says so (pickSlot), not the screen's opening.
+          message: picked ? copyParam("time.signedInTapAgain", "Signed in. Tap the time again to book it.") : "",
+        }, initialDay));
+      } catch {
+        slotsById = new Map();
+        waitlistIds = new Set();
+        allRows = [];
+        return derive({ ...next, status: "ready", errored: true, days: [], selectedDay: "", selectedDayLabel: "", slots: [] });
+      }
+    },
+    // #3276 — show one day's times. Re-tapping the active chip emits an empty
+    // selection; the strip is single-select with no "none", so the day stays.
+    // A time picked on another day stays selected (the selected line and the
+    // Book button keep naming it): switching days to compare is not a reset.
+    selectDay: async (s, arg): Promise<S> => {
+      const day = chosenDay(arg);
+      if (!day || !s.days.some((d) => d.id === day)) return derive(s);
+      pendingStart = "";
+      pendingSession = "";
+      const revision = ++dayRevision;
+      if (lastService?.type !== "CLASS") await loadGreyDay(s.id, day);
+      const current = svc.getState?.() ?? s;
+      return derive(revision === dayRevision ? withDay(current, day) : current);
+    },
+    refreshMember: (s, arg) => { stashCopy(arg); return probeMember(s); },
+    selectSlot: (s, arg) => selectSlotIn(s, tapped(arg).slotId),
+    // One tap books: the tap does what "Book selected time" did (select, then book). A guest keeps
+    // the pick and signs in first; after the sign-in the time comes back picked, and the member
+    // taps it again. Where the regular checkout is not allowed, the tap selects the time for the
+    // in-app purchase button.
+    pickSlot: async (s, arg): Promise<S | undefined> => {
+      const { slotId, signInScreenId, signInPresentation } = tapped(arg);
+      if (bookingLock || s.bookingInFlight || !allRows.some((row) => row.id === slotId && row.selectable)) return derive(s);
+      const selected = selectSlotIn(s, slotId);
+      // A modal sign-in leaves this screen in place: a host need not run its onAppear when the
+      // sheet closes, and the reload that refreshes `isMember` can still be running. So ask the
+      // session before opening the sheet again, or a member's tap would only reopen it. Only the
+      // session's own identity counts here, never getMyData: that can still answer with a stale
+      // site or owner profile for a visitor. A member found here gets the pick and the "tap again"
+      // note, as after a reload, and books on the next tap: that tap passes the booking lock and
+      // the offline guard with the member state, which this await would let a second tap skip.
+      if (!selected.isMember && signInScreenId && signInPresentation) {
+        const mine = ++sessionTaps;
+        const email = await signedInEmail();
+        if (mine !== sessionTaps) return undefined;
+        // From the state as it is NOW: a reload may have landed during the await. The pick
+        // stays only while that time is still bookable.
+        const now = svc.getState?.() ?? s;
+        const open = allRows.some((row) => row.id === slotId && row.selectable);
+        if (email) {
+          return derive({ ...(open ? selectSlotIn(now, slotId) : now), isMember: true, identityLine: email, email,
+            message: open ? copyParam("time.signedInTapAgain", "Signed in. Tap the time again to book it.") : "" });
+        }
+        // Still a guest: the sign-in opens over the newest state; a time gone meanwhile opens nothing.
+        if (!open) return derive(now);
+        return navigate(selectSlotIn(now, slotId), { screenId: signInScreenId, presentation: signInPresentation, args: { mode: "signin", intent: "book", modal: "1" } });
+      }
+      if (!selected.isMember) {
+        // Branded Lite opens its sign-in screen; other apps show the sign-in card on this screen.
+        // With a presentation it opens as a modal (`modal`: the sign-in worker closes it after a
+        // sign-in), and this screen loads again under it with the guest's pick kept.
+        if (!signInScreenId) return selected;
+        return navigate(selected, signInPresentation
+          ? { screenId: signInScreenId, presentation: signInPresentation, args: { mode: "signin", intent: "book", modal: "1" } }
+          : { screenId: signInScreenId, args: { mode: "signin", intent: "book" } });
+      }
+      const regular = regularCheckoutAllowed || applePurchase.usesRegularPlatform();
+      if (!regular && !waitlistIds.has(slotId)) {
+        // The in-app purchase button takes over for the picked time; with none, say why not.
+        return applePurchase.fields(true, false).iapBuyHidden
+          ? derive({ ...selected, message: copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") })
+          : selected;
+      }
+      bookingLock = true;
+      try {
+        return afterBooking(await bookSelectedIn(selected), slotId);
+      } finally {
+        bookingLock = false;
+      }
+    },
+    openLocations: (s) => derive({ ...s, locationSheetOpen: true }),
+    closeLocations: (s) => derive({ ...s, locationSheetOpen: false }),
+    selectLocation: async (s, arg): Promise<S> => {
+      const raw = (arg ?? {}) as { locationId?: unknown; id?: unknown };
+      const wanted = typeof arg === "string" ? arg : typeof raw.locationId === "string" ? raw.locationId : typeof raw.id === "string" ? raw.id : "";
+      const locationId = windowLocations().some((l) => l.key === wanted) ? wanted : "";
+      const next = visibleSelection({ ...s, locationId, locationSheetOpen: false });
+      // Stay on the day when it has a time at this location; else go to the first day that has one.
+      const keep = allRows.some((row) => row.dayKey === s.selectedDay && row.selectable && locationMatches(row, locationId));
+      const first = allRows.filter((row) => row.selectable && locationMatches(row, locationId)).sort(byDay)[0];
+      const revision = ++dayRevision;
+      // Kept for Services and the Agenda, which filter by the same location. Not awaited (it never
+      // throws): the choice shows at once, and a search still running settles as it always has.
+      // A place with no shared key (the client's place) is this screen's alone: Services and the
+      // Agenda keep their own choice instead of falling back to "All locations".
+      const picked = windowLocations().find((l) => l.key === locationId);
+      if (!locationId || picked?.place) void writeSharedLocation({ id: picked?.place ?? "", label: picked?.label ?? "" });
+      if (keep || !first) return derive(next);
+      if (lastService?.type !== "CLASS") await loadGreyDay(s.id, first.dayKey);
+      // A newer day or location choice made during the read wins.
+      if (revision !== dayRevision) return derive(svc.getState?.() ?? next);
+      const current = svc.getState?.() ?? next;
+      return derive(withDay(visibleSelection({ ...current, locationId, locationSheetOpen: false }), first.dayKey));
+    },
+    // The next day after the selected one with a time (at the chosen location): in the loaded
+    // window first, then forward up to 90 days, moving the strip.
+    checkNext: async (s): Promise<S> => {
+      if (checkingNextLock) return derive(s);
+      checkingNextLock = true;
+      try {
+        return await checkNextIn(s);
+      } finally {
+        checkingNextLock = false;
+      }
+    },
+    closeResult: (s) => derive({ ...s, message: "", successMessage: "" }),
+    setEmail: (s, arg) => derive({ ...s, email: strOf(arg), message: "" }),
+    setPassword: (s, arg) => derive({ ...s, password: strOf(arg), message: "" }),
+    setFirstName: (s, arg) => derive({ ...s, firstName: strOf(arg), message: "" }),
+    setLastName: (s, arg) => derive({ ...s, lastName: strOf(arg), message: "" }),
+    showRegister: (s) => derive({ ...s, isRegistering: true, message: "" }),
+    showSignIn: (s) => derive({ ...s, isRegistering: false, message: "" }),
+    signIn: async (s) => {
+      if (!s.email || !s.password) return derive({ ...s, message: copyParam("time.validationEmailPassword", "Enter your email and password.") });
+      try {
+        await dispatch("himi.wix.signInDirect", { email: s.email, password: s.password });
+        return derive({
+          ...s,
+          isMember: true,
+          identityLine: s.email,
+          password: "",
+          firstName: "",
+          lastName: "",
+          isRegistering: false,
+          message: s.isCourse
+            ? copyParam("time.courseSignedInReady", "Signed in. You can book this course now.")
+            : copyParam("time.signedInTapAgain", "Signed in. Tap the time again to book it."),
+        });
+      } catch {
+        return derive({ ...s, password: "", message: copyParam("time.signInFailed", "Sign in failed. Try again.") });
+      }
+    },
+    register: async (s) => {
+      if (!s.email || !s.password) return derive({ ...s, message: copyParam("time.validationEmailPassword", "Enter your email and password.") });
+      try {
+        await dispatch("himi.wix.registerDirect", {
+          email: s.email,
+          password: s.password,
+          firstName: s.firstName,
+          lastName: s.lastName,
+        });
+        return derive({
+          ...s,
+          isMember: true,
+          identityLine: s.email,
+          password: "",
+          firstName: "",
+          lastName: "",
+          isRegistering: false,
+          message: s.isCourse
+            ? copyParam("time.courseRegisterReady", "Account created. You can book this course now.")
+            : copyParam("time.signedInTapAgain", "Signed in. Tap the time again to book it."),
+        });
+      } catch {
+        return derive({ ...s, password: "", message: copyParam("time.registerFailed", "Account creation failed. Try another email.") });
+      }
+    },
+    // Kept for the course button and the offline replay (WriteQueue replays this action).
+    bookSelected: async (s) => {
+      if (bookingLock) return derive(s);
+      bookingLock = true;
+      try {
+        return afterBooking(await bookSelectedIn(s), s.selectedSlotId);
+      } finally {
+        bookingLock = false;
+      }
+    },
+  },
+});
+
+/** "Check Next Availability": the next day after the selected one with a time (at the chosen
+ *  location), in the loaded window first, then forward up to 90 days, moving the strip. */
+async function checkNextIn(s: S): Promise<S> {
+  const next = allRows.filter((row) => row.selectable && row.dayKey > s.selectedDay && locationMatches(row, s.locationId))
+    .sort(byDay)[0];
+  if (next) {
+    const revision = ++dayRevision;
+    if (lastService?.type !== "CLASS") await loadGreyDay(s.id, next.dayKey);
+    const current = svc.getState?.() ?? s;
+    return derive(revision === dayRevision ? withDay(current, next.dayKey) : current);
+  }
+  const revision = ++dayRevision;
+  const after = new Date(`${s.selectedDay || s.windowStart}T12:00:00`);
+  const from = new Date(after.getFullYear(), after.getMonth(), after.getDate() + 1);
+  const includeFull = lastService?.type === "CLASS";
+  let later: Awaited<ReturnType<typeof nextWindowWithTimes>>;
+  try {
+    later = Number.isNaN(from.getTime()) ? undefined : await nextWindowWithTimes(s.id, from, new Date(), includeFull, lastService, s.locationId);
+  } catch {
+    return derive({ ...(svc.getState?.() ?? s), message: copyParam("time.errorText", "Times could not be loaded.") });
+  }
+  const current = svc.getState?.() ?? s;
+  // A day or location chosen while the search ran wins: its result is dropped.
+  if (revision !== dayRevision) return derive(current);
+  if (!later) return derive({ ...current, message: copyParam("time.noLaterTimes", "There are no later times in the next 90 days.") });
+  allRows = later.built.rows;
+  slotsById = later.built.slots;
+  waitlistIds = later.built.waitlist;
+  greyByDay = new Map();
+  const day = later.built.rows.filter((row) => row.selectable && locationMatches(row, s.locationId))
+    .sort(byDay)[0]!.dayKey;
+  if (!includeFull) await loadGreyDay(s.id, day);
+  return derive(withDay(visibleSelection({ ...current, windowStart: later.windowStart }), day));
+}
+
+/** The booking itself: a waitlist, a paid or course checkout, or a free booking. */
+async function bookSelectedIn(s: S): Promise<S> {
+  if (!s.isMember) return derive({ ...s, message: copyParam("time.bookNeedsSignIn", "Sign in before booking.") });
+  if (s.isCourse && !s.scheduleId) return derive({ ...s, message: copyParam("time.courseUnavailable", "Course booking is unavailable right now.") });
+  if (!s.isCourse && !s.selectedSlotId) return derive({ ...s, message: copyParam("time.bookNeedsSlot", "Choose one time first.") });
+  const joiningWaitlist = !s.isCourse && waitlistIds.has(s.selectedSlotId);
+  const slot = s.isCourse ? undefined : slotsById.get(s.selectedSlotId);
+  if (!s.isCourse && !slot && !joiningWaitlist) return derive({ ...s, message: copyParam("time.bookSlotGone", "That time is no longer available. Try again.") });
+  // A booking is paid through the regular checkout only where that is allowed; joining a
+  // waitlist buys nothing, so it skips this check.
+  if (!joiningWaitlist) {
+    try {
+      const current = await getService(s.id);
+      // A course is booked whole, never one of its sessions as a time: a screen opened with no
+      // `course` input whose first service read failed lists the sessions as times.
+      if (!s.isCourse && current.service?.type === "COURSE") return derive({ ...s, message: copyParam("time.courseUnavailable", "Course booking is unavailable right now.") });
+      regularCheckoutAllowed = await mayUseRegularBookingCheckout(current.service);
+      if (serviceHeaderFields(current.service).paid !== s.serviceIsPaid) return derive({ ...s, message: copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+    } catch {
+      if (s.serviceIsPaid) return derive({ ...s, message: copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+    }
+    if (!regularCheckoutAllowed) return derive({ ...s, message: copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+  }
+  // A confirmed booking is reported to the app hosting this screen (an embed's `onAction`), so a
+  // host chat can say so and refresh what it shows. Dropped where nothing hosts the screen.
+  // The booking's own instants carry an offset; a slot's may be LOCAL to its timezone, which
+  // `emitHostEvent` leaves out rather than let the host read it in its own zone.
+  const reportBooked = (booking: { id?: string; startDate?: string; endDate?: string } | undefined) => emitHostEvent("booking.created", {
+    bookingId: booking?.id,
+    serviceId: s.id,
+    serviceName: s.serviceName,
+    start: hostEventInstant(booking?.startDate) || slot?.startDate || s.courseStart,
+    end: hostEventInstant(booking?.endDate) || slot?.endDate || s.courseEnd,
+  });
+  // The member acts on the pick now; a later visit must not restore it.
+  clearPick();
+  if (joiningWaitlist) {
+    const pending = derive({ ...s, bookingInFlight: true, message: "", successMessage: "" });
+    const my = await getMyData().catch(() => ({ email: s.email } as WixMyData));
+    const email = (await signedInEmail()) || my.email || my.contactEmail || s.email;
+    const name = contactName(displayName(my) || email);
+    try {
+      await registerToWaitlist(s.selectedSlotId, { email, firstName: name.first, lastName: name.last });
+      return derive({ ...pending, bookingInFlight: false,
+        successMessage: copyParam("time.waitlistJoined", "You're on the waitlist. Check My Bookings for updates."), message: "" });
+    } catch {
+      return derive({ ...s, bookingInFlight: false,
+        message: copyParam("time.waitlistFailed", "Couldn't join the waitlist. Try again.") });
+    }
+  }
+  // Paid service or any course — create a Wix eCommerce order so a free
+  // course does not remain in CREATED status with no reserved capacity.
+  // FULLY NATIVE in-app payment (mirrors Wix's RN apps): NO
+  // hosted-checkout WebView / browser redirect. The chain is
+  //   createBooking → ecom.createCheckout(booking line item) → ecom.createOrder
+  //   → @himalaya/wix-cashier.proceedToPayment(snapshotId)
+  // where `paymentGatewayOrderId` from createOrder is the cashier order id
+  // (snapshotId) settled on-device via Apple/Google Pay. We do NOT optimistically
+  // write a local booking row (My Bookings revalidates from Wix on success). Any
+  // failure degrades to an inline retry message, never a dead button.
+  if (s.serviceIsPaid || s.isCourse) {
+    const pending = derive({ ...s, bookingInFlight: true, message: "", successMessage: "" });
+    // Booker identity — same resolution as the free path (never throws).
+    const payerData = await getMyData().catch(() => ({ email: s.email } as WixMyData));
+    const payerEmail = (await signedInEmail()) || payerData.email || payerData.contactEmail || s.email;
+    const payerName = contactName(displayName(payerData) || payerEmail);
+    // Only the same customer's own unfinished booking for this course is reused.
+    const retried = s.isCourse && pendingCourseBooking?.scheduleId === s.scheduleId && pendingCourseBooking.email === payerEmail
+      ? pendingCourseBooking : undefined;
+    if (s.isCourse) {
+      try {
+        const latest = (await getService(s.id)).service;
+        const open = latest != null && await courseOpenTo(latest, new Date(), retried?.ordered === true);
+        if (!open) {
+          return derive({ ...pending, bookingInFlight: false, courseAvailable: false,
+            message: copyParam("time.courseUnavailable", "Course booking is unavailable right now.") });
+        }
+      } catch {
+        return derive({ ...pending, bookingInFlight: false,
+          message: copyParam("time.courseUnavailable", "Course booking is unavailable right now.") });
+      }
+    }
+    try {
+      // 1. Create the booking (CREATED status — payment pending).
+      //    A course retried after a failed checkout reuses the booking it already made.
+      const created = retried ? { booking: retried.booking }
+        : s.isCourse
+          ? await bookSchedule(s.scheduleId, payerName.first, payerName.last, payerEmail,
+            s.coursePaymentOption ? { selectedPaymentOption: s.coursePaymentOption } : undefined)
+          : await bookSlot(slot!, payerName.first, payerName.last, payerEmail);
+      const bookingId = created.booking?.id;
+      if (!bookingId) throw new Error("booking not created");
+      if (s.isCourse && !retried) pendingCourseBooking = { scheduleId: s.scheduleId, email: payerEmail, booking: created.booking! };
+      // 2. Wrap the booking as a checkout line item; create the checkout.
+      const checkoutRes = await createCheckout([
+        { quantity: 1, catalogReference: { appId: WIX_BOOKINGS_APP_ID, catalogItemId: bookingId } },
+      ]);
+      const checkoutId = checkoutRes.checkout?.id;
+      if (!checkoutId) throw new Error("checkout not created");
+      // 3. Create the Wix-managed order — mints the cashier snapshot when a
+      //    balance is due. No paymentGatewayOrderId ⇒ nothing to charge
+      //    (covered / zero total) ⇒ the booking is already confirmed.
+      // Hosted (Spaces): the site's own checkout page creates the order (as
+      // RN does) — creating it here first fails on a site with no payment method set up.
+      const hosted = isHostedWorker();
+      const orderRes = hosted ? { paymentGatewayOrderId: "" } : await createOrder(checkoutId);
+      if (s.isCourse && !hosted && pendingCourseBooking) pendingCourseBooking.ordered = true;
+      const snapshotId = orderRes.paymentGatewayOrderId ?? "";
+      if ((!snapshotId || (s.isCourse && s.coursePaymentOption === "OFFLINE")) && !hosted) {
+        pendingCourseBooking = null;
+        await reportBooked(created.booking);
+        return derive({ ...pending, bookingInFlight: false, successMessage: s.isCourse
+          ? copyParam("time.courseSubmitted", "Course booking submitted. Check My Bookings for confirmation.")
+          : copyParam("time.successMessage", "Booked. Your confirmation is ready in My Bookings."), message: "" });
+      }
+      // 4. Collect payment IN-APP — wallet when this app has one wired, otherwise
+      //    the in-app Wix cashier. Routed through the shared helper so a
+      //    wallet-less app can still actually pay: calling proceedToPayment
+      //    unconditionally created the booking + order and THEN failed, leaving an
+      //    unpaid booking behind (see @wix/himalaya/checkout).
+      const pay = await payCashierOrder({
+        appId: WIX_BOOKINGS_APP_ID,
+        snapshotId,
+        msid: await resolveMsid(),
+        // Hosted (Spaces): the host opens this booking's checkout as the lent member.
+        ...(hosted ? { openCashier: hostedCheckoutOpener(checkoutId) } : {}),
+        cashierUrl: async () => {
+          const redirect = await createRedirectSession(s.isCourse
+            ? { ecomCheckout: { checkoutId } }
+            : { bookingsCheckout: { slotAvailability: { slot: slot as WixSlot } } });
+          return redirect.redirectSession?.fullUrl;
+        },
+      });
+      if (pay.kind === "paid") {
+        pendingCourseBooking = null;
+        await reportBooked(created.booking);
+        return derive({ ...pending, bookingInFlight: false, successMessage: copyParam("time.successMessage", "Booked. Your confirmation is ready in My Bookings."), message: "" });
+      }
+      if (pay.kind === "handoff") {
+        // The cashier is open in-app; the booking confirms once payment lands, so
+        // promise nothing here — My Bookings revalidates from Wix.
+        return derive({ ...pending, bookingInFlight: false, message: copyParam("time.checkoutOpened", "Complete your payment in the checkout to confirm this booking.") });
+      }
+      if (pay.kind === "cancelled") {
+        return derive({ ...s, bookingInFlight: false, message: s.isCourse
+          ? copyParam("time.coursePaymentCancelled", "Payment cancelled — your course booking wasn't confirmed. Try again.")
+          : copyParam("time.paymentCancelled", "Payment cancelled — your booking wasn't confirmed. Pick a time to try again.") });
+      }
+      if (isPaymentSetupFailure(pay)) return derive({ ...s, bookingInFlight: false, message: paymentSetupMessage("time") });
+      return derive({ ...s, bookingInFlight: false, message: s.isCourse
+        ? copyParam("time.coursePaymentFailed", "Payment couldn't be completed. Try again.")
+        : copyParam("time.paymentFailed", "Payment couldn't be completed. Pick another time or try again.") });
+    } catch (error) {
+      if (isPaymentSetupFailure(error)) return derive({ ...s, bookingInFlight: false, message: paymentSetupMessage("time") });
+      return derive({ ...s, bookingInFlight: false, message: s.isCourse
+        ? copyParam("time.courseCheckoutFailed", "Checkout could not start. Try again.")
+        : copyParam("time.checkoutFailed", "Checkout could not start. Pick another time or try again.") });
+    }
+  }
+  // FREE appointment/class — the original member bookSlot rung (offline-safe below).
+  // getMyData/signedInEmail carry their own fallbacks (never throw), so the
+  // booker identity is resolved up front — needed for both the optimistic
+  // cache row and the offline replay params.
+  const my = await getMyData().catch(() => ({ email: s.email } as WixMyData));
+  const email = (await signedInEmail()) || my.email || my.contactEmail || s.email;
+  const name = contactName(displayName(my) || email);
+  // Optimistic local write — My Bookings repaints from cache immediately (offline or not).
+  const selectedSlot = allRows.find((r) => r.id === s.selectedSlotId);
+  const localId = `local-${Date.now()}`;
+  const localRow = (id: string): DbEntity => ({
+    id,
+    title: s.serviceName || "Booking",
+    subtitle: s.isCourse ? (s.selectedLine || "Full course") : (selectedSlot?.title || "Booked time"),
+    status: "Booked",
+  });
+  if (!offlineWritesEnabled) await cachePut(localRow(localId));
+  const pending = derive({ ...s, bookingInFlight: true, message: "", successMessage: "" });
+  try {
+    const created = await bookSlot(slot!, name.first, name.last, email);
+    // Reconcile the optimistic local id with the server-assigned booking id.
+    const realId = created.booking?.id;
+    if (offlineWritesEnabled) await cachePut(localRow(realId || localId));
+    else if (realId && realId !== localId) { await cacheDrop(localId); await cachePut(localRow(realId)); }
+    await reportBooked(created.booking);
+    return derive({
+      ...pending,
+      bookingInFlight: false,
+      successMessage: copyParam("time.successMessage", "Booked. Your confirmation is ready in My Bookings."),
+      message: "",
+    });
+  } catch (e) {
+    if (!offlineWritesEnabled && isBridgeUnavailable(e)) {
+      // Offline / no bridge: the optimistic cache row already shows in My
+      // Bookings; queue the booking to replay (WriteQueue, idempotent) when
+      // connectivity returns.
+      await queueWrite("tier5.himiBookingTime.bookSelected", {
+        serviceId: s.id,
+        ...(s.isCourse ? { scheduleId: s.scheduleId } : { slotId: s.selectedSlotId }),
+        email,
+        firstName: name.first,
+        lastName: name.last,
+        ...(slot ? { slot: JSON.stringify(slot) } : {}),
+      });
+      return derive({
+        ...pending,
+        bookingInFlight: false,
+        successMessage: "Booked offline — will sync when you reconnect.",
+        message: "",
+      });
+    }
+    return derive({ ...s, bookingInFlight: false, message: s.isCourse
+      ? copyParam("time.courseBookFailed", "Course booking failed. Try again.")
+      : copyParam("time.bookFailed", "Booking failed. Pick another time or try again.") });
+  }
+}
+resetUnhydratedKeysOnOlderRuntime(svc, { ...svc.getState(), ...ATTENDANCE_INITIAL, email: "", password: "", firstName: "", lastName: "", isMember: false, canBook: false, cannotBook: true }, [...ATTENDANCE_NOT_HYDRATED, "email", "password", "firstName", "lastName", "isMember", "canBook", "cannotBook"]);
+svc.load();
+export { svc };