@wix/himalaya-cli 0.1495.0 → 0.1497.0

package/templates/community-club/tier5-src/_shared/iap-attendance-purchase.ts

@@ -0,0 +1,211 @@
+import { attendanceCheckoutRoute, availableTicketAttendanceOf, bookingAttendanceOf, classifyForApple, hostSessionFromGlobal, iapPriceFields, type BookingAttendance, type CatalogReference, type IapPollDirective, type TicketAttendance } from "@himalaya/iap";
+import { bookingOrders, createIapCommerce, eventTicketOrders, type IapOrderItem } from "@himalaya/iap-checkout";
+import { copyParam, copyTemplate } from "./himi-copy.js";
+import { createAttendanceForm, type AttendanceField } from "./iap-attendance-form.js";
+import { attendancePlatform } from "./iap-attendance.js";
+import { iapPriceCopy, iapPurchaseCopy } from "./iap-worker.js";
+
+export interface AttendancePurchaseFields {
+  iapBuyHidden: boolean;
+  iapBuyDisabled: boolean;
+  iapBuyLabel: string;
+  iapBusy: boolean;
+  iapPrice: string;
+  iapNote: string;
+  iapRetryHidden: boolean;
+  iapFormHidden: boolean;
+  iapFormError: string;
+  iapSignInHidden: boolean;
+  iapFields: AttendanceField[];
+  _poll?: IapPollDirective;
+}
+
+export const ATTENDANCE_INITIAL: AttendancePurchaseFields = {
+  iapBuyHidden: true, iapBuyDisabled: true, iapBuyLabel: "", iapBusy: false,
+  iapPrice: "", iapNote: "", iapRetryHidden: true, iapFormHidden: true, iapFormError: "", iapSignInHidden: true, iapFields: [],
+};
+export const ATTENDANCE_NOT_HYDRATED = [...Object.keys(ATTENDANCE_INITIAL), "_poll"] as (keyof AttendancePurchaseFields & string)[];
+
+export function createAttendancePurchase(options: { kind: "bookingsService" | "eventsTicket"; prefix: string; pollAction: string; onChange(): void }) {
+  const { prefix } = options;
+  let form = createAttendanceForm(prefix);
+  const submittedForms = new Map<string, ReturnType<typeof createAttendanceForm>>();
+  const session = hostSessionFromGlobal();
+  const commerce = createIapCommerce({ adapters: [options.kind === "bookingsService" ? bookingOrders : eventTicketOrders], onChange: options.onChange });
+  let generation = session.current().generation;
+  let reference: CatalogReference | undefined;
+  let metadata: BookingAttendance | TicketAttendance | undefined;
+  let platform = "unknown";
+  let started = false;
+  let inFlight = false;
+  let formError = "";
+  let sequence = 0;
+  let formRevision = 0;
+  const attempts = new Map<string, string>();
+  session.subscribe(() => { syncSession(); if (reference) options.onChange(); });
+
+  function syncSession(): void {
+    const next = session.current().generation;
+    if (next === generation) return;
+    generation = next;
+    form.clear();
+    submittedForms.clear();
+    formError = "";
+    attempts.clear();
+  }
+
+  async function refresh(): Promise<void> {
+    const next = await attendancePlatform(publishPlatform);
+    if (next !== "unknown" || platform === "unknown") platform = next;
+    await resume();
+  }
+
+  async function resume(): Promise<void> {
+    if (reference) await commerce.loadPrices([{ reference }]);
+    const first = !started;
+    started = true;
+    await (first ? commerce.start() : commerce.reconcile());
+  }
+
+  function publishPlatform(next: string): void {
+    if (next === "unknown" && platform !== "unknown") return;
+    platform = next;
+    void resume().then(options.onChange, options.onChange);
+  }
+
+  function show(): void {
+    void attendancePlatform(publishPlatform).then(publishPlatform, options.onChange);
+  }
+
+  async function booking(id: string, service: unknown): Promise<void> {
+    syncSession();
+    reference = { kind: options.kind, id };
+    metadata = bookingAttendanceOf(service);
+    selectForm(id, (next) => next.booking(service));
+    formRevision++;
+    formError = "";
+    await show();
+  }
+
+  async function ticket(id: string, event: unknown, available: unknown): Promise<void> {
+    syncSession();
+    reference = id ? { kind: options.kind, id } : undefined;
+    metadata = availableTicketAttendanceOf(event, available);
+    selectForm(id, (next) => next.event((event as { form?: unknown } | undefined)?.form));
+    formRevision++;
+    formError = "";
+    await show();
+  }
+
+  function selectForm(id: string, initialize: (next: ReturnType<typeof createAttendanceForm>) => void): void {
+    const key = `${options.kind}:${id}`;
+    const retained = submittedForms.get(key);
+    form = retained ?? createAttendanceForm(prefix);
+    if (!retained) initialize(form);
+  }
+
+  function fields(selected = true, publishPoll = true): AttendancePurchaseFields {
+    syncSession();
+    if (!reference || !metadata) return ATTENDANCE_INITIAL;
+    const currency = metadata.currency ?? "";
+    const classified = classifyForApple(metadata, currency);
+    const candidate = platform === "ios" && classified === "appleIap";
+    const price = iapPriceFields(commerce.pricing.view(reference), iapPriceCopy(prefix));
+    const copy = { ...iapPurchaseCopy(prefix), buy: copyParam(`${prefix}.appleBuyCta`, options.kind === "bookingsService" ? "Book with Apple" : "Buy ticket with Apple"), buyAnother: copyParam(`${prefix}.buyAnotherCta`, options.kind === "bookingsService" ? "Book again" : "Buy another ticket") };
+    const purchase = commerce.purchaseFields(reference, copy);
+    const apple = candidate || (platform === "ios" && classified !== "wixPayments" && purchase.appleRoute);
+    const enabled = attendanceCheckoutRoute(metadata, currency, platform) === "appleIap";
+    const poll = publishPoll ? commerce.pollDirective(options.pollAction) : undefined;
+    const state = commerce.state();
+    for (const [target, attempt] of attempts) {
+      const key = `${reference.kind}:${reference.id}#${encodeURIComponent(attempt)}`;
+      if ((state.phase === "accessReady" && state.item === key) || state.payments.some((p) => p.item === key && p.access === "granted")) attempts.delete(target);
+    }
+    const formKey = `${reference.kind}:${reference.id}`;
+    if (![...attempts.keys()].some((target) => target.startsWith(`${formKey}:`))) submittedForms.delete(formKey);
+    const own = state.item?.startsWith(`${reference.kind}:${reference.id}#`);
+    const completed = state.phase === "accessReady" && own;
+    const member = session.current().kind === "member";
+    let note = "";
+    if (apple && !enabled) note = copy.unavailable;
+    else if (apple && !member) note = copy.signInRequired;
+    else if (apple && purchase.buyNote) note = purchase.buyNote;
+    else if (apple && !form.supported()) note = copyParam(`${prefix}.formUnavailableText`, "This registration form is not supported yet.");
+    else if (apple && completed) note = copyParam(`${prefix}.purchaseCompleteText`, options.kind === "bookingsService" ? "Your booking is confirmed." : "Your ticket is confirmed.");
+    else if (apple && own && state.phase === "cancelled") note = copyParam(`${prefix}.purchaseCancelledText`, "Purchase cancelled. Your place is not confirmed.");
+    return {
+      iapBuyHidden: !apple, iapBuyDisabled: !enabled || !selected || !member || !form.supported() || purchase.buyDisabled || inFlight,
+      iapBuyLabel: purchase.buyLabel || copy.buy, iapBusy: purchase.buyBusy || inFlight,
+      iapPrice: apple ? price.priceText : "", iapRetryHidden: !apple || (price.hidePriceRetry && commerce.scopeComplete()),
+      iapNote: note,
+      iapFormHidden: !apple || !selected || !form.supported(), iapFormError: formError,
+      iapSignInHidden: !apple || member || options.kind === "bookingsService",
+      iapFields: form.rows().map((f, index, rows) => ({ ...f,
+        id: `${generation}:${formRevision}:${f.id}`, fieldId: f.id,
+        errorHidden: !f.error,
+        options: f.options.map((o) => ({ ...o, fieldId: f.id, displayLabel: (f.kind === "multiple" ? f.selectedIds.includes(o.id) : f.value === o.id) ? `${o.label} ✓` : o.label })),
+        label: f.required ? `${f.label} *` : f.label,
+        inputLabel: copyTemplate(`${prefix}.fieldAccessibilityLabel`, "{section}: {field}", { section: f.id.startsWith("buyer:") ? copyParam(`${prefix}.buyerDetailsLabel`, "Buyer details") : copyParam(`${prefix}.guestDetailsLabel`, "Ticket holder details"), field: f.label }),
+        sectionLabel: index === 0 ? copyParam(`${prefix}.buyerDetailsLabel`, "Buyer details") : f.id.startsWith("guest:") && rows[index - 1].id.startsWith("buyer:") ? copyParam(`${prefix}.guestDetailsLabel`, "Ticket holder details") : "",
+      })), ...(poll ? { _poll: poll } : {}),
+    };
+  }
+
+  async function buy(selection: { key: string; slot?: Record<string, unknown>; eventId?: string }): Promise<void> {
+    syncSession();
+    if (!reference || !metadata || fields(true, false).iapBuyDisabled || inFlight) return;
+    if (options.kind === "eventsTicket" && reference.id !== selection.key) return;
+    if (!form.validate()) { formError = copyParam(`${prefix}.formRequiredText`, "Complete the required details before purchasing."); return; }
+    if (session.current().kind !== "member") { formError = iapPurchaseCopy(prefix).signInRequired; return; }
+    const currentGeneration = generation;
+    const ref = reference;
+    submittedForms.set(`${ref.kind}:${ref.id}`, form);
+    const target = `${ref.kind}:${ref.id}:${selection.key}`;
+    let attemptId = attempts.get(target);
+    const state = commerce.state();
+    const attemptKey = attemptId ? `${ref.kind}:${ref.id}#${encodeURIComponent(attemptId)}` : "";
+    const completed = attemptId && ((state.phase === "accessReady" && state.item === attemptKey) || state.payments.some((p) => p.item === attemptKey && p.access === "granted"));
+    if (!attemptId || completed) { attemptId = `${Date.now().toString(36)}-${++sequence}-${Math.random().toString(36).slice(2)}`; attempts.set(target, attemptId); }
+    const item: IapOrderItem = { reference: ref, attemptId, quantity: 1, attendance: {
+      amount: metadata.amount!, currency: metadata.currency!,
+      ...(options.kind === "bookingsService" ? { booking: { slot: selection.slot ?? {}, contactDetails: form.buyer() } } : { ticket: { eventId: selection.eventId ?? "", ...form.ticket(ref.id) } }),
+    } };
+    inFlight = true;
+    formError = "";
+    options.onChange();
+    try {
+      await commerce.buy(item);
+      const after = commerce.state();
+      if (after.phase === "accessReady" && after.item === `${ref.kind}:${ref.id}#${encodeURIComponent(attemptId)}`) attempts.delete(target);
+    }
+    finally { inFlight = false; syncSession(); if (generation !== currentGeneration) form.clear(); options.onChange(); }
+  }
+
+  function change(arg: unknown): void {
+    syncSession();
+    const state = commerce.state();
+    if (reference) {
+      for (const [target, attempt] of attempts) {
+        const item = `${reference.kind}:${reference.id}#${encodeURIComponent(attempt)}`;
+        const canCorrect = state.phase === "cancelled" || (state.phase === "refused" && (state.failure === "orderRefused" || state.failure === "productChanged"));
+        if (canCorrect && state.item === item) { attempts.delete(target); submittedForms.delete(`${reference.kind}:${reference.id}`); }
+      }
+      const referencePrefix = `${reference.kind}:${reference.id}:`;
+      if (inFlight || [...attempts.keys()].some((target) => target.startsWith(referencePrefix))) {
+        formError = copyParam(`${prefix}.detailsLockedText`, "Finish the current purchase before changing registration details.");
+        return;
+      }
+    }
+    form.change(arg);
+    formError = "";
+  }
+
+  return {
+    booking, ticket, fields, buy,
+    usesRegularPlatform: () => platform === "android" || platform === "web",
+    invalidate: () => { reference = undefined; metadata = undefined; options.onChange(); },
+    change,
+    refresh,
+    poll: async () => { syncSession(); await commerce.poll(); },
+  };
+}

package/templates/community-club/tier5-src/_shared/iap-attendance.ts

@@ -0,0 +1,38 @@
+import { get as appInfo } from "@himalaya/app-info";
+import { attendanceCheckoutRoute, bookingAttendanceOf, ticketAttendanceOf } from "@himalaya/iap";
+
+let knownPlatform: string | undefined;
+
+export function attendancePlatform(onResolved?: (platform: string) => void): Promise<string> {
+  if (knownPlatform) return Promise.resolve(knownPlatform);
+  const info = appInfo().then((value) => value.platform, () => "unknown").then((platform) => {
+    if (platform !== "unknown") knownPlatform = platform;
+    return platform;
+  });
+  const host = globalThis as { setTimeout?: (fn: () => void, ms: number) => unknown; clearTimeout?: (timer: unknown) => void };
+  if (!host.setTimeout) {
+    void info.then((platform) => onResolved?.(platform));
+    return Promise.resolve("unknown");
+  }
+  return new Promise((resolve) => {
+    let timedOut = false;
+    const timer = host.setTimeout!(() => { timedOut = true; resolve("unknown"); }, 1500);
+    void info.then((platform) => { host.clearTimeout?.(timer); resolve(platform); if (timedOut) onResolved?.(platform); });
+  });
+}
+
+export async function mayUseRegularBookingCheckout(service: unknown): Promise<boolean> {
+  const metadata = bookingAttendanceOf(service);
+  if (metadata.priceType === "NO_FEE" || isZero(metadata.amount)) return true;
+  return attendanceCheckoutRoute(metadata, metadata.currency ?? "", await attendancePlatform()) === "regular";
+}
+
+export async function mayUseRegularTicketCheckout(event: unknown, ticket: { free?: boolean; price?: { amount?: string; currency?: string }; saleStatus?: string } | undefined): Promise<boolean> {
+  if (ticket?.free === true || isZero(ticket?.price?.amount)) return true;
+  const metadata = ticketAttendanceOf(event, { hidden: false, saleStatus: ticket?.saleStatus });
+  return attendanceCheckoutRoute(metadata, ticket?.price?.currency ?? "", await attendancePlatform()) === "regular";
+}
+
+function isZero(value: unknown): boolean {
+  return typeof value === "string" && /^0+(?:\.0+)?$/.test(value);
+}

package/templates/community-club/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 };