@wix/himalaya-cli 0.1613.0 → 0.1615.0

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

@@ -0,0 +1,1170 @@
+// Tier-5 bundle: himi-booking — single service detail.
+//
+// Opened from an Agenda row (`sessionId` + `start` in the input), the screen is about THAT
+// session: its date and time show under the name and in the facts, and the footer offers what
+// the Agenda row offers, from the same session state (`_shared/booking-session.ts`): Book (Choose
+// Time opens with the session picked), Join Waitlist (joined from here), a disabled Book with the
+// reason, or the member's own place (Booked / On waitlist). A course keeps its course footer.
+// Opened without a session (the Services list), the footer is "Choose a Time", as before.
+import { defineService, navigate } from "@himalaya/state";
+import { share as shareSheet } from "@himalaya/share";
+import { open, defaultMode } from "@himalaya/open-url";
+import { addDays, dayKey, dayLabel, timeLabel } from "@himalaya/time";
+import { getService, queryServiceAvailability, registerToWaitlist, type WixAvailabilityEntry, type WixService, type WixServiceAddress, type WixServiceBookingPolicy } from "@himalaya/wix-bookings";
+import { getMyMember } from "@himalaya/wix-members";
+import { memberAccess, type MemberAccess } from "../_shared/member-access.js";
+import { placesIn, sessionControl, sessionOf, type MemberPlace, type Session, type SessionControl } from "../_shared/booking-session.js";
+import { categoryName, courseDatesText, courseReadWindows, courseSessionsAvailability, courseWindowOpen, serviceDurationText, servicePriceLine, slotStartInstant, type BookingLabel, type ServicePriceLine } from "../_shared/himi-bookings.js";
+import { formatServiceMoney, serviceCurrency } from "../_shared/wix-service-price.js";
+import { stashCopy, copyParam, copyTemplate, copyPlural } from "../_shared/himi-copy.js";
+import { get, type DbEntity } from "@himalaya/local-db";
+import { wixMediaUrl, WIX_DETAIL_IMAGE, WIX_LIST_IMAGE } from "@himalaya/wix-media";
+import { formatClock, formatDateMedium, formatMonthDay } from "../_shared/engine-intl.js";
+import { descriptionBody } from "../_shared/rich-body.js";
+import { openRichLink } from "../_shared/rich-content-link.js";
+import { isServiceSaved, toggleSavedService } from "../_shared/himi-booking-saved.js";
+
+// Offline-first (data-offline): the service detail is a public read-through. On a
+// fetch failure we fall back to the last-synced row for this service written by
+// the services LIST worker (shared `services` entity). DEGRADES GRACEFULLY: the
+// local-db read is wrapped so a bundle that ships in an app which hasn't granted
+// `local_database` behaves exactly as before (online-only, error on failure).
+const ENTITY = "services";
+async function readCached(id: string): Promise<DbEntity | null> {
+  try { return await get(ENTITY, id); } catch { /* capability not granted → online-only */ return null; }
+}
+
+/** Staff names come back only on request (Wix "Get Service" `conditionalFields`). */
+const SERVICE_FIELDS = { conditionalFields: ["STAFF_MEMBER_DETAILS"] };
+/** At most this many location rows, in record order. */
+const MAX_LOCATIONS = 3;
+
+interface ServiceImage { url: string; alt: string }
+interface LocationRow {
+  index: number;
+  title: string;
+  /** A maps search for the address; "" for the client's place. */
+  directionsUrl: string;
+  tappable: boolean;
+  notTappable: boolean;
+  a11y: string;
+}
+interface PolicyLine { text: string; owner: boolean; notOwner: boolean }
+interface CourseSession { date: string; time: string }
+
+interface S {
+  status: "loading" | "ready";
+  id: string;
+  name: string;
+  /** The category name, shown as the small label above the name. */
+  category: string;
+  noCategory: boolean;
+  typeTag: string;
+  noTypeTag: boolean;
+  isClass: boolean;
+  isCourse: boolean;
+  noCourse: boolean;
+  tagline: string;
+  noTagline: boolean;
+  /** The price line: "₪90" + "per session", "From ₪60", "Free", or a CUSTOM description. */
+  priceText: string;
+  priceUnit: string;
+  /** A CUSTOM rate: the owner's own words stand in for the price, with no unit. */
+  priceIsText: boolean;
+  noPrice: boolean;
+  noPriceUnit: boolean;
+  /** Hide the amount row (no price, or a CUSTOM text price). */
+  noPriceAmount: boolean;
+  /** Hide the CUSTOM text price (any other rate). */
+  noPriceDescription: boolean;
+  priceA11y: string;
+  images: ServiceImage[];
+  /** The first image, for the one-image case. */
+  image: string;
+  hasGallery: boolean;
+  noGallery: boolean;
+  hasOneImage: boolean;
+  noOneImage: boolean;
+  hasImage: boolean;
+  noImage: boolean;
+  durationText: string;
+  noDuration: boolean;
+  courseDates: string;
+  courseSessionCount: string;
+  noCourseDates: boolean;
+  spotsText: string;
+  noSpots: boolean;
+  spotsWarning: boolean;
+  spotsNeutral: boolean;
+  hideSpotsNeutral: boolean;
+  courseSessions: CourseSession[];
+  noCourseSessions: boolean;
+  courseMoreSessions: CourseSession[];
+  noCourseMoreSessions: boolean;
+  scheduleExpanded: boolean;
+  scheduleCollapsed: boolean;
+  courseCtaBook: boolean;
+  courseCtaRequest: boolean;
+  courseCtaFull: boolean;
+  courseCtaClosed: boolean;
+  hideChooseTime: boolean;
+  hideRequestTime: boolean;
+  noCourseCtaBook: boolean;
+  noCourseCtaRequest: boolean;
+  noCourseCtaFull: boolean;
+  noCourseCtaClosed: boolean;
+  locations: LocationRow[];
+  noLocations: boolean;
+  online: boolean;
+  noOnline: boolean;
+  staffText: string;
+  staffImage: string;
+  staffInitials: string;
+  hasStaffImage: boolean;
+  noStaffImage: boolean;
+  noStaff: boolean;
+  payText: string;
+  paySub: string;
+  noPay: boolean;
+  noPaySub: boolean;
+  /** The business confirms each booking: the button says "Request to Book". */
+  requestToBook: boolean;
+  notRequestToBook: boolean;
+  bookableOnline: boolean;
+  notBookableOnline: boolean;
+  about: string;
+  aboutJson: string;
+  hasAboutJson: boolean;
+  noAbout: boolean;
+  policyLines: PolicyLine[];
+  noPolicy: boolean;
+  policyExpanded: boolean;
+  policyCollapsed: boolean;
+  /** No fact row has data: the facts section and its divider hide. */
+  noFacts: boolean;
+  /** No price, duration or category: Branded Web's summary grid hides. */
+  noKeyFacts: boolean;
+  /** Loading, error or empty: the service content hides. */
+  hideContent: boolean;
+  hideFooter: boolean;
+  /** Share payload — the service page URL when the payload carries one. */
+  shareUrl: string;
+  timeScreenId: string;
+  emptyText: string;
+  errored: boolean;
+  notErrored: boolean;
+  isLoading: boolean;
+  notLoading: boolean;
+  hasService: boolean;
+  noEmpty: boolean;
+  // ---- The session an Agenda row opened this screen on (all "" without one) ----
+  /** Its Wix session id ("" when it has none) and start instant: Book opens Choose Time on it. */
+  sessionId: string;
+  sessionStart: string;
+  /** "Tue, Nov 5 · 6:00 PM" under the name; the date and the time range apart for the fact row. */
+  sessionWhen: string;
+  sessionDate: string;
+  sessionTime: string;
+  noSession: boolean;
+  /** The control the Agenda row shows for this session (`sessionControl`), "" without a session. */
+  sessionControl: "" | SessionControl;
+  /** Why a closed session cannot be booked: "Full", "Not open yet" or "Closed". */
+  closedLabel: string;
+  noSessionBook: boolean;
+  noSessionRequest: boolean;
+  noSessionWaitlist: boolean;
+  noSessionClosed: boolean;
+  noSessionBooked: boolean;
+  noSessionWaitlisted: boolean;
+  /** "Change time" shows while the member can still choose another session. */
+  noChangeTime: boolean;
+  /** The outcome of a waitlist join, above the footer's control: it went through (a check) or not. */
+  sessionMessage: string;
+  sessionMessageOk: boolean;
+  sessionMessageFailed: boolean;
+  noSessionMessage: boolean;
+  // ---- Favorites (the heart an app adds with withServiceSaveToggle; _shared/himi-booking-saved.ts) ----
+  saved: boolean;
+  notSaved: boolean;
+  /** The heart's spoken label: what a tap does now. */
+  saveLabel: string;
+  /** "" unless the last save or unsave failed. */
+  saveMessage: string;
+}
+
+function inputId(): string {
+  // WS-C — `himalaya.input.id` is the PRIMARY contract: hosts thread the row's
+  // `id` nav param (himi.open { screenId: "himi_service", id }) into worker input.
+  // The screenId-slice below is #570 back-compat for pre-params releases with
+  // baked `himi_service_<id>` screenIds — do not author against this.
+  const input = (globalThis as { himalaya?: { input?: { id?: unknown; screenId?: unknown } } }).himalaya?.input;
+  if (typeof input?.id === "string" && input.id) return input.id;
+  const screenId = typeof input?.screenId === "string" ? input.screenId : "";
+  return screenId.startsWith("himi_service_") ? screenId.slice("himi_service_".length) : "";
+}
+
+/** The session an Agenda row opened this screen on, from the same input as `id`: `sessionId`
+ *  (the Wix session id, "" for a session without one) and `start` (its ISO instant). No valid
+ *  `start` — opened from the Services list — and the screen has no session. */
+function inputSession(): { sessionId: string; start: string } {
+  const input = (globalThis as { himalaya?: { input?: { sessionId?: unknown; start?: unknown } } }).himalaya?.input;
+  const start = typeof input?.start === "string" && Number.isFinite(Date.parse(input.start)) ? input.start : "";
+  return { sessionId: start && typeof input?.sessionId === "string" ? input.sessionId.trim() : "", start };
+}
+
+function stringOf(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function numberOf(value: unknown): number | undefined {
+  if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+  if (typeof value === "string" && value.trim()) {
+    const n = Number(value);
+    return Number.isNaN(n) ? undefined : n;
+  }
+  return undefined;
+}
+
+// ---- Price -----------------------------------------------------------------------
+
+/** The service screen's copy keys for the shared price, duration and course-date lines. */
+const serviceLabel: BookingLabel = (key, fallback, values) =>
+  values ? copyTemplate(`service.${key}`, fallback, values) : copyParam(`service.${key}`, fallback);
+
+function priceLine(service: WixService): ServicePriceLine {
+  return servicePriceLine(service, serviceLabel);
+}
+
+// ---- Media -----------------------------------------------------------------------
+
+/** Every distinct image of the service: `media.items`, then `mainMedia`, then `coverMedia`. */
+function serviceImages(service: WixService, name: string): ServiceImage[] {
+  const media = service.media ?? {};
+  const out: ServiceImage[] = [];
+  for (const item of [...(media.items ?? []), media.mainMedia, media.coverMedia]) {
+    const url = wixMediaUrl(item?.image?.url, WIX_DETAIL_IMAGE);
+    if (url && !out.some((image) => image.url === url)) out.push({ url, alt: stringOf(item?.image?.altText) || name });
+  }
+  if (!out.length) {
+    // Older payloads carry one image in another shape.
+    const legacy = legacyImageUrl(service);
+    if (legacy) out.push({ url: legacy, alt: name });
+  }
+  return out;
+}
+
+function legacyImageUrl(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 = legacyImageUrl(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 = legacyImageUrl(node[key]);
+    if (url) return url;
+  }
+  return "";
+}
+
+// ---- Duration --------------------------------------------------------------------
+
+function durationText(service: WixService): string {
+  return serviceDurationText(service, serviceLabel);
+}
+
+// ---- Locations -------------------------------------------------------------------
+
+/** The address as one line, or "" when it names no place. A country alone (the Wix default
+ *  "Location 1") is not an address. */
+function addressText(address: WixServiceAddress | undefined): string {
+  if (!address) return "";
+  const formatted = stringOf(address.formattedAddress);
+  if (formatted) return formatted;
+  const street = [stringOf(address.streetAddress?.number), stringOf(address.streetAddress?.name)].filter(Boolean).join(" ");
+  const line = [street, stringOf(address.streetAddress?.apt)].filter(Boolean).join(" ") || stringOf(address.addressLine);
+  const city = stringOf(address.city);
+  if (!line && !city) return "";
+  return [line, city, stringOf(address.subdivision), stringOf(address.postalCode), stringOf(address.country)].filter(Boolean).join(", ");
+}
+
+function directionsUrl(address: string): string {
+  return `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(address)}`;
+}
+
+/** One row per location the customer can act on: a BUSINESS or CUSTOM location with an
+ *  address (tap → maps), or the client's place. At most {@link MAX_LOCATIONS}. */
+function locationRows(service: WixService): LocationRow[] {
+  const rows: LocationRow[] = [];
+  for (const location of service.locations ?? []) {
+    if (rows.length >= MAX_LOCATIONS) break;
+    const type = stringOf(location?.type).toUpperCase();
+    if (type === "CUSTOMER") {
+      const title = copyParam("service.clientPlace", "Client's place");
+      rows.push({ index: rows.length, title, directionsUrl: "", tappable: false, notTappable: true, a11y: title });
+      continue;
+    }
+    const place = type === "BUSINESS" ? location.business : type === "CUSTOM" ? location.custom : undefined;
+    if (!place) continue;
+    const address = addressText(place.address) || addressText(location.calculatedAddress);
+    if (!address) continue;
+    const title = (type === "BUSINESS" ? stringOf(location.business?.name) : "") || address;
+    rows.push({
+      index: rows.length,
+      title,
+      directionsUrl: directionsUrl(address),
+      tappable: true,
+      notTappable: false,
+      a11y: copyTemplate("service.directionsLabel", "Get directions to {place}", { place: title }),
+    });
+  }
+  return rows;
+}
+
+// ---- Staff -----------------------------------------------------------------------
+
+function initials(name: string): string {
+  return name.split(/\s+/).filter(Boolean).slice(0, 2).map((part) => part[0]!.toUpperCase()).join("");
+}
+
+function firstName(name: string): string {
+  return name.split(/\s+/)[0] ?? name;
+}
+
+/** "With Noa Levi", "With Noa or Dana", "With Noa, Dana and 2 more". Empty when the
+ *  record carries no staff details (a visitor may not be allowed to read them). */
+function staffLine(service: WixService): { text: string; image: string; initials: string } {
+  const staff = (service.staffMemberDetails?.staffMembers ?? []).filter((member) => stringOf(member?.name));
+  if (!staff.length) return { text: "", image: "", initials: "" };
+  const names = staff.map((member) => stringOf(member.name));
+  const text = names.length === 1
+    ? copyTemplate("service.staffOne", "With {name}", { name: names[0]! })
+    : names.length === 2
+      ? copyTemplate("service.staffTwo", "With {a} or {b}", { a: firstName(names[0]!), b: firstName(names[1]!) })
+      : copyTemplate("service.staffMany", "With {a}, {b} and {count} more", { a: firstName(names[0]!), b: firstName(names[1]!), count: names.length - 2 });
+  return { text, image: wixMediaUrl(staff[0]!.mainMedia?.image?.url, WIX_LIST_IMAGE), initials: initials(names[0]!) };
+}
+
+// ---- How to pay ------------------------------------------------------------------
+
+/** The payment row, by the first rule that matches. Never mentions pricing plans. */
+function payLine(service: WixService): { text: string; sub: string } {
+  const payment = service.payment ?? {};
+  const rate = stringOf(payment.rateType).toUpperCase();
+  if (rate === "NO_FEE") return { text: "", sub: "" };
+  const options = payment.options ?? {};
+  const currency = serviceCurrency(service);
+  const depositMoney = payment.fixed?.deposit ?? payment.varied?.deposit;
+  const deposit = numberOf(depositMoney?.value);
+  if (options.deposit && deposit != null && deposit > 0) {
+    const price = rate === "VARIED" ? undefined : numberOf(payment.fixed?.price?.value);
+    const remaining = price != null && price > deposit ? price - deposit : undefined;
+    const depositCurrency = stringOf(depositMoney?.currency) || currency;
+    return {
+      text: copyTemplate("service.payDeposit", "{amount} deposit", { amount: formatServiceMoney(depositMoney, currency) }),
+      sub: remaining != null
+        ? copyTemplate("service.payDueLater", "{amount} due later", { amount: formatServiceMoney({ value: String(remaining), currency: depositCurrency }, currency) })
+        : "",
+    };
+  }
+  if (options.online && options.inPerson) return { text: copyParam("service.payBoth", "Pay now or in person"), sub: "" };
+  if (options.online) return { text: copyParam("service.payOnline", "Pay now"), sub: "" };
+  if (options.inPerson) return { text: copyParam("service.payInPerson", "Pay in person"), sub: "" };
+  return { text: "", sub: "" };
+}
+
+// ---- Our policy ------------------------------------------------------------------
+
+/** Minutes as words: under 60 → minutes; under 2 days, or not whole days → hours; else days. */
+function windowText(minutes: number): string {
+  if (minutes < 60) {
+    return minutes === 1 ? copyParam("service.minute", "1 minute") : copyTemplate("service.minutes", "{n} minutes", { n: minutes });
+  }
+  if (minutes < 2880 || minutes % 1440 !== 0) {
+    const hours = Math.round((minutes / 60) * 10) / 10;
+    return hours === 1 ? copyParam("service.hour", "1 hour") : copyTemplate("service.hours", "{n} hours", { n: hours });
+  }
+  const days = minutes / 1440;
+  return days === 1 ? copyParam("service.day", "1 day") : copyTemplate("service.days", "{n} days", { n: days });
+}
+
+type Change = { kind: "none" } | { kind: "anytime" } | { kind: "until"; minutes: number } | { kind: "off" };
+
+function changeRule(enabled: boolean | undefined, limited: boolean | undefined, minutes: number | undefined): Change {
+  if (enabled === undefined) return { kind: "none" };
+  if (!enabled) return { kind: "off" };
+  return limited && minutes != null && minutes > 0 ? { kind: "until", minutes } : { kind: "anytime" };
+}
+
+/** Strip HTML from the owner's policy text but keep its line breaks. */
+function policyText(text: string): string {
+  return text.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<[^>]*>/g, "").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+/** The lines of "Our policy", from the business's own booking policy. The app never
+ *  invents policy text: each line exists only when the policy states it. */
+function policyLines(policy: WixServiceBookingPolicy | undefined, type: string): PolicyLine[] {
+  if (!policy) return [];
+  const lines: PolicyLine[] = [];
+  const add = (text: string, owner = false) => { if (text) lines.push({ text, owner, notOwner: !owner }); };
+  const templated = (key: string, fallback: string, values: Record<string, string | number>) =>
+    type === "COURSE" && fallback.includes("session starts")
+      ? copyTemplate(`${key}Course`, fallback.replace("session starts", "course starts"), values)
+      : copyTemplate(key, fallback, values);
+
+  const custom = policy.customPolicyDescription;
+  if (custom?.enabled) add(policyText(stringOf(custom.description)), true);
+
+  const cancel = changeRule(policy.cancellationPolicy?.enabled, policy.cancellationPolicy?.limitLatestCancellation, numberOf(policy.cancellationPolicy?.latestCancellationInMinutes));
+  const reschedule = changeRule(policy.reschedulePolicy?.enabled, policy.reschedulePolicy?.limitLatestReschedule, numberOf(policy.reschedulePolicy?.latestRescheduleInMinutes));
+  if (cancel.kind === "until" && reschedule.kind === "until" && cancel.minutes === reschedule.minutes) {
+    add(templated("service.changeUntil", "Cancel or reschedule online up to {window} before the session starts.", { window: windowText(cancel.minutes) }));
+  } else if (cancel.kind === "anytime" && reschedule.kind === "anytime") {
+    add(copyParam("service.changeAnytime", "You can cancel or reschedule online at any time."));
+  } else {
+    if (cancel.kind === "until") add(templated("service.cancelUntil", "Cancel online up to {window} before the session starts.", { window: windowText(cancel.minutes) }));
+    if (cancel.kind === "anytime") add(copyParam("service.cancelAnytime", "You can cancel online at any time."));
+    if (cancel.kind === "off") add(copyParam("service.cancelNotOnline", "You can't cancel online. Contact us to cancel."));
+    if (reschedule.kind === "until") add(templated("service.rescheduleUntil", "Reschedule online up to {window} before the session starts.", { window: windowText(reschedule.minutes) }));
+    if (reschedule.kind === "anytime") add(copyParam("service.rescheduleAnytime", "You can reschedule online at any time."));
+    if (reschedule.kind === "off") add(copyParam("service.rescheduleNotOnline", "You can't reschedule online."));
+  }
+
+  const fees = policy.cancellationFeePolicy;
+  if (fees?.enabled) {
+    for (const window of fees.cancellationWindows ?? []) {
+      const percentage = stringOf(window?.percentage);
+      const fee = formatServiceMoney(window?.amount) || (percentage ? `${percentage}%` : "");
+      if (!fee) continue;
+      const start = numberOf(window?.startInMinutes);
+      if (start == null || start <= 0) add(copyTemplate("service.feeLate", "Late cancellations have a {fee} fee.", { fee }));
+      else if (cancel.kind === "until" && cancel.minutes === start) add(copyTemplate("service.feeAfterThat", "Cancellations after that have a {fee} fee.", { fee }));
+      else add(templated("service.feeWindow", "Cancellations less than {window} before the session starts have a {fee} fee.", { window: windowText(start), fee }));
+    }
+  }
+
+  const early = policy.limitEarlyBookingPolicy;
+  const earliest = numberOf(early?.earliestBookingInMinutes);
+  if (early?.enabled && earliest != null && earliest > 0) add(templated("service.bookingsOpen", "Bookings open {window} before the session starts.", { window: windowText(earliest) }));
+  const late = policy.limitLateBookingPolicy;
+  const latest = numberOf(late?.latestBookingInMinutes);
+  if (late?.enabled && latest != null && latest > 0) add(templated("service.bookingsClose", "Bookings close {window} before the session starts.", { window: windowText(latest) }));
+
+  // Live payloads also carry `participantsPolicy.enabled` (not in the V2 types); a disabled
+  // policy keeps its configured maximum, which is not a rule the customer is held to.
+  const participants = policy.participantsPolicy as { enabled?: boolean; maxParticipantsPerBooking?: number } | undefined;
+  const max = numberOf(participants?.maxParticipantsPerBooking);
+  if (participants?.enabled !== false && max != null && max > 1) add(copyTemplate("service.maxParticipants", "Book for up to {n} participants.", { n: max }));
+  if (type === "CLASS" && policy.waitlistPolicy?.enabled) add(copyParam("service.waitlistRule", "When a class is full, you can join the waitlist."));
+  if (type === "COURSE" && policy.bookAfterStartPolicy?.enabled) add(copyParam("service.joinAfterStart", "You can join after the course starts."));
+  return lines;
+}
+
+// ---- Share -----------------------------------------------------------------------
+
+/** The service's public page URL when the payload carries one ("" otherwise). Bookings
+ *  V2 puts it at `urls.servicePage.url`; the other shapes are older payloads. */
+function serviceShareUrl(service: WixService): string {
+  const page = stringOf(service.urls?.servicePage?.url);
+  if (/^https?:\/\//i.test(page)) return page;
+  const raw = service as unknown as {
+    url?: unknown;
+    servicePageUrl?: { base?: string; path?: string; relativePath?: string } | string;
+  };
+  if (typeof raw.url === "string" && /^https?:\/\//i.test(raw.url)) return raw.url;
+  const legacy = raw.servicePageUrl;
+  if (typeof legacy === "string" && /^https?:\/\//i.test(legacy)) return legacy;
+  if (legacy && typeof legacy === "object" && typeof legacy.base === "string" && legacy.base) {
+    const path = typeof legacy.path === "string" ? legacy.path : typeof legacy.relativePath === "string" ? legacy.relativePath : "";
+    return `${legacy.base.replace(/\/$/, "")}${path && !path.startsWith("/") ? "/" : ""}${path}`;
+  }
+  return "";
+}
+
+// ---- Class and course ------------------------------------------------------------
+
+const DAY_MS = 86_400_000;
+const GROUP_WINDOW_DAYS = 14;
+
+function validDate(value: string | undefined): Date | undefined {
+  if (!value) return undefined;
+  const date = new Date(value);
+  return Number.isFinite(date.getTime()) ? date : undefined;
+}
+
+function shortDate(date: Date, year: boolean): string {
+  return year ? formatDateMedium(date, "en") : formatMonthDay(date, "en");
+}
+
+function courseDates(service: WixService): string {
+  return courseDatesText(service);
+}
+
+function spotCount(entry: WixAvailabilityEntry | undefined): number | undefined {
+  const count = numberOf(entry?.openSpots);
+  return count != null && count >= 0 ? count : undefined;
+}
+
+function spotText(count: number): string {
+  return copyPlural("service.spotsLeft", "{n, plural, one {# spot left} other {# spots left}}", count);
+}
+
+function sessionTime(start: string, end: string | undefined): string {
+  const from = validDate(start);
+  const to = validDate(end);
+  if (!from) return "";
+  return to ? `${formatClock(from, "en")} – ${formatClock(to, "en")}` : formatClock(from, "en");
+}
+
+/** V1 availability is the same visitor-readable call used by the time screen. Ask
+ *  for full entries too, since `bookable: true` hides the full sessions whose
+ *  zero capacity and waitlist state the design needs. Bound every request to 14
+ *  days; a course reads at most 84 days and never calls its partial count exact. */
+async function groupAvailability(service: WixService, now: Date): Promise<{ entries: WixAvailabilityEntry[]; complete: boolean; readToEnd: boolean }> {
+  if (service.type === "CLASS") {
+    const res = await queryServiceAvailability(service.id, now.toISOString(), new Date(now.getTime() + GROUP_WINDOW_DAYS * DAY_MS).toISOString(), { bookable: false });
+    return { entries: res.availabilityEntries ?? [], complete: true, readToEnd: true };
+  }
+  if (service.type !== "COURSE") return { entries: [], complete: true, readToEnd: true };
+  // The same sessions the time screen checks before it books (_shared/himi-bookings.ts). The
+  // session count is the whole course only when the read starts at its first session.
+  const read = courseReadWindows(service, now.getTime(), GROUP_WINDOW_DAYS);
+  const replies = await Promise.all(read.windows.map(([from, to]) =>
+    queryServiceAvailability(service.id, new Date(from).toISOString(), new Date(to).toISOString(), { bookable: false })));
+  return { entries: replies.flatMap((res) => res.availabilityEntries ?? []), complete: read.complete && read.fromFirst, readToEnd: read.complete };
+}
+
+/** When a session starts, read in its own zone (a local wall time beside `timezone`). */
+function sessionStart(entry: WixAvailabilityEntry): number {
+  return entry.slot ? slotStartInstant(entry.slot as { startDate?: string; timezone?: unknown }) : NaN;
+}
+
+async function withGroupAvailability(s: S, service: WixService): Promise<S> {
+  if (service.type !== "CLASS" && service.type !== "COURSE") return s;
+  const now = new Date();
+  try {
+    const result = await groupAvailability(service, now);
+    const seen = new Set<string>();
+    const entries = result.entries.filter((entry) => {
+      const slot = entry.slot;
+      if (!slot?.startDate) return false;
+      const key = String(slot.sessionId ?? slot.startDate);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    }).sort((a, b) => sessionStart(a) - sessionStart(b));
+    const next = entries.find((entry) => sessionStart(entry) >= now.getTime());
+    // A course is booked whole, so its count is the smallest across every upcoming session, and
+    // one session that cannot be booked closes it (the rule the time screen books by).
+    const course = service.type === "COURSE" ? courseSessionsAvailability(entries, now.getTime(), result.readToEnd) : undefined;
+    const count = course ? course.spots : spotCount(next);
+    // No upcoming session read back: the time screen refuses it, so the button is closed too.
+    const courseClosed = s.courseCtaClosed || (course != null && (!course.found || (!course.bookable && count !== 0)));
+    const waitlist = service.type === "CLASS" && service.bookingPolicy?.waitlistPolicy?.enabled === true &&
+      (numberOf(next?.waitingList?.openSpots) ?? 0) > 0;
+    const spotsText = count == null ? "" : count > 0 ? spotText(count)
+      : service.type === "CLASS"
+        ? waitlist
+          ? copyParam("service.classFullWaitlist", "The class is fully booked. You can join the waitlist.")
+          : copyParam("service.classFull", "The class is fully booked.")
+        : "";
+    const courseSessions = service.type === "COURSE" ? entries.map((entry) => ({
+      date: shortDate(validDate(entry.slot!.startDate)!, true),
+      time: sessionTime(entry.slot!.startDate!, entry.slot!.endDate),
+    })) : [];
+    return derive({
+      ...s,
+      spotsText,
+      spotsWarning: count != null && count > 0 && count <= 3,
+      courseCtaClosed: courseClosed,
+      courseCtaFull: service.type === "COURSE" && count === 0 && !courseClosed,
+      courseCtaBook: service.type === "COURSE" && count !== 0 && !s.requestToBook && !courseClosed,
+      courseCtaRequest: service.type === "COURSE" && count !== 0 && s.requestToBook && !courseClosed,
+      courseSessionCount: service.type === "COURSE" && result.complete && courseSessions.length > 0
+        ? copyPlural("service.sessionsCount", "{n, plural, one {# session} other {# sessions}}", courseSessions.length) : "",
+      courseSessions: courseSessions.slice(0, 3),
+      courseMoreSessions: courseSessions.slice(3),
+    });
+  } catch {
+    // The record still loads if the availability endpoint is unavailable. Unknown
+    // capacity stays unknown; the customer can inspect availability at booking.
+    return s;
+  }
+}
+
+// ---- The session from the Agenda -------------------------------------------------
+
+/** The session as last read, with the member its place was read for: a join checks against them. */
+interface Picked { session: Session; place: MemberPlace | undefined; who: MemberAccess | undefined }
+
+const NO_SESSION = {
+  sessionId: "", sessionStart: "", sessionWhen: "", sessionDate: "", sessionTime: "", sessionControl: "" as const, closedLabel: "",
+};
+const NO_SESSION_MESSAGE = { sessionMessage: "", sessionMessageOk: false, sessionMessageFailed: false };
+
+let picked: Picked | undefined;
+/** The record the last load showed: a join that finds another member re-reads its session. */
+let loadedService: WixService | undefined;
+/** A waitlist join is in flight: a second tap registers nothing. */
+let joining = false;
+
+/** The input session as the Agenda read it: the service's availability on that LOCAL day (the
+ *  Agenda reads whole local days), the entry with the session id — or, for a session without
+ *  one, the same start instant — and the signed-in member's place in it. `undefined` when the
+ *  screen has no session, the service is not a class or course, the session is no longer listed,
+ *  or a read fails: the screen then offers "Choose a Time", as from the Services list. */
+async function readSession(service: WixService): Promise<Picked | undefined> {
+  const want = inputSession();
+  const type = stringOf(service.type).toUpperCase();
+  if (!want.start || (type !== "CLASS" && type !== "COURSE")) return undefined;
+  const day = dayKey(want.start);
+  try {
+    const from = new Date(`${day}T00:00:00`).toISOString();
+    const to = new Date(`${dayKey(addDays(day, 1))}T00:00:00`).toISOString();
+    const res = await queryServiceAvailability(service.id, from, to, { bookable: false });
+    const sessions = (res.availabilityEntries ?? []).map((entry) => sessionOf(entry, service)).filter((x): x is Session => !!x);
+    const at = Date.parse(want.start);
+    // Two sessions of a class can start at the same instant: the session id decides when there is one.
+    const session = want.sessionId
+      ? sessions.find((x) => x.sessionId === want.sessionId)
+      : sessions.find((x) => !x.sessionId && Date.parse(x.start) === at) ?? sessions.find((x) => Date.parse(x.start) === at);
+    if (!session) return undefined;
+    // A failed bookings read is not "no place": Book on a session the member holds invites a
+    // duplicate, so the screen falls back to Choose a Time instead (placesIn throws).
+    const { who, found } = await placesIn(day, day, [session]);
+    return { session, place: found.get(session.key), who };
+  } catch (err) {
+    // Not silent: the screen still offers "Choose a Time", and the host log says why it did not
+    // offer the session's own control.
+    console.warn("himi_service: the Agenda session could not be read; offering Choose a Time", err);
+    return undefined;
+  }
+}
+
+/** How long the session read may take before the screen paints without it. The read asks the host
+ *  for the member's identity, and a host whose identity dispatch never settles must not pin the
+ *  skeleton (the time screen's D5 case). */
+const SESSION_READ_BUDGET_MS = 10_000;
+
+/** `readSession`, or `undefined` once the budget is spent. A worker engine with no timer waits
+ *  for the read itself. */
+function readSessionBounded(service: WixService): Promise<Picked | undefined> {
+  const host = globalThis as { setTimeout?: (fn: () => void, ms: number) => unknown; clearTimeout?: (timer: unknown) => void };
+  const read = readSession(service);
+  if (typeof host.setTimeout !== "function") return read;
+  return new Promise((resolve) => {
+    const timer = host.setTimeout!(() => resolve(undefined), SESSION_READ_BUDGET_MS);
+    void read.then((sel) => {
+      try { host.clearTimeout?.(timer); } catch { /* best-effort */ }
+      resolve(sel);
+    });
+  });
+}
+
+/** A class session's own spots: "4 spots left", or full — with "You can join the waitlist" only
+ *  when Join Waitlist is offered. The service-wide line describes the NEXT session, which may be
+ *  another one. Unknown capacity (the site reports none) shows no line, as on the Agenda row. */
+function sessionSpots(session: Session, control: SessionControl): Pick<S, "spotsText" | "spotsWarning"> {
+  if (session.total <= 0) return { spotsText: "", spotsWarning: false };
+  if (session.open > 0) return { spotsText: spotText(session.open), spotsWarning: session.open <= 3 };
+  return {
+    spotsText: control === "waitlist"
+      ? copyParam("service.classFullWaitlist", "The class is fully booked. You can join the waitlist.")
+      : copyParam("service.classFull", "The class is fully booked."),
+    spotsWarning: false,
+  };
+}
+
+/** `s` showing `sel` — or no session. Records `sel` as the session a join acts on. */
+function withSession(s: S, sel: Picked | undefined): S {
+  picked = sel;
+  if (!sel) return derive({ ...s, ...NO_SESSION });
+  const { session, place } = sel;
+  const { control, closedLabel } = sessionControl(session, place);
+  const date = dayLabel(session.start, { absolute: true });
+  const time = Date.parse(session.end) > Date.parse(session.start)
+    ? `${timeLabel(session.start)} – ${timeLabel(session.end)}`
+    : timeLabel(session.start);
+  return derive({
+    ...s,
+    ...(session.kind === "class" ? sessionSpots(session, control) : {}),
+    sessionId: session.sessionId,
+    sessionStart: session.start,
+    sessionDate: date,
+    sessionTime: time,
+    // The start only: beside "Change Time" a full range broke mid-range on a phone. The fact row
+    // below carries the range.
+    sessionWhen: [date, timeLabel(session.start)].filter(Boolean).join(" · "),
+    sessionControl: control,
+    closedLabel,
+  });
+}
+
+/** The member's name for a waitlist registration, when their member record has one (the Agenda's
+ *  rule). The email alone registers; a failed profile read registers by email alone. */
+async function memberName(): Promise<{ firstName?: string; lastName?: string }> {
+  const res = await getMyMember({ fieldsets: ["FULL"] }).catch(() => undefined);
+  const contact = res?.member?.contact as { firstName?: string; lastName?: string } | undefined;
+  return { firstName: contact?.firstName || undefined, lastName: contact?.lastName || undefined };
+}
+
+const sameMember = (a: MemberAccess | undefined, b: MemberAccess | undefined): boolean =>
+  !!a?.email && a.email === b?.email && a.scope === b?.scope;
+
+/** Where a visitor's Join Waitlist signs in: the app's sign-in screen and how it opens, from the
+ *  appear (or tap) params — Branded Lite passes `himi_sign_in` as a sheet. */
+let signInScreenId = "";
+let signInPresentation: "" | "sheet" | "full_screen" = "";
+function rememberSignIn(arg: unknown): void {
+  const a = (arg ?? {}) as { signInScreenId?: unknown; signInPresentation?: unknown };
+  if (typeof a.signInScreenId === "string" && a.signInScreenId.trim()) signInScreenId = a.signInScreenId.trim();
+  if (a.signInPresentation === "sheet" || a.signInPresentation === "full_screen") signInPresentation = a.signInPresentation;
+}
+
+// ---- State -----------------------------------------------------------------------
+
+function derive(s: S): S {
+  const isLoading = s.status === "loading";
+  const hasService = !!s.name;
+  const hasImage = s.images.length > 0;
+  const control = s.sessionControl;
+  // The session's own control replaces the service-wide one; a course session not yet booked
+  // keeps the course footer ("course"), as on the Agenda, where it opens this screen.
+  const sessionCta = control !== "" && control !== "course";
+  const ownPlace = control === "booked" || control === "waitlisted";
+  return {
+    ...s,
+    isLoading,
+    notLoading: !isLoading,
+    notErrored: !s.errored,
+    hasService,
+    noEmpty: isLoading || s.errored || hasService,
+    noCategory: !s.category,
+    noTypeTag: !s.typeTag,
+    noCourse: !s.isCourse,
+    noTagline: !s.tagline,
+    noPrice: !s.priceText,
+    noPriceUnit: !s.priceUnit,
+    noPriceAmount: !s.priceText || s.priceIsText,
+    noPriceDescription: !s.priceText || !s.priceIsText,
+    priceA11y: s.priceText && !s.priceIsText
+      ? copyTemplate("service.priceLabel", "Price, {price}", { price: [s.priceText, s.priceUnit].filter(Boolean).join(" ") })
+      : "",
+    image: s.images[0]?.url ?? "",
+    hasGallery: s.images.length > 1,
+    noGallery: s.images.length < 2,
+    hasOneImage: s.images.length === 1,
+    noOneImage: s.images.length !== 1,
+    hasImage,
+    noImage: !hasImage,
+    noDuration: !s.durationText,
+    noCourseDates: !s.courseDates,
+    noSpots: !s.spotsText,
+    spotsNeutral: !s.spotsWarning,
+    hideSpotsNeutral: !s.spotsText || s.spotsWarning,
+    noCourseMoreSessions: s.courseMoreSessions.length === 0,
+    noCourseSessions: s.courseSessions.length === 0,
+    scheduleCollapsed: !s.scheduleExpanded,
+    noLocations: s.locations.length === 0,
+    noOnline: !s.online,
+    noStaff: !s.staffText,
+    hasStaffImage: !!s.staffImage,
+    noStaffImage: !s.staffImage,
+    noPay: !s.payText,
+    noPaySub: !s.paySub,
+    notRequestToBook: !s.requestToBook,
+    hideChooseTime: s.isCourse || s.requestToBook || sessionCta,
+    hideRequestTime: s.isCourse || !s.requestToBook || sessionCta,
+    noCourseCtaBook: !s.courseCtaBook || sessionCta,
+    noCourseCtaRequest: !s.courseCtaRequest || sessionCta,
+    noCourseCtaFull: !s.courseCtaFull || sessionCta,
+    noCourseCtaClosed: !s.courseCtaClosed || sessionCta,
+    noSession: !s.sessionWhen,
+    // Book where the Agenda row says Book; "Request to Book" when the business confirms each one.
+    noSessionBook: control !== "book" || s.requestToBook,
+    noSessionRequest: control !== "book" || !s.requestToBook,
+    noSessionWaitlist: control !== "waitlist",
+    noSessionClosed: control !== "closed",
+    noSessionBooked: control !== "booked",
+    noSessionWaitlisted: control !== "waitlisted",
+    // Change Time opens the time screen, which cannot book a service closed to online booking.
+    noChangeTime: (control !== "book" && control !== "waitlist" && control !== "closed") || !s.bookableOnline,
+    noSessionMessage: !s.sessionMessage,
+    notSaved: !s.saved,
+    saveLabel: s.saved
+      ? copyParam("service.unsaveLabel", "Remove from favorites")
+      : copyParam("service.saveLabel", "Save to favorites"),
+    notBookableOnline: !s.bookableOnline,
+    noAbout: !s.about && !s.aboutJson,
+    noPolicy: s.policyLines.length === 0,
+    policyCollapsed: !s.policyExpanded,
+    noFacts: !s.sessionWhen && !s.courseDates && !s.durationText && !s.spotsText && s.locations.length === 0 && !s.online && !s.staffText && !s.payText,
+    noKeyFacts: !s.priceText && !s.durationText && !s.category,
+    hideContent: isLoading || s.errored || !hasService,
+    // The session's own status still shows when the service has since closed online booking: the
+    // member's place, or the Agenda row's disabled Book with its reason.
+    hideFooter: isLoading || s.errored || !hasService || (!s.bookableOnline && !ownPlace && control !== "closed"),
+    emptyText: s.errored
+      ? copyParam("service.errorText", "Service details could not be loaded.")
+      : copyParam("service.emptyText", "This service is not available."),
+  };
+}
+
+function withService(s: S, service: WixService): S {
+  const body = descriptionBody(service.description);
+  const serviceId = stringOf(service.id) || s.id;
+  const name = stringOf(service.name) || "Service";
+  const price = priceLine(service);
+  const staff = staffLine(service);
+  const pay = payLine(service);
+  const isCourse = service.type === "COURSE";
+  const isClass = service.type === "CLASS";
+  // Ended, started without late joining, or outside the booking window: the same rule the time
+  // screen applies before it books (_shared/himi-bookings.ts).
+  const courseCtaClosed = isCourse && !courseWindowOpen(service, Date.now());
+  return derive({
+    ...s,
+    status: "ready",
+    errored: false,
+    id: serviceId,
+    name,
+    // Live payloads carry `category` as a structured object — extract the name
+    // (the list worker joins the same field; see _shared/himi-bookings.ts).
+    category: categoryName(service.category),
+    typeTag: isClass ? copyParam("service.tagClass", "Class") : isCourse ? copyParam("service.tagCourse", "Course") : "",
+    isClass,
+    isCourse,
+    tagline: stringOf(service.tagLine),
+    priceText: price.text,
+    priceUnit: price.unit,
+    priceIsText: price.isText,
+    images: serviceImages(service, name),
+    durationText: isCourse && durationText(service)
+      ? copyTemplate("service.durationEach", "{duration} each", { duration: durationText(service) })
+      : durationText(service),
+    courseDates: isCourse ? courseDates(service) : "",
+    courseSessionCount: "",
+    courseSessions: [],
+    courseMoreSessions: [],
+    spotsText: "",
+    spotsWarning: false,
+    scheduleExpanded: false,
+    courseCtaClosed,
+    courseCtaFull: false,
+    courseCtaBook: isCourse && !courseCtaClosed && service.onlineBooking?.requireManualApproval !== true,
+    courseCtaRequest: isCourse && !courseCtaClosed && service.onlineBooking?.requireManualApproval === true,
+    locations: locationRows(service),
+    online: service.conferencing?.enabled === true,
+    staffText: staff.text,
+    staffImage: staff.image,
+    staffInitials: staff.initials,
+    payText: pay.text,
+    paySub: pay.sub,
+    requestToBook: service.onlineBooking?.requireManualApproval === true,
+    bookableOnline: service.onlineBooking?.enabled !== false,
+    about: body.bodyText,
+    aboutJson: body.bodyJson,
+    hasAboutJson: body.bodyJson !== "",
+    policyLines: policyLines(service.bookingPolicy, stringOf(service.type).toUpperCase()),
+    shareUrl: serviceShareUrl(service),
+    // WS-C — canonical param-less target; the descriptor's choose-time CTA
+    // binds the separate `id` state field as a first-class nav param.
+    timeScreenId: "himi_time",
+    saved: savedNow(serviceId),
+  });
+}
+
+/** Whether the service is a favorite. Unreadable storage reads as not saved: the heart is a
+ *  convenience and never holds the screen back. */
+function savedNow(id: string): boolean {
+  try { return !!id && isServiceSaved(id); } catch { return false; }
+}
+
+/** The service record: with staff details when this token may read them, else without. */
+async function fetchService(id: string): Promise<WixService | undefined> {
+  try {
+    return (await getService(id, SERVICE_FIELDS)).service;
+  } catch {
+    // A visitor token that may not read STAFF_MEMBER_DETAILS must not lose the whole screen.
+    return (await getService(id)).service;
+  }
+}
+
+/** `{ index }` from a row tap, as a number (`$item.index` may arrive as a string). */
+function tappedIndex(arg: unknown): number {
+  const a = arg as { index?: unknown; args?: { index?: unknown } } | null | undefined;
+  return numberOf(a?.index ?? a?.args?.index) ?? -1;
+}
+
+const id = inputId();
+const svc = defineService<S, {
+  load: (s: S, arg?: unknown) => Promise<S>;
+  share: (s: S) => Promise<S>;
+  openLink: (s: S, arg?: unknown) => Promise<undefined>;
+  togglePolicy: (s: S) => S;
+  toggleSchedule: (s: S) => S;
+  openDirections: (s: S, arg?: unknown) => Promise<S>;
+  chooseTime: (s: S) => S;
+  book: (s: S) => S;
+  changeTime: (s: S) => S;
+  joinWaitlist: (s: S, arg?: unknown) => Promise<S>;
+  toggleSaved: (s: S) => S;
+}>("himiBookingService", {
+  // A join's outcome belongs to that visit: a cold start must not replay it from saved state.
+  notHydrated: ["sessionMessage", "sessionMessageOk", "sessionMessageFailed", "noSessionMessage", "saveMessage"],
+  state: derive({
+    status: "loading",
+    id,
+    name: "",
+    category: "",
+    noCategory: true,
+    typeTag: "",
+    noTypeTag: true,
+    isClass: false,
+    isCourse: false,
+    noCourse: true,
+    tagline: "",
+    noTagline: true,
+    priceText: "",
+    priceUnit: "",
+    priceIsText: false,
+    noPrice: true,
+    noPriceUnit: true,
+    noPriceAmount: true,
+    noPriceDescription: true,
+    priceA11y: "",
+    images: [],
+    image: "",
+    hasGallery: false,
+    noGallery: true,
+    hasOneImage: false,
+    noOneImage: true,
+    hasImage: false,
+    noImage: true,
+    durationText: "",
+    noDuration: true,
+    courseDates: "",
+    courseSessionCount: "",
+    noCourseDates: true,
+    spotsText: "",
+    noSpots: true,
+    spotsWarning: false,
+    spotsNeutral: true,
+    hideSpotsNeutral: true,
+    courseSessions: [],
+    noCourseSessions: true,
+    courseMoreSessions: [],
+    noCourseMoreSessions: true,
+    scheduleExpanded: false,
+    scheduleCollapsed: true,
+    courseCtaBook: false,
+    courseCtaRequest: false,
+    courseCtaFull: false,
+    courseCtaClosed: false,
+    hideChooseTime: false,
+    hideRequestTime: true,
+    noCourseCtaBook: true,
+    noCourseCtaRequest: true,
+    noCourseCtaFull: true,
+    noCourseCtaClosed: true,
+    locations: [],
+    noLocations: true,
+    online: false,
+    noOnline: true,
+    staffText: "",
+    staffImage: "",
+    staffInitials: "",
+    hasStaffImage: false,
+    noStaffImage: true,
+    noStaff: true,
+    payText: "",
+    paySub: "",
+    noPay: true,
+    noPaySub: true,
+    requestToBook: false,
+    notRequestToBook: true,
+    bookableOnline: true,
+    notBookableOnline: false,
+    about: "",
+    aboutJson: "",
+    hasAboutJson: false,
+    noAbout: true,
+    policyLines: [],
+    noPolicy: true,
+    policyExpanded: false,
+    policyCollapsed: true,
+    noFacts: true,
+    noKeyFacts: true,
+    hideContent: true,
+    hideFooter: true,
+    shareUrl: "",
+    timeScreenId: id ? "himi_time" : "himi_services", // WS-C canonical + `id` nav param
+    emptyText: "",
+    errored: false,
+    notErrored: true,
+    isLoading: true,
+    notLoading: false,
+    hasService: false,
+    noEmpty: true,
+    ...NO_SESSION,
+    noSession: true,
+    noSessionBook: true,
+    noSessionRequest: true,
+    noSessionWaitlist: true,
+    noSessionClosed: true,
+    noSessionBooked: true,
+    noSessionWaitlisted: true,
+    noChangeTime: true,
+    ...NO_SESSION_MESSAGE,
+    noSessionMessage: true,
+    saved: false,
+    notSaved: true,
+    saveLabel: "",
+    saveMessage: "",
+  }),
+  actions: {
+    load: async (s, arg) => {
+      stashCopy(arg);
+      rememberSignIn(arg);
+      if (!s.id) return derive({ ...s, status: "ready", errored: true });
+      // A new view: a join's outcome from before is not news when the screen shows again.
+      const start = { ...s, policyExpanded: false, scheduleExpanded: false, saveMessage: "", ...NO_SESSION_MESSAGE };
+      try {
+        const service = await fetchService(s.id);
+        if (!service) return withSession(derive({ ...start, status: "ready" }), undefined);
+        loadedService = service;
+        // The session the Agenda row opened on, read beside the service-wide availability.
+        const [shown, sel] = await Promise.all([withGroupAvailability(withService(start, service), service), readSessionBounded(service)]);
+        // The heart is read again after the waits (the session read takes up to 10 s): a toggle
+        // tapped meanwhile wrote storage, and the snapshot taken before would undo it.
+        return withSession({ ...shown, saved: savedNow(s.id) }, sel);
+      } catch {
+        // Offline: paint from the last-synced services cache (written by the list
+        // worker) before falling back to the error state. The cache holds the name,
+        // the category and one image; every other row stays hidden.
+        const cached = await readCached(s.id);
+        // No session state offline: the member's place in it cannot be read.
+        if (cached) {
+          const name = String(cached.name ?? "") || "Service";
+          const image = String(cached.image ?? "");
+          return withSession({
+            ...start,
+            status: "ready",
+            errored: false,
+            id: s.id,
+            name,
+            category: String(cached.category ?? ""),
+            images: image ? [{ url: image, alt: name }] : [],
+            timeScreenId: `himi_time_${s.id}`,
+            saved: savedNow(s.id),
+          }, undefined);
+        }
+        return withSession({ ...start, status: "ready", errored: true, name: "" }, undefined);
+      }
+    },
+    openLink: async (_state, arg) => { await openRichLink(arg); return undefined; },
+    share: async (s) => {
+      if (!s.name) return s;
+      const text = [s.name, s.tagline].filter(Boolean).join(" — ");
+      try {
+        await shareSheet({ subject: s.name, text, ...(s.shareUrl ? { url: s.shareUrl } : {}) });
+        return s;
+      } catch {
+        return s;
+      }
+    },
+    togglePolicy: (s) => derive({ ...s, policyExpanded: !s.policyExpanded }),
+    toggleSchedule: (s) => derive({ ...s, scheduleExpanded: !s.scheduleExpanded }),
+    // The heart: save or unsave this service on the device (the member's own list once signed
+    // in). The row keeps what the Favorites list shows offline; a failed write says so and never
+    // shows the heart as saved.
+    toggleSaved: (s) => {
+      if (!s.id || !s.hasService || s.errored) return s;
+      try {
+        const saved = toggleSavedService({
+          id: s.id,
+          name: s.name,
+          price: s.priceIsText ? "" : s.priceText,
+          duration: s.durationText,
+          image: s.image,
+          category: s.category,
+          ...(s.isCourse ? { course: true } : {}),
+        });
+        return derive({ ...s, saved, saveMessage: "" });
+      } catch {
+        return derive({ ...s, saved: savedNow(s.id), saveMessage: copyParam("service.saveError", "Could not update your favorites. Try again.") });
+      }
+    },
+    // The footer button opens the time screen for the loaded service. A worker directive,
+    // not a `himi.open` with a `$service:` id param: the iOS and Android sticky footers
+    // dispatch their taps without resolving `$service:` params, so the id never arrived.
+    chooseTime: (s) => (s.id && s.hasService ? navigate(s, { screenId: "himi_time", args: { id: s.id, ...(s.isCourse ? { course: "true" } : {}) } }) : s),
+    // Book the session the screen opened on: Choose Time opens with it picked — the Agenda row's
+    // own Book (`{ id, start, sessionId }`), so the member does not choose the time again.
+    book: (s) => (s.id && s.hasService && s.sessionControl === "book"
+      ? navigate(s, { screenId: "himi_time", args: { id: s.id, start: s.sessionStart, sessionId: s.sessionId } })
+      : s),
+    // "Change time": Choose Time for the service, with nothing picked.
+    changeTime: (s) => (s.id && s.hasService ? navigate(s, { screenId: "himi_time", args: { id: s.id } }) : s),
+    // Join the session's waitlist from here — the Agenda row's join: a visitor signs in first; the
+    // member's email and name are read, and the registration goes out only while the member is the
+    // one the session's place was read for. The screen then shows "On waitlist".
+    joinWaitlist: async (s, arg): Promise<S> => {
+      rememberSignIn(arg);
+      const sel = picked;
+      if (!sel || joining || s.sessionControl !== "waitlist" || !sel.session.sessionId) return s;
+      joining = true;
+      try {
+        const before = await memberAccess().catch(() => undefined);
+        if (!before?.email) {
+          joining = false;
+          // Without a sign-in screen, Choose Time opens on the session: it signs a guest in and
+          // joins the waitlist itself. A sign-in sheet only closes, and this screen loads again.
+          if (!signInScreenId) return navigate(s, { screenId: "himi_time", args: { id: s.id, start: s.sessionStart, sessionId: s.sessionId } });
+          return navigate(s, signInPresentation
+            ? { screenId: signInScreenId, presentation: signInPresentation, args: { mode: "signin", modal: "1" } }
+            : { screenId: signInScreenId, args: { mode: "signin" } });
+        }
+        const name = await memberName();
+        const current = await memberAccess().catch(() => undefined);
+        if (!sameMember(before, current) || !sameMember(sel.who, current)) {
+          // Another member since the load — or the load was a visitor's, whose place was never
+          // read: read the session again for whoever is signed in now; nothing is registered.
+          const reread = loadedService ? await readSession(loadedService) : undefined;
+          joining = false;
+          return withSession(svc.getState() as S, reread);
+        }
+        const res = await registerToWaitlist(sel.session.sessionId, { email: current!.email, ...name });
+        const place: MemberPlace = { bookingId: res?.booking?.id ?? "", revision: "", place: "waitlisted", registrationId: res?.registrationId, confirmed: false };
+        joining = false;
+        // Against the state as it is NOW; a load that landed meanwhile read this session again.
+        const now = svc.getState() as S;
+        return withSession({ ...now, sessionMessage: copyParam("agenda.joinedWaitlist", "You're on the waitlist."), sessionMessageOk: true, sessionMessageFailed: false },
+          { ...(picked?.session.key === sel.session.key ? picked : sel), place });
+      } catch {
+        joining = false;
+        return derive({ ...(svc.getState() as S), sessionMessage: copyParam("agenda.waitlistFailed", "Couldn't join the waitlist. Try again."), sessionMessageOk: false, sessionMessageFailed: true });
+      }
+    },
+    openDirections: async (s, arg) => {
+      const url = s.locations[tappedIndex(arg)]?.directionsUrl ?? "";
+      if (!url) return s;
+      try {
+        await open(url, defaultMode(url));
+      } catch {
+        // Nothing took the link; the screen stays as it was.
+      }
+      return s;
+    },
+  },
+});
+svc.load();
+export { svc };