@wix/himalaya-cli 0.1522.0 → 0.1524.0

package/templates/gym-fitness/tier5-src/_shared/himi-bookings.ts

@@ -65,3 +65,72 @@ export function slotIdAt(slots: Iterable<[string, { startDate?: string; timezone
   }
   return "";
 }
+
+// ---- Courses ----------------------------------------------------------------------
+// One answer for the service screen's course button and the time screen's course booking, so
+// the button never offers a course that the booking step then refuses.
+
+type CoursePolicyShape = {
+  schedule?: { id?: string; firstSessionStart?: string; lastSessionEnd?: string };
+  bookingPolicy?: {
+    bookAfterStartPolicy?: { enabled?: boolean };
+    limitEarlyBookingPolicy?: { enabled?: boolean; earliestBookingInMinutes?: number };
+    limitLateBookingPolicy?: { enabled?: boolean; latestBookingInMinutes?: number };
+  };
+};
+
+/** Whether the business takes course bookings at `now` (ms): the course has not ended, has not
+ *  started (unless the policy lets people join late), and `now` is inside its booking window —
+ *  which the early and late limits count from the first session. */
+export function courseWindowOpen(service: CoursePolicyShape, now: number): boolean {
+  const first = Date.parse(service.schedule?.firstSessionStart ?? "");
+  const last = Date.parse(service.schedule?.lastSessionEnd ?? "");
+  if (!Number.isFinite(first) || !Number.isFinite(last) || last <= now) return false;
+  const policy = service.bookingPolicy;
+  if (first < now && policy?.bookAfterStartPolicy?.enabled !== true) return false;
+  const early = policy?.limitEarlyBookingPolicy;
+  if (early?.enabled && typeof early.earliestBookingInMinutes === "number" && now < first - early.earliestBookingInMinutes * 60_000) return false;
+  const late = policy?.limitLateBookingPolicy;
+  if (late?.enabled && typeof late.latestBookingInMinutes === "number" && now > first - late.latestBookingInMinutes * 60_000) return false;
+  return true;
+}
+
+/** How far ahead a course is read: the whole remaining course, up to a year. Both screens read the
+ *  same sessions — from the later of its first session and now — so the service screen never
+ *  offers a course that the booking step then refuses on a session the first did not read. */
+export const COURSE_READ_DAYS = 366;
+const DAY = 86_400_000;
+
+/** The 14-day availability windows covering a course's remaining sessions, and whether they reach
+ *  its last session (`complete`) and start at its first (`fromFirst`, so a count is the whole
+ *  course). Empty when the course has no usable dates or has ended. */
+export function courseReadWindows(service: CoursePolicyShape, now: number, chunkDays = 14): { windows: Array<[number, number]>; complete: boolean; fromFirst: boolean } {
+  const first = Date.parse(service.schedule?.firstSessionStart ?? "");
+  const last = Date.parse(service.schedule?.lastSessionEnd ?? "");
+  if (!Number.isFinite(first) || !Number.isFinite(last)) return { windows: [], complete: false, fromFirst: false };
+  const from = Math.max(first, now);
+  const courseEnd = last + DAY;
+  const until = Math.min(courseEnd, from + COURSE_READ_DAYS * DAY);
+  const windows: Array<[number, number]> = [];
+  for (let at = from; at < until; at += chunkDays * DAY) windows.push([at, Math.min(until, at + chunkDays * DAY)]);
+  return { windows, complete: courseEnd <= until, fromFirst: from === first };
+}
+
+type CourseEntryShape = { slot?: { startDate?: string; timezone?: unknown }; bookable?: boolean; openSpots?: number };
+
+/** A course across EVERY upcoming session read: a customer books all of them at once, so the
+ *  smallest open count is the course's, and one session that cannot be booked closes it. A start
+ *  is read in the session's own zone (`slotStartInstant`). `found` is false when no upcoming
+ *  session came back: both screens then treat the course as not bookable. So is a course whose
+ *  read did not reach its last session (`readComplete`, from `courseReadWindows`): a session
+ *  past the year read may be full, and the course is booked whole. */
+export function courseSessionsAvailability(entries: readonly CourseEntryShape[], now: number, readComplete = true): { found: boolean; spots: number | undefined; bookable: boolean } {
+  const upcoming = entries.filter((entry) => {
+    const start = entry.slot ? slotStartInstant(entry.slot as { startDate?: string; timezone?: unknown }) : NaN;
+    return Number.isFinite(start) && start >= now;
+  });
+  if (!upcoming.length) return { found: false, spots: undefined, bookable: false };
+  const counts = upcoming.map((entry) => entry.openSpots).filter((n): n is number => typeof n === "number" && Number.isFinite(n) && n >= 0);
+  const spots = counts.length ? Math.min(...counts) : undefined;
+  return { found: true, spots, bookable: readComplete && upcoming.every((entry) => entry.bookable !== false) && spots !== 0 };
+}

package/templates/gym-fitness/tier5-src/_shared/himi-copy.ts

@@ -54,3 +54,12 @@ export function copyTemplate(key: string, fallback: string, values: Record<strin
     name in values ? String(values[name]) : "",
   );
 }
+
+/** The small ICU plural form used by Bookings spot counts. The provisioned copy may
+ *  translate both branches without adding a second key for the singular. */
+export function copyPlural(key: string, fallback: string, count: number): string {
+  const pattern = copyParam(key, fallback);
+  const match = /^\{n, plural, one \{([^{}]*)\} other \{([^{}]*)\}\}$/.exec(pattern);
+  if (!match) return copyTemplate(key, fallback, { n: count });
+  return (count === 1 ? match[1] : match[2])!.replace(/#/g, String(count));
+}

package/templates/gym-fitness/tier5-src/himi-booking-service/index.ts

@@ -2,12 +2,13 @@
 import { defineService, navigate } from "@himalaya/state";
 import { share as shareSheet } from "@himalaya/share";
 import { open, defaultMode } from "@himalaya/open-url";
-import { getService, type WixService, type WixServiceAddress, type WixServiceBookingPolicy } from "@himalaya/wix-bookings";
-import { categoryName } from "../_shared/himi-bookings.js";
+import { getService, queryServiceAvailability, type WixAvailabilityEntry, type WixService, type WixServiceAddress, type WixServiceBookingPolicy } from "@himalaya/wix-bookings";
+import { categoryName, courseReadWindows, courseSessionsAvailability, courseWindowOpen, slotStartInstant } from "../_shared/himi-bookings.js";
 import { formatServicePrice, formatServiceMoney, serviceCurrency } from "../_shared/wix-service-price.js";
-import { stashCopy, copyParam, copyTemplate } from "../_shared/himi-copy.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";
 
 // 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
@@ -35,6 +36,7 @@ interface LocationRow {
   a11y: string;
 }
 interface PolicyLine { text: string; owner: boolean; notOwner: boolean }
+interface CourseSession { date: string; time: string }
 
 interface S {
   status: "loading" | "ready";
@@ -43,6 +45,11 @@ interface S {
   /** 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. */
@@ -68,6 +75,30 @@ interface S {
   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;
@@ -146,7 +177,9 @@ function priceLine(service: WixService): PriceLine {
   const payment = service.payment ?? {};
   const rate = stringOf(payment.rateType).toUpperCase();
   const currency = serviceCurrency(service);
-  const unit = copyParam("service.unitSession", "per session");
+  const unit = service.type === "COURSE"
+    ? copyParam("service.unitParticipant", "per participant")
+    : copyParam("service.unitSession", "per session");
   if (rate === "NO_FEE") return { text: copyParam("service.priceFree", "Free"), unit: "", isText: false };
   if (rate === "CUSTOM") return { text: stringOf(payment.custom?.description), unit: "", isText: true };
   if (rate === "VARIED") {
@@ -363,10 +396,14 @@ function policyText(text: string): string {
 
 /** 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): PolicyLine[] {
+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);
@@ -374,14 +411,14 @@ function policyLines(policy: WixServiceBookingPolicy | undefined): PolicyLine[]
   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(copyTemplate("service.changeUntil", "Cancel or reschedule online up to {window} before the session starts.", { window: windowText(cancel.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(copyTemplate("service.cancelUntil", "Cancel online up to {window} before the session starts.", { window: windowText(cancel.minutes) }));
+    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(copyTemplate("service.rescheduleUntil", "Reschedule online up to {window} before the session starts.", { window: windowText(reschedule.minutes) }));
+    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."));
   }
@@ -395,22 +432,24 @@ function policyLines(policy: WixServiceBookingPolicy | undefined): PolicyLine[]
       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(copyTemplate("service.feeWindow", "Cancellations less than {window} before the session starts have a {fee} fee.", { window: windowText(start), 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(copyTemplate("service.bookingsOpen", "Bookings open {window} before the session starts.", { window: windowText(earliest) }));
+  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(copyTemplate("service.bookingsClose", "Bookings close {window} before the session starts.", { window: windowText(latest) }));
+  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;
 }
 
@@ -442,6 +481,120 @@ function plain(text: string | undefined): string {
     .trim();
 }
 
+// ---- 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 {
+  const first = validDate(service.schedule?.firstSessionStart);
+  const last = validDate(service.schedule?.lastSessionEnd);
+  if (!first || !last) return "";
+  return `${shortDate(first, first.getFullYear() !== last.getFullYear())} – ${shortDate(last, true)}`;
+}
+
+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;
+  }
+}
+
 // ---- State -----------------------------------------------------------------------
 
 function derive(s: S): S {
@@ -456,6 +609,8 @@ function derive(s: S): S {
     hasService,
     noEmpty: isLoading || s.errored || hasService,
     noCategory: !s.category,
+    noTypeTag: !s.typeTag,
+    noCourse: !s.isCourse,
     noTagline: !s.tagline,
     noPrice: !s.priceText,
     noPriceUnit: !s.priceUnit,
@@ -472,6 +627,13 @@ function derive(s: S): S {
     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,
@@ -480,11 +642,17 @@ function derive(s: S): S {
     noPay: !s.payText,
     noPaySub: !s.paySub,
     notRequestToBook: !s.requestToBook,
+    hideChooseTime: s.isCourse || s.requestToBook,
+    hideRequestTime: s.isCourse || !s.requestToBook,
+    noCourseCtaBook: !s.courseCtaBook,
+    noCourseCtaRequest: !s.courseCtaRequest,
+    noCourseCtaFull: !s.courseCtaFull,
+    noCourseCtaClosed: !s.courseCtaClosed,
     notBookableOnline: !s.bookableOnline,
     noAbout: !s.about,
     noPolicy: s.policyLines.length === 0,
     policyCollapsed: !s.policyExpanded,
-    noFacts: !s.durationText && s.locations.length === 0 && !s.online && !s.staffText && !s.payText,
+    noFacts: !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,
     hideFooter: isLoading || s.errored || !hasService || !s.bookableOnline,
@@ -500,6 +668,11 @@ function withService(s: S, service: WixService): S {
   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",
@@ -509,12 +682,28 @@ function withService(s: S, service: WixService): S {
     // 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: durationText(service),
+    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,
@@ -525,7 +714,7 @@ function withService(s: S, service: WixService): S {
     requestToBook: service.onlineBooking?.requireManualApproval === true,
     bookableOnline: service.onlineBooking?.enabled !== false,
     about: plain(service.description),
-    policyLines: policyLines(service.bookingPolicy),
+    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.
@@ -554,6 +743,7 @@ const svc = defineService<S, {
   load: (s: S, arg?: unknown) => Promise<S>;
   share: (s: S) => Promise<S>;
   togglePolicy: (s: S) => S;
+  toggleSchedule: (s: S) => S;
   openDirections: (s: S, arg?: unknown) => Promise<S>;
   chooseTime: (s: S) => S;
 }>("himiBookingService", {
@@ -563,6 +753,11 @@ const svc = defineService<S, {
     name: "",
     category: "",
     noCategory: true,
+    typeTag: "",
+    noTypeTag: true,
+    isClass: false,
+    isCourse: false,
+    noCourse: true,
     tagline: "",
     noTagline: true,
     priceText: "",
@@ -583,6 +778,30 @@ const svc = defineService<S, {
     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,
@@ -625,10 +844,10 @@ const svc = defineService<S, {
     load: async (s, arg) => {
       stashCopy(arg);
       if (!s.id) return derive({ ...s, status: "ready", errored: true });
-      const start = { ...s, policyExpanded: false };
+      const start = { ...s, policyExpanded: false, scheduleExpanded: false };
       try {
         const service = await fetchService(s.id);
-        return service ? withService(start, service) : derive({ ...start, status: "ready" });
+        return service ? withGroupAvailability(withService(start, service), service) : derive({ ...start, status: "ready" });
       } 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,
@@ -662,10 +881,11 @@ const svc = defineService<S, {
       }
     },
     togglePolicy: (s) => derive({ ...s, policyExpanded: !s.policyExpanded }),
+    toggleSchedule: (s) => derive({ ...s, scheduleExpanded: !s.scheduleExpanded }),
     // 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),
+    chooseTime: (s) => (s.id && s.hasService ? navigate(s, { screenId: "himi_time", args: { id: s.id, ...(s.isCourse ? { course: "true" } : {}) } }) : s),
     openDirections: async (s, arg) => {
       const url = s.locations[tappedIndex(arg)]?.directionsUrl ?? "";
       if (!url) return s;