@wix/himalaya-cli 0.1495.0 → 0.1497.0

package/templates/branded-lite/tier5-src/himi-booking-time/index.ts

@@ -19,6 +19,9 @@ 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 { 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";
+import { resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
 
 // Offline-first (data-offline): booking a slot is WRITE-BEHIND against the
 // `member_bookings` entity (the same rows the My Bookings worker reads). The
@@ -53,7 +56,7 @@ interface SlotRow {
   notSelected: boolean;
 }
 
-interface S {
+interface S extends AttendancePurchaseFields {
   status: "loading" | "ready";
   id: string;
   serviceName: string;
@@ -132,6 +135,10 @@ interface DayOption {
 }
 
 let slotsById = new Map<string, WixBookingSlotFull>();
+let regularCheckoutAllowed = false;
+let regularServicePrice = "";
+let lastReady: S | undefined;
+const applePurchase = createAttendancePurchase({ kind: "bookingsService", prefix: "time", pollAction: "himiBookingTime.iapPoll", onChange: () => { void svc.iapPublish(); } });
 /** Every slot row in the window, across all days. Kept out of worker state so
  *  the state the host receives holds one day's rows, not the whole window. */
 let allRows: SlotRow[] = [];
@@ -326,18 +333,24 @@ function withDay(s: S, day: string): S {
 }
 
 function derive(s: S): S {
+  const regular = regularCheckoutAllowed || applePurchase.usesRegularPlatform();
   // `hasSlots` is the WHOLE window (it drives the screen-level empty state); the
   // selected day having none is a per-day line, not an empty screen.
   const hasSlots = s.days.some((d) => d.hasSlots) || s.slots.length > 0;
   const hasDaySlots = s.slots.length > 0;
   const hasSelected = !!s.selectedSlotId;
   const hasSuccess = !!s.successMessage;
-  const canBook = s.isMember && hasSelected && !s.bookingInFlight && !hasSuccess;
-  const showChoosePrompt = s.isMember && hasSlots && !hasSelected && !s.bookingInFlight && !hasSuccess;
+  const canBook = regular && s.isMember && hasSelected && !s.bookingInFlight && !hasSuccess;
+  const showChoosePrompt = regular && s.isMember && hasSlots && !hasSelected && !s.bookingInFlight && !hasSuccess;
   const isRegistering = !!s.isRegistering;
-  return {
+  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,
+    message: regular && !regularCheckoutAllowed && s.message === copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable.") ? "" : s.message,
     hasSlots,
+    ...applePurchase.fields(hasSelected),
     hasSelected,
     noSelected: !hasSelected,
     hideSignIn: s.isMember || !hasSelected,
@@ -375,6 +388,8 @@ function derive(s: S): S {
       ? copyParam("time.authBodyRegister", "Create a member account, then book the selected time on this screen.")
       : copyParam("time.authBody", "You can browse times as a visitor. Booking is saved to a member account."),
   };
+  if (next.status === "ready") lastReady = next;
+  return next;
 }
 
 async function probeMember(s: S): Promise<S> {
@@ -499,8 +514,15 @@ const svc = defineService<S, {
   signIn: (s: S) => Promise<S>;
   register: (s: S) => Promise<S>;
   bookSelected: (s: S) => Promise<S>;
+  buyApple: (s: S) => Promise<S>;
+  setIapField: (s: S, arg?: unknown) => S;
+  iapPublish: (s: S) => S;
+  iapRefresh: (s: S) => Promise<S>;
+  iapPoll: (s: S) => Promise<S>;
 }>("himiBookingTime", {
+  notHydrated: [...ATTENDANCE_NOT_HYDRATED, "email", "password", "firstName", "lastName", "isMember", "canBook", "cannotBook"],
   state: derive({
+    ...ATTENDANCE_INITIAL,
     status: "loading",
     id,
     serviceName: "Choose a time",
@@ -555,6 +577,16 @@ const svc = defineService<S, {
     bookingsScreenId: "himi_bookings",
   }),
   actions: {
+    iapPublish: (s) => derive(lastReady ?? s),
+    iapRefresh: async (): Promise<S> => { await applePurchase.refresh(); return derive(svc.getState()); },
+    iapPoll: async (): Promise<S> => { await applePurchase.poll(); return derive(svc.getState()); },
+    setIapField: (s, arg) => { applePurchase.change(arg); return derive(s); },
+    buyApple: async (s: S): Promise<S> => {
+      const slot = slotsById.get(s.selectedSlotId);
+      if (!slot || !s.isMember) return derive(s);
+      await applePurchase.buy({ key: s.selectedSlotId, slot: slot as unknown as Record<string, unknown> });
+      return derive(svc.getState());
+    },
     load: async (s, arg): Promise<S> => {
       const revisionAtStart = selectionRevision;
       stashCopy(arg);
@@ -598,6 +630,10 @@ const svc = defineService<S, {
         }
         allRows = rows;
         const days = daysOf(rows);
+        const header = serviceHeaderFields(serviceRes.service);
+        regularServicePrice = header.price;
+        regularCheckoutAllowed = await mayUseRegularBookingCheckout(serviceRes.service);
+        await applePurchase.booking(s.id, serviceRes.service);
         // A reload runs in the background when the screen shows again. A time the customer
         // picked while it ran wins over the selection this load started from.
         const chosen: S = selectionRevision !== revisionAtStart ? (svc.getState?.() ?? next) : next;
@@ -617,7 +653,6 @@ const svc = defineService<S, {
         // otherwise open on the first day that has any.
         const keep = days.find((d) => d.id === chosen.selectedDay && d.hasSlots);
         const initialDay = startRow?.dayKey ?? startDay?.id ?? picked?.dayKey ?? keep?.id ?? days.find((d) => d.hasSlots)?.id ?? days[0]?.id ?? "";
-        const header = serviceHeaderFields(serviceRes.service);
         return derive(withDay({
           ...next,
           days,
@@ -628,13 +663,14 @@ const svc = defineService<S, {
           status: "ready",
           errored: false,
           serviceName: serviceRes.service?.name || copyParam("time.serviceNameFallback", "Choose a time"),
-          serviceLine: [header.duration, header.price, copyParam("time.availabilityWindow", "Available in the next 14 days")].filter(Boolean).join(" · "),
+          serviceLine: [header.duration, regularCheckoutAllowed ? header.price : "", copyParam("time.availabilityWindow", "Available in the next 14 days")].filter(Boolean).join(" · "),
           serviceImage: header.image,
           hasServiceImage: !!header.image,
           noServiceImage: !header.image,
-          servicePrice: header.price,
+          servicePrice: regularCheckoutAllowed ? header.price : "",
           serviceDuration: header.duration,
           serviceIsPaid: header.paid,
+          message: regularCheckoutAllowed || !applePurchase.fields(true, false).iapBuyHidden ? "" : copyParam("time.purchaseUnavailable", "Purchasing is temporarily unavailable."),
         }, initialDay));
       } catch {
         slotsById = new Map();
@@ -727,6 +763,14 @@ const svc = defineService<S, {
       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 (!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
@@ -867,5 +911,6 @@ const svc = defineService<S, {
     },
   },
 });
+resetUnhydratedKeysOnOlderRuntime(svc, { ...svc.getState(), ...ATTENDANCE_INITIAL, email: "", password: "", firstName: "", lastName: "", isMember: false, canBook: false, cannotBook: true }, [...ATTENDANCE_NOT_HYDRATED, "email", "password", "firstName", "lastName", "isMember", "canBook", "cannotBook"]);
 svc.load();
 export { svc };

package/templates/branded-lite/tier5-src/himi-events-detail/index.ts

@@ -36,6 +36,23 @@ import {
 } from "../_shared/himi-events";
 import { initials } from "../_shared/himi-text.js";
 import { hostedSitePageOpener, isHostedWorker } from "../_shared/hosted-checkout.js";
+import { mayUseRegularTicketCheckout } from "../_shared/iap-attendance.js";
+import { ATTENDANCE_INITIAL, ATTENDANCE_NOT_HYDRATED, createAttendancePurchase, type AttendancePurchaseFields } from "../_shared/iap-attendance-purchase.js";
+import { resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
+
+let ticketCheckoutAllowed = false;
+let paymentEvent: unknown;
+let paymentTickets = new Map<string, WixAvailableTicket>();
+let ticketSelectionVersion = 0;
+let lastReady: S | undefined;
+const applePurchase = createAttendancePurchase({ kind: "eventsTicket", prefix: "event", pollAction: "himiEventDetail.iapPoll", onChange: () => { void svc.iapPublish(); } });
+
+async function priceTicket(event: unknown, id: string, version: number): Promise<boolean> {
+  const available = paymentTickets.get(id);
+  if (version !== ticketSelectionVersion) return false;
+  await applePurchase.ticket(id, event, available);
+  return version === ticketSelectionVersion;
+}
 
 /** A hosted signed-in event-page open is in flight (see openRegistration). */
 let hostedOpenInFlight = false;
@@ -88,7 +105,7 @@ async function writeCachedRow(row: EventRow): Promise<void> {
   try { await upsert(ENTITY, row as unknown as DbEntity); } catch { /* capability not granted → online-only */ }
 }
 
-interface S {
+interface S extends AttendancePurchaseFields {
   status: "loading" | "ready";
   id: string;
   title: string;
@@ -139,6 +156,8 @@ interface S {
   /** The tier the CTA will reserve. Defaults to the cheapest on-sale tier so the
    *  button is never dead, and follows the buyer's tap after that. */
   selectedTierId: string;
+  ticketPurchaseBlocked: boolean;
+  regularTicketsHidden: boolean;
   /** "General · $25" — echoed next to the CTA so the choice is visible. */
   selectedTierLabel: string;
   /** External/ticketed registration URL when the payload carries one. */
@@ -179,7 +198,7 @@ function tierPrice(t: WixAvailableTicket): string {
 }
 
 function tierAvailable(t: WixAvailableTicket): boolean {
-  return !!t.id && !/SALE_ENDED|CANCELED|SOLD_OUT/i.test(t.saleStatus ?? "");
+  return !!t.id && !/SALE_SCHEDULED|SALE_ENDED|CANCELED|SOLD_OUT/i.test(t.saleStatus ?? "");
 }
 
 /** Map the buyer-visible tiers onto rows, cheapest first (so the default pick is
@@ -205,26 +224,36 @@ function tierRows(defs: WixAvailableTicket[], selectedId: string): TicketTierRow
 }
 
 /** Best-effort tier read — never sinks the screen if the tier endpoint fails. */
-async function loadTiers(eventId: string): Promise<TicketTierRow[]> {
+async function loadTiers(eventId: string): Promise<{ rows: TicketTierRow[]; tickets: Map<string, WixAvailableTicket> }> {
   try {
     const response = await queryAvailableTickets(eventId);
     const defs = response.definitions ?? [];
+    const tickets = new Map(defs.filter((t) => t.id).map((t) => [t.id!, t]));
     const cheapestAvailable = defs
       .filter(tierAvailable)
       .slice()
       .sort((a, b) => Number(a.price?.amount ?? 0) - Number(b.price?.amount ?? 0))[0];
-    return tierRows(defs, cheapestAvailable?.id ?? "");
+    return { rows: tierRows(defs, cheapestAvailable?.id ?? ""), tickets };
   } catch {
-    return [];
+    return { rows: [], tickets: new Map() };
   }
 }
 
 function derive(s: S): S {
+  const regular = ticketCheckoutAllowed || applePurchase.usesRegularPlatform();
   const hasContent = !!s.title;
   const hasMapMarkers = s.mapMarkers.length > 0;
   const hasAttendees = s.attendeeAvatars.length > 0;
-  return {
+  const purchase = applePurchase.fields(!!s.selectedTierId);
+  const tiers = s.ticketTiers.map((t) => ({ ...t, priceLine: regular ? tierPrice(paymentTickets.get(t.id) ?? {}) : t.id === s.selectedTierId ? purchase.iapPrice : "" }));
+  const next = {
     ...s,
+    _poll: undefined,
+    ...purchase,
+    actionMessage: regular && !ticketCheckoutAllowed && s.actionMessage === copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") ? "" : s.actionMessage,
+    ticketTiers: tiers,
+    regularTicketsHidden: s.registrationKind !== "tickets" || !purchase.iapBuyHidden,
+    ticketPurchaseBlocked: s.registrationKind === "tickets" && !regular,
     hasDescriptionJson: s.descriptionJson !== "",
     noMap: !s.mapUrl,
     hasMapMarkers,
@@ -239,8 +268,8 @@ function derive(s: S): S {
     showTierPicker: s.ticketTiers.length > 1,
     hideTierPicker: s.ticketTiers.length <= 1,
     selectedTierLabel: (() => {
-      const picked = s.ticketTiers.find((t) => t.id === s.selectedTierId);
-      return picked ? `${picked.name} · ${picked.priceLine}` : "";
+      const picked = tiers.find((t) => t.id === s.selectedTierId);
+      return picked ? [picked.name, picked.priceLine].filter(Boolean).join(" · ") : "";
     })(),
     showTickets: s.registrationKind === "tickets",
     hideTickets: s.registrationKind !== "tickets",
@@ -256,6 +285,8 @@ function derive(s: S): S {
         ? copyParam("event.errorText", "Event could not be loaded.")
         : copyParam("event.notFoundText", "Event not found.")),
   };
+  if (next.status === "ready") lastReady = next;
+  return next;
 }
 
 function calendarStamp(ms: number): string {
@@ -288,7 +319,7 @@ function calendarFallbackUrl(s: S, end: number): string {
 
 /** The Events v3 fieldsets the detail reads (see `WixEventFieldset`). DETAILS carries mainImage and
  *  shortDescription: REGISTRATION fills eventType, which skips the query enrichment that used to supply them. */
-export const EVENT_DETAIL_FIELDSETS: WixEventFieldset[] = ["DETAILS", "TEXTS", "REGISTRATION", "URLS"];
+export const EVENT_DETAIL_FIELDSETS: WixEventFieldset[] = ["DETAILS", "TEXTS", "REGISTRATION", "URLS", "FORM"];
 
 /** Map the decoded registration/eventType onto the CTA variant. The decoded
  *  `eventType` already folds registration.type / registration.initialType /
@@ -401,16 +432,23 @@ async function enrichRegistration(id: string, e: WixEvent): Promise<WixEvent> {
 }
 
 const svc = defineService<S, {
-  load: (s: S, arg?: unknown) => Promise<S>;
+  load: (s: S, arg?: unknown) => Promise<S | undefined>;
   openMap: (s: S) => Promise<S>;
-  selectTier: (s: S, arg?: unknown) => Promise<S>;
+  selectTier: (s: S, arg?: unknown) => Promise<S | undefined>;
   openRegistration: (s: S) => Promise<S>;
   share: (s: S) => Promise<S>;
   addToCalendar: (s: S) => Promise<S>;
   /** [rico] #3372 — RichContent's on_link: `{ url }` of the tapped link. */
   openLink: (s: S, arg?: unknown) => Promise<S>;
+  buyApple: (s: S) => Promise<S>;
+  setIapField: (s: S, arg?: unknown) => S;
+  iapPublish: (s: S) => S;
+  iapRefresh: (s: S) => Promise<S>;
+  iapPoll: (s: S) => Promise<S>;
 }>("himiEventDetail", {
+  notHydrated: [...ATTENDANCE_NOT_HYDRATED, "ticketPurchaseBlocked"],
   state: derive({
+    ...ATTENDANCE_INITIAL,
     status: "loading",
     id: inputId(),
     title: "",
@@ -433,6 +471,8 @@ const svc = defineService<S, {
     hasAttendees: false,
     noAttendees: true,
     registrationKind: "rsvp",
+    ticketPurchaseBlocked: true,
+    regularTicketsHidden: true,
     showRsvp: true,
     hideRsvp: false,
     showTickets: false,
@@ -462,7 +502,19 @@ const svc = defineService<S, {
     noEmpty: true,
   }),
   actions: {
-    load: async (s, arg) => {
+    iapPublish: (s) => derive(lastReady ?? s),
+    iapRefresh: async (): Promise<S> => { await applePurchase.refresh(); return derive(svc.getState()); },
+    iapPoll: async (): Promise<S> => { await applePurchase.poll(); return derive(svc.getState()); },
+    setIapField: (s, arg) => { applePurchase.change(arg); return derive(s); },
+    buyApple: async (s: S): Promise<S> => {
+      if (!s.selectedTierId || !s.ticketTiers.some((t) => t.id === s.selectedTierId && t.available)) return derive(s);
+      await applePurchase.buy({ key: s.selectedTierId, eventId: s.id });
+      return derive(svc.getState());
+    },
+    load: async (s: S, arg?: unknown): Promise<S | undefined> => {
+      const selectionVersion = ++ticketSelectionVersion;
+      ticketCheckoutAllowed = false;
+      applePurchase.invalidate();
       stashCopy(arg);
       const id = s.id || inputId();
       if (!id) return derive({ ...s, status: "ready", errored: true });
@@ -479,7 +531,15 @@ const svc = defineService<S, {
         // screen BEFORE the CTA is tapped. Best-effort: a tier read that fails
         // leaves the picker collapsed and the CTA falls back to its own read.
         const kind = registrationKindOf(e);
-        const tiers = kind === "tickets" ? await loadTiers(id) : [];
+        const loaded = kind === "tickets" ? await loadTiers(id) : { rows: [], tickets: new Map<string, WixAvailableTicket>() };
+        const tiers = loaded.rows;
+        const selectedTierId = tiers.find((t) => t.isSelected)?.id ?? tiers.find((t) => t.available)?.id ?? "";
+        const regular = kind !== "tickets" || await mayUseRegularTicketCheckout(e, loaded.tickets.get(selectedTierId));
+        if (selectionVersion !== ticketSelectionVersion) return undefined;
+        paymentEvent = e;
+        paymentTickets = loaded.tickets;
+        ticketCheckoutAllowed = regular;
+        if (kind === "tickets" && !await priceTicket(e, selectedTierId, selectionVersion)) return undefined;
         // Write-through: cache the fetched row (same EventRow shape as the list) so a
         // later offline open of this detail can fall back to it.
         await writeCachedRow(normalizeEvent(e));
@@ -493,7 +553,7 @@ const svc = defineService<S, {
           ticketTiers: tiers,
           // Default the pick to the cheapest AVAILABLE tier so the CTA is never
           // dead; the buyer's tap overrides it from there.
-          selectedTierId: tiers.find((t) => t.available)?.id ?? "",
+          selectedTierId,
           title,
           initial: (title.trim()[0] || "E").toUpperCase(),
           when: eventWhen(e),
@@ -514,11 +574,12 @@ const svc = defineService<S, {
           shareUrl: eventPageUrlOf(e),
           calendarStart: eventStartMillis(e) ?? 0,
           calendarEnd: eventEndMillis(e) ?? 0,
-          actionMessage: "",
+          actionMessage: ticketCheckoutAllowed || !applePurchase.fields(true, false).iapBuyHidden ? "" : copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable."),
           statusLabel: titleCase(e.eventStatus) || titleCase((e as unknown as { status?: string }).status),
         });
       } catch {
         // Offline / fetch failure: fall back to the last-synced cached row before erroring.
+        if (selectionVersion !== ticketSelectionVersion) return undefined;
         const cached = await readCachedRow(id);
         if (cached) {
           const title = cached.title || "Event";
@@ -552,22 +613,46 @@ const svc = defineService<S, {
         return derive({ ...s, actionMessage: copyParam("event.mapOpenFailed", "Could not open maps on this device.") });
       }
     },
-    selectTier: async (s, arg) => {
+    selectTier: async (s: S, arg?: unknown): Promise<S | undefined> => {
       const id = typeof arg === "string" ? arg : (arg as { id?: unknown } | undefined)?.id;
       const wanted = typeof id === "string" ? id : "";
       const tier = s.ticketTiers.find((t) => t.id === wanted);
       // Ignore a tap on an off-sale row rather than letting the CTA promise a
       // ticket it cannot reserve.
       if (!tier || !tier.available) return s;
+      const selectionVersion = ++ticketSelectionVersion;
+      ticketCheckoutAllowed = false;
+      applePurchase.invalidate();
+      const regular = await mayUseRegularTicketCheckout(paymentEvent, paymentTickets.get(wanted));
+      if (selectionVersion !== ticketSelectionVersion) return undefined;
+      ticketCheckoutAllowed = regular;
+      if (!await priceTicket(paymentEvent, wanted, selectionVersion)) return undefined;
       return derive({
         ...s,
         selectedTierId: wanted,
         ticketTiers: s.ticketTiers.map((t) => ({ ...t, isSelected: t.id === wanted, notSelected: t.id !== wanted })),
         // A new pick invalidates whatever the last attempt said.
-        actionMessage: "",
+        actionMessage: ticketCheckoutAllowed || !applePurchase.fields(true, false).iapBuyHidden ? "" : copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable."),
       });
     },
-    openRegistration: async (s) => {
+    openRegistration: async (s): Promise<S> => {
+      let eventPageAllowed = true;
+      let checkoutEvent: WixEvent | undefined;
+      if (s.registrationKind === "tickets") {
+        try {
+          const current = await getEvent(s.id, { fields: EVENT_DETAIL_FIELDSETS });
+          const event = ((current as unknown as { event?: WixEvent }).event ?? current) as WixEvent;
+          checkoutEvent = event;
+          eventPageAllowed = await mayUseRegularTicketCheckout(event, undefined);
+          ticketCheckoutAllowed = eventPageAllowed;
+          if (!ticketCheckoutAllowed) {
+            const tickets = await queryAvailableTickets(s.id);
+            const selected = (tickets.definitions ?? []).find((ticket) => ticket.id === s.selectedTierId);
+            ticketCheckoutAllowed = await mayUseRegularTicketCheckout(event, selected);
+          }
+          if (!ticketCheckoutAllowed) return derive({ ...s, actionMessage: copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+        } catch { return derive({ ...s, actionMessage: copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") }); }
+      }
       // Phase 2c — NATIVE ticket purchase. Reserve the cheapest available tier,
       // turn the hold into an order, then settle it on the shared in-app pay rail
       // (@wix/himalaya/checkout): wallet where the app has one, in-app Wix cashier
@@ -598,9 +683,12 @@ const svc = defineService<S, {
           // picker is collapsed.
           const tickets = await queryAvailableTickets(s.id);
           const live = (tickets.definitions ?? []).filter(tierAvailable);
-          const tier = live.find((t) => t.id === s.selectedTierId)
-            // The pick went off-sale (or we never had one) ⇒ cheapest available.
-            ?? live.slice().sort((a, b) => Number(a.price?.amount ?? 0) - Number(b.price?.amount ?? 0))[0];
+          // A recovered first read must show the offer before it can be sold.
+          if (live.length > 0 && !s.selectedTierId && s.ticketTiers.length === 0) return svc.load();
+          const tier = live.find((t) => t.id === s.selectedTierId);
+          if (!tier) return derive({ ...s, actionMessage: copyParam("event.ticketChanged", "That ticket is no longer available. Choose a ticket again.") });
+          ticketCheckoutAllowed = await mayUseRegularTicketCheckout(checkoutEvent, tier);
+          if (!ticketCheckoutAllowed) return derive({ ...s, actionMessage: copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
           if (tier?.id) {
             const held = await createTicketReservation(s.id, [{ ticketDefinitionId: tier.id, quantity: 1 }]);
             reservationId = held.id ?? "";
@@ -643,6 +731,7 @@ const svc = defineService<S, {
           // fall through to the hosted rail below
         }
         // Hosted eventsCheckout — pinned to the live reservation when we have one.
+        if (!eventPageAllowed && !reservationId) return derive({ ...s, actionMessage: copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
         try {
           const params = reservationId ? { reservationId } : s.eventSlug ? { eventSlug: s.eventSlug } : undefined;
           if (params) {
@@ -667,6 +756,7 @@ const svc = defineService<S, {
       // page → nothing) on its own. Nothing here can change between its prepare and its open (the event
       // is fixed and the page is where the member chooses and pays), so the guard has nothing to re-read.
       // A host that refused or failed leaves the visitor page below.
+      if (!eventPageAllowed) return derive({ ...s, actionMessage: copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
       if (isHostedWorker() && s.id && (s.registrationKind === "tickets" || s.registrationKind === "rsvp")) {
         // One signed-in open at a time: the host keeps a single one-time ticket, so a second tap would
         // replace the first tap's ticket and drop that tap into the signed-OUT visitor page below.
@@ -747,5 +837,6 @@ const svc = defineService<S, {
     }),
   },
 });
+resetUnhydratedKeysOnOlderRuntime(svc, { ...svc.getState(), ...ATTENDANCE_INITIAL, ticketPurchaseBlocked: true }, [...ATTENDANCE_NOT_HYDRATED, "ticketPurchaseBlocked"]);
 svc.load();
 export { svc };