@wix/himalaya-cli 0.1522.0 → 0.1523.0

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

@@ -5,7 +5,7 @@ import { defineService } from "@himalaya/state";
 // instant range, not a calendar day.
 import { addDays as addLocalDays, dayKey, dayLabel, timeLabel, toDate } from "@himalaya/time";
 import { dispatch } from "@himalaya/dispatch";
-import { bookSlot, getService, queryServiceAvailability, type WixBookingSlotFull } from "@himalaya/wix-bookings";
+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 { payCashierOrder } from "@himalaya/checkout";
@@ -13,11 +13,11 @@ import { hostedCheckoutOpener, isHostedWorker } from "../_shared/hosted-checkout
 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 } from "../_shared/himi-copy.js";
+import { stashCopy, copyParam, copyPlural } from "../_shared/himi-copy.js";
 import { upsert as dbUpsert, remove as dbRemove, enqueue as dbEnqueue, type DbEntity } from "@himalaya/local-db";
 import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
 import { emitHostEvent, hostEventInstant } from "../_shared/host-events.js";
-import { availabilityBeyond, slotIdAt } from "../_shared/himi-bookings.js";
+import { availabilityBeyond, courseReadWindows, courseSessionsAvailability, courseWindowOpen, slotIdAt } from "../_shared/himi-bookings.js";
 import { wixMediaUrl, WIX_DETAIL_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";
@@ -52,6 +52,12 @@ interface SlotRow {
   dayChip: string;
   title: string;
   subtitle: string;
+  badge: string;
+  noBadge: boolean;
+  badgeWarning: boolean;
+  badgeNeutral: boolean;
+  selectable: boolean;
+  notSelectable: boolean;
   selected: boolean;
   notSelected: boolean;
 }
@@ -72,6 +78,13 @@ interface S extends AttendancePurchaseFields {
    *  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[];
@@ -106,8 +119,17 @@ interface S extends AttendancePurchaseFields {
   /** #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;
@@ -135,6 +157,7 @@ interface DayOption {
 }
 
 let slotsById = new Map<string, WixBookingSlotFull>();
+let waitlistIds = new Set<string>();
 let regularCheckoutAllowed = false;
 let regularServicePrice = "";
 let lastReady: S | undefined;
@@ -150,6 +173,40 @@ let allRows: SlotRow[] = [];
 // bound that list needed is gone, and the availability query has no paging.
 const WINDOW_DAYS = 14;
 
+/** 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.
@@ -338,25 +395,35 @@ function derive(s: S): S {
   // 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 hasSelected = !!s.selectedSlotId;
+  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.isMember && hasSlots && !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 : "",
-    serviceLine: s.status === "ready" ? [s.serviceDuration, regular ? regularServicePrice : "", copyParam("time.availabilityWindow", "Available in the next 14 days")].filter(Boolean).join(" · ") : s.serviceLine,
+    // 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 : "", s.isCourse ? "" : copyParam("time.availabilityWindow", "Available in the next 14 days")].filter(Boolean).join(" · ") : s.serviceLine,
     message: regular && !regularCheckoutAllowed && s.message === copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") ? "" : s.message,
     hasSlots,
-    ...applePurchase.fields(hasSelected),
+    // 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,
-    hideSignIn: s.isMember || !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,
+    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.
     dayEmptyText: hasDaySlots || !s.selectedDay || !hasSlots
@@ -366,11 +433,18 @@ function derive(s: S): S {
     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 || !hasSlots,
+    hideDaySlots: s.isCourse || !hasDaySlots,
+    hideDayEmpty: s.isCourse || hasDaySlots,
     showChoosePrompt,
     hideChoosePrompt: !showChoosePrompt,
     isLoading: s.status === "loading",
     notLoading: s.status !== "loading",
-    noEmpty: s.status === "loading" || s.errored || hasSlots,
+    noEmpty: s.status === "loading" || s.errored || hasSlots || s.isCourse,
     notErrored: !s.errored,
     notMember: !s.isMember,
     notBooking: !s.bookingInFlight,
@@ -384,9 +458,11 @@ function derive(s: S): S {
     authTitle: isRegistering
       ? copyParam("time.authTitleRegister", "Create account to book")
       : copyParam("time.authTitle", "Sign in to book"),
-    authBody: 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."),
+    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;
@@ -533,6 +609,13 @@ const svc = defineService<S, {
     servicePrice: "",
     serviceDuration: "",
     serviceIsPaid: false,
+    coursePaymentOption: "",
+    courseAvailable: false,
+    isCourse: false,
+    notCourse: true,
+    scheduleId: "",
+    courseStart: "",
+    courseEnd: "",
     days: [],
     selectedDay: "",
     selectedDayLabel: "",
@@ -557,8 +640,17 @@ const svc = defineService<S, {
     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,
@@ -596,26 +688,83 @@ const svc = defineService<S, {
       try {
         const now = new Date();
         const beyond = availabilityBeyond(now, farStart);
-        const [serviceRes, availability, target] = await Promise.all([
-          getService(s.id).catch(() => ({ service: undefined })),
-          queryServiceAvailability(s.id, isoDate(now), isoDate(new Date(now.getTime() + WINDOW_DAYS * 86_400_000))),
+        const serviceRes = await getService(s.id).catch(() => ({ service: undefined }));
+        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 [availability, target] = await Promise.all([
+          queryServiceAvailability(s.id, isoDate(now), isoDate(new Date(now.getTime() + WINDOW_DAYS * 86_400_000)), { 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)).catch(() => ({ availabilityEntries: [] })) : undefined,
+          beyond ? queryServiceAvailability(s.id, isoDate(beyond.from), isoDate(beyond.until), { bookable: !includeFull }).catch(() => ({ availabilityEntries: [] })) : undefined,
         ]);
         slotsById = new Map();
+        waitlistIds = new Set();
         const rows: SlotRow[] = [];
         // 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 = serviceRes.service?.type === "CLASS";
         for (const [index, entry] of [...(availability.availabilityEntries ?? []), ...(target?.availabilityEntries ?? [])]
-          .filter((candidate) => candidate.bookable !== false && candidate.slot?.startDate)
+          .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 slotId = String(slot.sessionId ?? slot.startDate ?? `slot-${index}`);
-          slotsById.set(slotId, slot);
+          const openSpots = classService && typeof entry.openSpots === "number" && entry.openSpots >= 0 ? entry.openSpots : undefined;
+          const waitlist = openSpots === 0 && serviceRes.service?.bookingPolicy?.waitlistPolicy?.enabled === true &&
+            typeof entry.waitingList?.openSpots === "number" && entry.waitingList.openSpots > 0;
+          const selectable = (entry.bookable !== false && openSpots !== 0) || waitlist;
+          if (waitlist) waitlistIds.add(slotId);
+          else if (selectable) slotsById.set(slotId, slot);
           const label = fmtRange(slot.startDate, slot.endDate);
           rows.push({
             id: slotId,
@@ -624,6 +773,14 @@ const svc = defineService<S, {
             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)
+              : waitlist ? 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,
           });
@@ -642,13 +799,13 @@ const svc = defineService<S, {
         // 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)
-          : rows.find((r) => r.id === slotIdAt(slotsById, wantedStart));
+          : 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);
+        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));
+        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);
@@ -674,6 +831,7 @@ const svc = defineService<S, {
         }, initialDay));
       } catch {
         slotsById = new Map();
+        waitlistIds = new Set();
         allRows = [];
         return derive({ ...next, status: "ready", errored: true, days: [], selectedDay: "", selectedDayLabel: "", slots: [] });
       }
@@ -694,7 +852,7 @@ const svc = defineService<S, {
       const slotId = typeof arg === "string"
         ? arg
         : ((arg as { id?: string; slotId?: string })?.slotId ?? (arg as { id?: string })?.id ?? "");
-      const selected = allRows.find((slot) => slot.id === slotId);
+      const selected = allRows.find((slot) => slot.id === slotId && slot.selectable);
       if (selected) {
         selectionRevision++;
         pendingStart = "";
@@ -729,7 +887,9 @@ const svc = defineService<S, {
           firstName: "",
           lastName: "",
           isRegistering: false,
-          message: copyParam("time.signedInReady", "Signed in. You can book this time now."),
+          message: s.isCourse
+            ? copyParam("time.courseSignedInReady", "Signed in. You can book this course now.")
+            : copyParam("time.signedInReady", "Signed in. You can book this time now."),
         });
       } catch {
         return derive({ ...s, password: "", message: copyParam("time.signInFailed", "Sign in failed. Try again.") });
@@ -752,7 +912,9 @@ const svc = defineService<S, {
           firstName: "",
           lastName: "",
           isRegistering: false,
-          message: copyParam("time.registerReady", "Account created. You can book this time now."),
+          message: s.isCourse
+            ? copyParam("time.courseRegisterReady", "Account created. You can book this course now.")
+            : copyParam("time.registerReady", "Account created. You can book this time now."),
         });
       } catch {
         return derive({ ...s, password: "", message: copyParam("time.registerFailed", "Account creation failed. Try another email.") });
@@ -760,17 +922,26 @@ const svc = defineService<S, {
     },
     bookSelected: async (s) => {
       if (!s.isMember) return derive({ ...s, message: copyParam("time.bookNeedsSignIn", "Sign in before booking.") });
-      if (!s.selectedSlotId) return derive({ ...s, message: copyParam("time.bookNeedsSlot", "Choose one time first.") });
-      const slot = slotsById.get(s.selectedSlotId);
-      if (!slot) return derive({ ...s, message: copyParam("time.bookSlotGone", "That time is no longer available. Try again.") });
-      try {
-        const current = await getService(s.id);
-        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 (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.") });
       }
-      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
@@ -779,12 +950,28 @@ const svc = defineService<S, {
         bookingId: booking?.id,
         serviceId: s.id,
         serviceName: s.serviceName,
-        start: hostEventInstant(booking?.startDate) || slot.startDate,
-        end: hostEventInstant(booking?.endDate) || slot.endDate,
+        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();
-      // PAID service — FULLY NATIVE in-app payment (mirrors Wix's RN apps): NO
+      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)
@@ -792,17 +979,39 @@ const svc = defineService<S, {
       // (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) {
+      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).
-          const created = await bookSlot(slot, payerName.first, payerName.last, payerEmail);
+          //    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 } },
@@ -816,10 +1025,14 @@ const svc = defineService<S, {
           // 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 && !hosted) {
+          if ((!snapshotId || (s.isCourse && s.coursePaymentOption === "OFFLINE")) && !hosted) {
+            pendingCourseBooking = null;
             await reportBooked(created.booking);
-            return derive({ ...pending, bookingInFlight: false, successMessage: copyParam("time.successMessage", "Booked. Your confirmation is ready in My Bookings."), message: "" });
+            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
@@ -833,13 +1046,14 @@ const svc = defineService<S, {
             // Hosted (Spaces): the host opens this booking's checkout as the lent member.
             ...(hosted ? { openCashier: hostedCheckoutOpener(checkoutId) } : {}),
             cashierUrl: async () => {
-              const redirect = await createRedirectSession({
-                bookingsCheckout: { slotAvailability: { slot: slot as unknown as WixSlot } },
-              });
+              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: "" });
           }
@@ -849,14 +1063,20 @@ const svc = defineService<S, {
             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: copyParam("time.paymentCancelled", "Payment cancelled — your booking wasn't confirmed. Pick a time to try again.") });
+            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.") });
           }
-          return derive({ ...s, bookingInFlight: false, message: copyParam("time.paymentFailed", "Payment couldn't be completed. Pick another time or try again.") });
+          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 {
-          return derive({ ...s, bookingInFlight: false, message: copyParam("time.checkoutFailed", "Checkout could not start. Pick another time or try again.") });
+          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 service — the original member bookSlot rung (offline-safe below).
+      // 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.
@@ -869,13 +1089,13 @@ const svc = defineService<S, {
       const localRow = (id: string): DbEntity => ({
         id,
         title: s.serviceName || "Booking",
-        subtitle: selectedSlot?.title || "Booked time",
+        subtitle: s.isCourse ? (s.selectedLine || "Full course") : (selectedSlot?.title || "Booked time"),
         status: "Booked",
       });
       await cachePut(localRow(localId));
       const pending = derive({ ...s, bookingInFlight: true, message: "", successMessage: "" });
       try {
-        const created = await bookSlot(slot, name.first, name.last, email);
+        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 (realId && realId !== localId) { await cacheDrop(localId); await cachePut(localRow(realId)); }
@@ -893,11 +1113,11 @@ const svc = defineService<S, {
           // connectivity returns.
           await queueWrite("tier5.himiBookingTime.bookSelected", {
             serviceId: s.id,
-            slotId: s.selectedSlotId,
+            ...(s.isCourse ? { scheduleId: s.scheduleId } : { slotId: s.selectedSlotId }),
             email,
             firstName: name.first,
             lastName: name.last,
-            slot: JSON.stringify(slot),
+            ...(slot ? { slot: JSON.stringify(slot) } : {}),
           });
           return derive({
             ...pending,
@@ -906,7 +1126,9 @@ const svc = defineService<S, {
             message: "",
           });
         }
-        return derive({ ...s, bookingInFlight: false, message: copyParam("time.bookFailed", "Booking failed. Pick another time or try again.") });
+        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.") });
       }
     },
   },

package/templates/gym-fitness-owner/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/himi-chat/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/nonprofit-cause/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));
+}