@wix/himalaya-cli 0.1560.0 → 0.1561.0

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

@@ -1,7 +1,9 @@
 // Tier-5 bundle: himi-events — event detail.
-import { formatCurrency } from "../_shared/engine-intl.js";
+import { calendarDay, formatClock, formatCurrency, formatWeekdayDateTime, formatWeekdayMonthDay, formatTimeZoneLabel } from "../_shared/engine-intl.js";
 import { defineService as registerService } from "@himalaya/state";
+import { dispatch } from "@himalaya/dispatch";
 import { withOnlineWrites } from "../_shared/online-actions.js";
+import { hostedSitePageOpener, isHostedWorker } from "../_shared/hosted-checkout.js";
 import { createEvent, getPermissionStatus, requestPermission } from "@himalaya/calendar";
 import { open } from "@himalaya/open-url";
 import { share as shareSheet } from "@himalaya/share";
@@ -10,70 +12,61 @@ import {
   checkoutReservation,
   createTicketReservation,
   getEvent,
-  getEventGuestList,
   queryAvailableTickets,
-  queryEvents,
   type WixAvailableTicket,
   type WixEventFieldset,
   type WixEvent,
-  type WixGuestRsvp,
-  type WixGuestTicket,
 } from "@himalaya/wix-events";
 import { session as wixPlatformSession } from "@himalaya/wix-platform";
 import { payCashierOrder } from "@himalaya/checkout";
 import { get, upsert, type DbEntity } from "@himalaya/local-db";
 import {
   currentInputId,
+  forgetRsvp,
   eventDescription,
-  eventEndMillis,
   eventImage,
   eventLocation,
+  eventAddress,
   eventMapUrl,
   eventStartMillis,
   eventWhen,
   normalizeEvent,
-  titleCase,
   type EventRow,
 } from "../_shared/himi-events";
-import { initials } from "../_shared/himi-text.js";
-import { hostedSitePageOpener, isHostedWorker } from "../_shared/hosted-checkout.js";
+import { stashCopy, copyParam } from "../_shared/himi-copy.js";
+import { openRichLink } from "../_shared/rich-content-link.js";
+import { richBody } from "../_shared/rich-body.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 ticketCheckoutDenied = false;
 let paymentEvent: unknown;
 let paymentTickets = new Map<string, WixAvailableTicket>();
 let ticketSelectionVersion = 0;
+let ticketCheckoutInFlight = false;
+let ticketSelectionQueue: Promise<void> = Promise.resolve();
+let ticketSelectionState: S | undefined;
 let lastReady: S | undefined;
+let cancelRsvpInFlight = false;
 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);
+async function priceTicket(event: unknown, id: string, version: number, ticket = paymentTickets.get(id)): Promise<boolean> {
   if (version !== ticketSelectionVersion) return false;
-  await applePurchase.ticket(id, event, available);
+  await applePurchase.ticket(id, event, ticket);
   return version === ticketSelectionVersion;
 }
-
-/** A hosted signed-in event-page open is in flight (see openRegistration). */
 let hostedOpenInFlight = false;
-import { stashCopy, copyParam, copyTemplate } from "../_shared/himi-copy.js";
-import { openRichLink } from "../_shared/rich-content-link.js";
-import { richBody } from "../_shared/rich-body.js";
-
-interface MapMarker {
-  latitude: number;
-  longitude: number;
-  label?: string;
-}
-
-interface AttendeeAvatar {
-  initials: string;
-}
 
 /** One buyer-visible ticket tier. */
 interface TicketTierRow {
   id: string;
+  ticketDefinitionId?: string;
+  pricingOptionId?: string;
+  guestPrice?: string;
+  minPrice?: number;
+  minimumPriceLabel?: string;
+  isGuestPrice?: boolean;
   name: string;
   /** Formatted price, or the free label. */
   priceLine: string;
@@ -83,6 +76,15 @@ interface TicketTierRow {
   /** Selection is rendered by the row itself (bound to `$item.isSelected`). */
   isSelected: boolean;
   notSelected: boolean;
+  quantity?: number;
+  feeNote?: string;
+  description?: string;
+  policy?: string;
+  priceAmount?: number;
+  maxQuantity?: number;
+  rowLimit?: number;
+  noPolicy?: boolean;
+  notAvailable?: boolean;
 }
 
 /** Registration CTA kind derived from the event's registration/eventType. */
@@ -110,7 +112,6 @@ interface S extends AttendancePurchaseFields {
   status: "loading" | "ready";
   id: string;
   title: string;
-  initial: string;
   when: string;
   location: string;
   /** The plain-text description: RichContent's fallback, the calendar notes, and what shows with no document. */
@@ -124,17 +125,62 @@ interface S extends AttendancePurchaseFields {
   hasImage: boolean;
   noImage: boolean;
   mapUrl: string;
-  noMap: boolean;
-  /** Inline schematic map — a 0/1-marker set from the event's geo coordinates. */
-  mapMarkers: MapMarker[];
-  hasMapMarkers: boolean;
-  noMapMarkers: boolean;
-  /** Attendees ("N going") from the guest list — best-effort (the guest-list
-   *  endpoint is owner-scoped; a visitor rung just collapses the strip). */
-  goingLabel: string;
-  attendeeAvatars: AttendeeAvatar[];
-  hasAttendees: boolean;
-  noAttendees: boolean;
+  place: string;
+  placeIcon: string;
+  noPlace: boolean;
+  hidePlaceStatic: boolean;
+  price: string;
+  zone: string;
+  noPrice: boolean;
+  hideMapTap: boolean;
+  shortDescription: string;
+  noShortDescription: boolean;
+  noDescription: boolean;
+  noDate: boolean;
+  dateNotTappable: boolean;
+  hideDateStatic: boolean;
+  registrationState: string;
+  footerLabel: string;
+  footerAction: string;
+  footerCaption: string;
+  hideFooter: boolean;
+  noFooterButton: boolean;
+  noFooterCaption: boolean;
+  notice: string;
+  exploreLabel: string;
+  noNotice: boolean;
+  rsvpLabel: string;
+  rsvpId: string;
+  rsvpState: "none" | "going" | "waitlist";
+  hideRsvpChip: boolean;
+  hideGoingChip: boolean;
+  hideWaitlistedChip: boolean;
+  hideCancelRsvp: boolean;
+  hideCancelConfirm: boolean;
+  hideRsvpOptions: boolean;
+  ticketSheetOpen: boolean;
+  rsvpActionsOpen: boolean;
+  cancelConfirmOpen: boolean;
+  ticketTotal: string;
+  ticketCountLabel: string;
+  checkoutDisabled: boolean;
+  schedule: Array<{ time: string; name: string; detail: string }>;
+  fullSchedule: Array<{ time: string; name: string; detail: string }>;
+  noSchedule: boolean;
+  noFullSchedule: boolean;
+  moreDates: Array<{ id: string; date: string }>;
+  allDates: Array<{ id: string; date: string }>;
+  noMoreDates: boolean;
+  noAllDates: boolean;
+  policies: Array<{ name: string; text: string }>;
+  noPolicies: boolean;
+  hideWaitlist: boolean;
+  hideScheduled: boolean;
+  memberOnly: boolean;
+  hideMemberRsvp: boolean;
+  hideMemberWaitlist: boolean;
+  hideMemberTickets: boolean;
+  hideMemberScheduled: boolean;
   /** CTA variant flags — exactly one of {RSVP, tickets, external} shows, or
    *  none for NO_REGISTRATION. Unknown/absent registration keeps RSVP (the
    *  historical default). */
@@ -148,6 +194,10 @@ interface S extends AttendancePurchaseFields {
   /** Buyer-visible ticket tiers for a ticketed event (empty otherwise). Loaded
    *  alongside the event so the price is on screen BEFORE the CTA is tapped. */
   ticketTiers: TicketTierRow[];
+  ticketCurrency: string;
+  ticketLimitPerOrder: number;
+  ticketPurchaseBlocked: boolean;
+  regularTicketsHidden: boolean;
   hasTiers: boolean;
   noTiers: boolean;
   /** More than one tier ⇒ the picker is worth showing; exactly one ⇒ the CTA
@@ -157,8 +207,6 @@ interface S extends AttendancePurchaseFields {
   /** 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. */
@@ -169,9 +217,9 @@ interface S extends AttendancePurchaseFields {
   shareUrl: string;
   calendarStart: number;
   calendarEnd: number;
-  actionMessage: string;
+  snackbarMessage: string;
+  noSnackbar: boolean;
   isAddingCalendar: boolean;
-  statusLabel: string;
   emptyText: string;
   errored: boolean;
   notErrored: boolean;
@@ -199,7 +247,8 @@ function tierPrice(t: WixAvailableTicket): string {
 }
 
 function tierAvailable(t: WixAvailableTicket): boolean {
-  return !!t.id && !/SALE_SCHEDULED|SALE_ENDED|CANCELED|SOLD_OUT/i.test(t.saleStatus ?? "");
+  const salesDetails = (t as WixAvailableTicket & { salesDetails?: { soldOut?: boolean } }).salesDetails;
+  return !!t.id && !salesDetails?.soldOut && !/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
@@ -207,75 +256,155 @@ function tierAvailable(t: WixAvailableTicket): boolean {
 function tierRows(defs: WixAvailableTicket[], selectedId: string): TicketTierRow[] {
   return defs
     .filter((t) => !!t.id)
+    .flatMap((t) => {
+      const raw = t as WixAvailableTicket & { pricingOptions?: Array<{ id?: string; optionId?: string; name?: string; price?: { amount?: string; value?: string; currency?: string } }>; pricingMethod?: { type?: string; pricingOptions?: { optionDetails?: Array<{ id?: string; optionId?: string; name?: string; price?: { amount?: string; value?: string; currency?: string } }> } } };
+      const options = raw.pricingOptions ?? raw.pricingMethod?.pricingOptions?.optionDetails ?? [];
+      return options.length ? options.map((option) => ({ ...t, id: `${t.id}:${option.optionId ?? option.id}`, name: [t.name, option.name].filter(Boolean).join(" · "), price: { ...t.price, amount: option.price?.amount ?? option.price?.value ?? t.price?.amount, currency: option.price?.currency ?? t.price?.currency }, __optionId: option.optionId ?? option.id })) : [t as WixAvailableTicket & { __optionId?: string }];
+    })
     .slice()
-    .sort((a, b) => Number(a.price?.amount ?? 0) - Number(b.price?.amount ?? 0))
+    .sort((a, b) => Number(a.orderIndex ?? 0) - Number(b.orderIndex ?? 0))
     .map((t) => {
       const available = tierAvailable(t);
       const selected = t.id === selectedId;
+      const originalId = t.id?.split(":")[0] ?? "";
+      const optionId = (t as WixAvailableTicket & { __optionId?: string }).__optionId;
+      const raw = t as WixAvailableTicket & { pricingMethod?: { type?: string; pricingType?: string; guestPrice?: { value?: string } }; pricing?: { pricingType?: string } };
+      const isGuestPrice = raw.pricingMethod?.guestPrice != null || /guestPrice/i.test(raw.pricingMethod?.type ?? raw.pricingMethod?.pricingType ?? raw.pricing?.pricingType ?? "");
+      const minPrice = Number(raw.pricingMethod?.guestPrice?.value ?? 0);
       return {
         id: t.id ?? "",
+        ticketDefinitionId: originalId,
+        pricingOptionId: optionId,
+        guestPrice: "",
+        minPrice,
         name: (t.name || copyParam("event.tierFallbackName", "Ticket")).trim(),
         priceLine: tierPrice(t),
-        unavailableNote: available ? "" : copyParam("event.tierOffSale", "Not on sale"),
+        unavailableNote: available ? "" : /SALE_SCHEDULED/i.test(t.saleStatus ?? "") ? copyParam("event.onSaleFrom", "On sale {date}").replace("{date}", t.salePeriod?.startDate ? formatWeekdayDateTime(new Date(t.salePeriod.startDate)) : "") : copyParam("event.soldOut", "Sold out"),
         available,
         isSelected: selected,
         notSelected: !selected,
+        priceAmount: Number(t.price?.amount ?? 0),
+        ...(isGuestPrice ? { priceLine: detailCopy("event.payWhatYouWant", "Pay what you want") } : {}),
+        ...(isGuestPrice ? { priceAmount: minPrice, isGuestPrice: true } : {}),
+        ...(isGuestPrice ? { minimumPriceLabel: detailCopy("event.minPrice", "Minimum {price}").replace("{price}", formatCurrency(minPrice, t.price?.currency || "USD", "en")) } : {}),
       };
     });
 }
 
-/** Best-effort tier read — never sinks the screen if the tier endpoint fails. */
-async function loadTiers(eventId: string): Promise<{ rows: TicketTierRow[]; tickets: Map<string, WixAvailableTicket> }> {
-  try {
-    const response = await queryAvailableTickets(eventId);
-    const defs = response.definitions ?? [];
+function loadedTiers(defs: WixAvailableTicket[]): { rows: TicketTierRow[]; tickets: Map<string, WixAvailableTicket> } {
     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 { rows: tierRows(defs, cheapestAvailable?.id ?? ""), tickets };
+    const rows = tierRows(defs, cheapestAvailable?.id ?? "").map((row) => {
+      const ticket = tickets.get(row.ticketDefinitionId ?? row.id);
+      if (!ticket) return { ...row, quantity: 0, description: "", feeNote: "", policy: "", noPolicy: true, notAvailable: !row.available, notGuestPrice: !row.isGuestPrice, maxQuantity: 0 };
+      const policy = (ticket as unknown as { policy?: string; policyText?: string }).policyText || (ticket as unknown as { policy?: string }).policy || "";
+      return { ...row, quantity: 0, description: ticket.description || "", feeNote: ((ticket as unknown as { wixFeeConfig?: { type?: string }; feeType?: string }).wixFeeConfig?.type ?? (ticket as unknown as { feeType?: string }).feeType) === "FEE_ADDED_AT_CHECKOUT" ? detailCopy("event.serviceFee", "+ ticket service fee") : "", policy, noPolicy: !policy, notAvailable: !row.available, notGuestPrice: !row.isGuestPrice, priceAmount: row.priceAmount ?? Number(ticket.price?.amount ?? 0), rowLimit: row.available ? ticket.limitPerCheckout ?? 99 : 0, maxQuantity: row.available ? ticket.limitPerCheckout ?? 99 : 0 };
+    });
+    return { rows, tickets };
+}
+
+/** Classify the buyer's selected option or bid, rather than the definition's cheapest price. */
+function selectedPaymentTicket(row: TicketTierRow, tickets = paymentTickets): WixAvailableTicket | undefined {
+  const ticket = tickets.get(row.ticketDefinitionId ?? row.id);
+  if (!ticket) return;
+  const priced = tierRows([ticket], row.id).find((next) => next.id === row.id);
+  if (!priced) return;
+  const amount = priced.isGuestPrice ? Number(row.guestPrice || priced.minPrice || 0) : priced.priceAmount ?? 0;
+  return { ...ticket, free: amount === 0, price: { ...ticket.price, amount: String(amount) } };
+}
+
+/** Best-effort tier read — never sinks the screen if the tier endpoint fails. */
+async function loadTiers(eventId: string): Promise<{ rows: TicketTierRow[]; tickets: Map<string, WixAvailableTicket> }> {
+  try {
+    return loadedTiers((await queryAvailableTickets(eventId)).definitions ?? []);
   } catch {
     return { rows: [], tickets: new Map() };
   }
 }
 
 function derive(s: S): S {
-  const regular = ticketCheckoutAllowed || applePurchase.usesRegularPlatform();
+  // A price refresh can publish a ready snapshot captured before checkout's
+  // guard denied the selection. Keep that denial visible until a new selection
+  // or load clears it, including across delayed StoreKit publications.
+  const snackbarMessage = s.snackbarMessage || (ticketCheckoutDenied ? copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") : "");
   const hasContent = !!s.title;
-  const hasMapMarkers = s.mapMarkers.length > 0;
-  const hasAttendees = s.attendeeAvatars.length > 0;
-  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 count = s.ticketTiers.reduce((n, row) => n + (row.quantity ?? 0), 0);
+  const total = s.ticketTiers.reduce((n, row) => n + (row.isGuestPrice ? Number(row.guestPrice || row.minPrice || 0) : row.priceAmount ?? 0) * (row.quantity ?? 0), 0);
+  const ticketTiers = s.ticketTiers.map((row) => {
+    const definitionId = row.ticketDefinitionId ?? row.id;
+    const sameDefinitionElsewhere = s.ticketTiers.reduce((n, other) => n + ((other.ticketDefinitionId ?? other.id) === definitionId && other.id !== row.id ? other.quantity ?? 0 : 0), 0);
+    const selectedElsewhere = s.ticketTiers.reduce((n, other) => n + (other.id === row.id ? 0 : other.quantity ?? 0), 0);
+    return { ...row, maxQuantity: Math.max(0, Math.min((row.rowLimit ?? 99) - sameDefinitionElsewhere, s.ticketLimitPerOrder - selectedElsewhere)) };
+  });
+  const chosenRows = s.ticketTiers.filter((row) => (row.quantity ?? 0) > 0);
+  const singleTicketSelected = chosenRows.length === 1 && chosenRows[0]!.quantity === 1;
+  const purchase = applePurchase.fields(singleTicketSelected);
+  const regularRoute = ticketCheckoutAllowed || applePurchase.usesRegularPlatform();
   const next = {
     ...s,
-    _poll: undefined,
+    ticketTiers,
     ...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,
+    iapBuyHidden: !singleTicketSelected || purchase.iapBuyHidden,
+    // The shared attendance purchase produces a one-shot native poll directive.
+    // Let it through once; its commerce adapter consumes it, so later derives
+    // cannot replay it from a cached ready state.
+    regularTicketsHidden: s.registrationKind !== "tickets" || (singleTicketSelected && !purchase.iapBuyHidden),
+    ticketPurchaseBlocked: ticketCheckoutDenied || (s.registrationKind === "tickets" && !regularRoute && purchase.iapBuyHidden),
     hasDescriptionJson: s.descriptionJson !== "",
-    noMap: !s.mapUrl,
-    hasMapMarkers,
-    noMapMarkers: !hasMapMarkers,
-    hasAttendees,
-    noAttendees: !hasAttendees,
-    showRsvp: s.registrationKind === "rsvp",
-    hideRsvp: s.registrationKind !== "rsvp",
+    noPlace: !s.place,
+    noDate: !s.when,
+    dateNotTappable: !s.calendarStart,
+    hideDateStatic: !s.when || !!s.calendarStart,
+    hidePlaceStatic: !s.place || !!s.mapUrl,
+    noPrice: !s.price,
+    hideMapTap: !s.place || !s.mapUrl,
+    noShortDescription: !s.shortDescription || s.shortDescription.trim() === s.description.trim(),
+    noDescription: !s.description && !s.descriptionJson,
+    showRsvp: s.registrationState === "rsvp",
+    hideRsvp: s.registrationState !== "rsvp" || s.memberOnly,
     hasTiers: s.ticketTiers.length > 0,
     noTiers: s.ticketTiers.length === 0,
     // One tier is not a choice — showing a single-row "picker" would be noise.
     showTierPicker: s.ticketTiers.length > 1,
     hideTierPicker: s.ticketTiers.length <= 1,
     selectedTierLabel: (() => {
-      const picked = tiers.find((t) => t.id === s.selectedTierId);
+      const picked = s.ticketTiers.find((t) => t.id === s.selectedTierId);
       return picked ? [picked.name, picked.priceLine].filter(Boolean).join(" · ") : "";
     })(),
-    showTickets: s.registrationKind === "tickets",
-    hideTickets: s.registrationKind !== "tickets",
-    showExternal: s.registrationKind === "external",
-    hideExternal: s.registrationKind !== "external",
+    showTickets: s.registrationState === "tickets",
+    hideTickets: s.registrationState !== "tickets" || s.memberOnly,
+    showExternal: s.registrationState === "external",
+    hideExternal: s.registrationState !== "external" || s.memberOnly,
+    noNotice: !s.notice,
+    snackbarMessage,
+    noSnackbar: !snackbarMessage,
+    hideWaitlist: s.registrationState !== "waitlist" || s.memberOnly,
+    hideScheduled: s.registrationState !== "scheduled",
+    memberOnly: s.memberOnly,
+    hideMemberRsvp: !s.memberOnly || s.registrationState !== "rsvp",
+    hideMemberWaitlist: !s.memberOnly || s.registrationState !== "waitlist",
+    hideMemberTickets: !s.memberOnly || s.registrationState !== "tickets",
+    // Scheduled registration uses the shared disabled footer, including for members.
+    hideMemberScheduled: true,
+    hideRsvpChip: s.rsvpState !== "waitlist",
+    hideGoingChip: s.rsvpState !== "going",
+    hideWaitlistedChip: s.rsvpState !== "waitlist",
+    hideCancelRsvp: !s.rsvpId,
+    hideCancelConfirm: !s.cancelConfirmOpen,
+    hideRsvpOptions: s.cancelConfirmOpen,
+    noFooterButton: !s.footerLabel,
+    noFooterCaption: !s.footerCaption,
+    hideFooter: s.status !== "ready" || s.errored || !s.footerLabel || s.rsvpState !== "none",
+    checkoutDisabled: count === 0 || count > s.ticketLimitPerOrder || ticketCheckoutInFlight || !ticketCheckoutAllowed || s.ticketTiers.some((row) => row.isGuestPrice && (row.quantity ?? 0) > 0 && (!String(row.guestPrice ?? "").trim() || Number(row.guestPrice) < (row.minPrice ?? 0) || !Number.isFinite(Number(row.guestPrice)))) || s.ticketTiers.some((row) => (row.quantity ?? 0) > (row.maxQuantity ?? 99)),
+    ticketTotal: formatCurrency(total, s.ticketCurrency || "USD", "en"),
+    ticketCountLabel: copyParam("event.ticketCount", "{n} tickets, plus fees").replace("{n}", String(count)),
+    noSchedule: s.schedule.length === 0,
+    noFullSchedule: s.fullSchedule.length === 0,
+    noMoreDates: s.moreDates.length === 0,
+    noAllDates: s.allDates.length === 0,
     isLoading: s.status === "loading",
     notLoading: s.status !== "loading",
     notErrored: !s.errored,
@@ -286,7 +415,6 @@ 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;
 }
 
@@ -320,20 +448,120 @@ 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", "FORM"];
+export const EVENT_DETAIL_FIELDSETS: WixEventFieldset[] = ["DETAILS", "TEXTS", "REGISTRATION", "URLS", "FORM", "AGENDA"];
 
-/** Map the decoded registration/eventType onto the CTA variant. The decoded
+/** Map registration status and decoded eventType onto the CTA variant. The decoded
  *  `eventType` already folds registration.type / registration.initialType /
- *  the legacy flat `type` (decodeEvent, #478). Unknown ⇒ RSVP (historical). */
+ *  the legacy flat `type` (decodeEvent, #478). Without a recognized type or
+ *  status there is no registration action to offer. */
 export function registrationKindOf(e: WixEvent): RegistrationKind {
-  const raw = e as unknown as { registration?: { type?: string; initialType?: string } };
-  const value = (e.eventType ?? raw.registration?.type ?? raw.registration?.initialType ?? "").toUpperCase();
-  if (!value) return "rsvp";
-  if (value.includes("NO_REGISTRATION")) return "none";
+  const raw = e as unknown as { registration?: { type?: string; initialType?: string; status?: string } };
+  const value = (raw.registration?.type ?? e.eventType ?? raw.registration?.initialType ?? "").toUpperCase();
+  if (value === "NONE" || value.includes("NO_REGISTRATION")) return "none";
+  // Open statuses select the footer action, so they must also select the
+  // inventory read and action guards when type metadata is absent or stale.
+  switch (raw.registration?.status?.toUpperCase()) {
+    case "OPEN_TICKETS": return "tickets";
+    case "OPEN_EXTERNAL": return "external";
+    case "OPEN_RSVP":
+    case "OPEN_RSVP_WAITLIST_ONLY":
+    case "SCHEDULED_RSVP": return "rsvp";
+  }
   if (value.includes("EXTERNAL")) return "external";
   if (value.includes("TICKET")) return "tickets";
   if (value.includes("RSVP")) return "rsvp";
-  return "rsvp";
+  return "none";
+}
+
+function detailCopy(key: string, fallback: string): string { return copyParam(key, fallback); }
+
+function detailDate(e: WixEvent): { line: string; zone: string; start: number; end: number } {
+  const raw = e as unknown as {
+    dateAndTimeSettings?: { startDate?: string; endDate?: string; dateAndTimeTbd?: boolean; dateAndTimeTbdMessage?: string; timeZoneId?: string; showTimeZone?: boolean; hideEndDate?: boolean };
+    scheduling?: { startDate?: string; endDate?: string; timeZoneId?: string; tbd?: string; endDateHidden?: boolean; config?: { startDate?: string; endDate?: string; timeZoneId?: string } };
+  };
+  const settings = raw.dateAndTimeSettings ?? {};
+  const schedule = raw.scheduling;
+  const startValue = settings.startDate ?? schedule?.config?.startDate ?? schedule?.startDate;
+  const endValue = settings.endDate ?? schedule?.config?.endDate ?? schedule?.endDate;
+  const timeZoneId = settings.timeZoneId ?? schedule?.config?.timeZoneId ?? schedule?.timeZoneId;
+  const start = startValue ? new Date(startValue) : null;
+  const end = endValue ? new Date(endValue) : null;
+  const validStart = start && !Number.isNaN(start.getTime());
+  if (settings.dateAndTimeTbd || (!validStart && schedule?.tbd)) return { line: settings.dateAndTimeTbdMessage || schedule?.tbd || detailCopy("event.dateTbd", "Date to be announced"), zone: "", start: 0, end: 0 };
+  if (!validStart) return { line: "", zone: "", start: 0, end: 0 };
+  const zone = timeZoneId;
+  const format = (d: Date): string => formatWeekdayDateTime(d, "en-US", zone);
+  const a = format(start);
+  const b = end && !Number.isNaN(end.getTime()) ? format(end) : "";
+  const parts = (date: Date) => {
+    const time = formatClock(date, "en-US", zone);
+    const clock = time.match(/^(\d{1,2}):(\d{2})\s*(AM|PM)?$/i);
+    return { day: formatWeekdayMonthDay(date, "en-US", zone), hour: clock?.[1] ?? "", minute: clock?.[2] ?? "", period: clock?.[3] ?? "", time, calendarDay: calendarDay(date, zone) };
+  };
+  const startParts = parts(start);
+  const endParts = end && !Number.isNaN(end.getTime()) ? parts(end) : undefined;
+  const startDisplayDay = startParts.day.replace(/, \d{4}$/, "");
+  const hideEndDate = settings.hideEndDate ?? schedule?.endDateHidden;
+  const line = hideEndDate || !endParts ? `${startDisplayDay} at ${startParts.time}` : startParts.calendarDay === endParts.calendarDay
+    ? `${startDisplayDay} · ${startParts.hour}:${startParts.minute}${startParts.period !== endParts.period ? ` ${startParts.period}` : ""} – ${endParts.time}`
+    : `${a} – ${b}`;
+  let zoneLine = "";
+  if (settings.showTimeZone && zone) zoneLine = formatTimeZoneLabel(start, zone, "en");
+  return { line, zone: zoneLine, start: start.getTime(), end: end?.getTime() ?? start.getTime() + 3600000 };
+}
+
+type EventDetailMoney = { formattedValue?: string; value?: string; currency?: string };
+
+function detailMoney(money?: EventDetailMoney): string {
+  if (money?.formattedValue) return money.formattedValue;
+  const value = money?.value;
+  if (value == null || String(value).trim() === "" || !money?.currency || !Number.isFinite(Number(value))) return "";
+  return formatCurrency(Number(value), money.currency, "en");
+}
+
+function detailPlace(e: WixEvent): { value: string; mapUrl: string; hideMapTap: boolean; icon: string } {
+  const raw = e as unknown as { location?: { type?: string; name?: string; locationTbd?: boolean; address?: { formattedAddress?: string; formatted?: string } | string } };
+  const place = raw.location;
+  const type = (place?.type ?? "").toUpperCase();
+  if (place?.locationTbd) return { value: place.name || detailCopy("event.locationTbd", "Location to be announced"), mapUrl: "", hideMapTap: true, icon: "location" };
+  if (type === "ONLINE") return { value: detailCopy("event.onlineEvent", "Online event"), mapUrl: "", hideMapTap: true, icon: "globe" };
+  const address = eventAddress({ ...e, location: { ...e.location, name: "" } } as WixEvent);
+  const value = [place?.name, address].filter(Boolean).join(", ") || place?.name || "";
+  const geo = (e.location as unknown as { coordinates?: { latitude?: number; longitude?: number; lat?: number; lng?: number }; location?: { latitude?: number; longitude?: number; lat?: number; lng?: number } })?.coordinates
+    ?? (e.location as unknown as { location?: { latitude?: number; longitude?: number; lat?: number; lng?: number } })?.location;
+  const hasCoordinates = typeof (geo?.latitude ?? geo?.lat) === "number" && typeof (geo?.longitude ?? geo?.lng) === "number";
+  const mapped = address || hasCoordinates ? eventMapUrl(e) : "";
+  return { value, mapUrl: mapped, hideMapTap: !mapped, icon: "location" };
+}
+
+function eventStatus(e: WixEvent): string {
+  const raw = e as unknown as { status?: string };
+  return (raw.status ?? e.eventStatus ?? "").toUpperCase();
+}
+
+function registrationUi(e: WixEvent, now: number): { state: string; label: string; action: string; caption: string; notice: string } {
+  const raw = e as unknown as { registration?: { status?: string; registrationPaused?: boolean; registrationDisabled?: boolean; allowedGuestTypes?: string; rsvp?: { startDate?: string }; tickets?: { soldOut?: boolean }; external?: { url?: string } }; form?: { messages?: { registrationClosed?: { message?: string; exploreEventsActionLabel?: string }; ticketsUnavailable?: { message?: string; exploreEventsActionLabel?: string } } } };
+  const r = raw.registration ?? {};
+  const status = eventStatus(e);
+  const type = registrationKindOf(e);
+  if (status === "CANCELED") return { state: "notice", label: "", action: "", caption: "", notice: detailCopy("event.canceledNotice", "This event was canceled.") };
+  if (status === "ENDED") return { state: "notice", label: "", action: "", caption: "", notice: detailCopy("event.endedNotice", "This event has ended.") };
+  if (type === "none" || r.registrationDisabled) return { state: "none", label: "", action: "", caption: "", notice: "" };
+  const ownerClosed = raw.form?.messages?.registrationClosed?.message;
+  const ownerSold = raw.form?.messages?.ticketsUnavailable?.message;
+  if (["CLOSED_AUTOMATICALLY", "CLOSED_MANUALLY"].includes(r.status || "") || r.registrationPaused) return { state: "notice", label: "", action: "", caption: "", notice: ownerClosed || detailCopy("event.closedNotice", "Registration is closed.") };
+  if (type === "tickets" && r.tickets?.soldOut) return { state: "notice", label: "", action: "", caption: "", notice: ownerSold || detailCopy("event.soldOutNotice", "Tickets are sold out.") };
+  if (r.status === "SCHEDULED_RSVP") return { state: "scheduled", label: detailCopy("event.rsvpCta", "RSVP"), action: "", caption: detailCopy("event.opensCaption", "RSVP opens {date}.").replace("{date}", r.rsvp?.startDate ? formatWeekdayDateTime(new Date(r.rsvp.startDate)) : ""), notice: "" };
+  if (r.status === "OPEN_RSVP_WAITLIST_ONLY") return { state: "waitlist", label: detailCopy("event.waitlistCta", "Join Waitlist"), action: "himi.open", caption: detailCopy("event.fullCaption", "This event is full."), notice: "" };
+  if (r.status === "OPEN_TICKETS" || type === "tickets") return { state: "tickets", label: detailCopy("event.ticketsCta", "Buy Tickets"), action: "openTickets", caption: "", notice: "" };
+  if (r.status === "OPEN_EXTERNAL" || type === "external") return registrationUrlOf(e)
+    ? { state: "external", label: detailCopy("event.externalCta", "Register"), action: "openRegistration", caption: "", notice: "" }
+    : { state: "none", label: "", action: "", caption: "", notice: "" };
+  if (type === "rsvp" && r.status === "OPEN_RSVP") return { state: "rsvp", label: detailCopy("event.rsvpCta", "RSVP"), action: "himi.open", caption: "", notice: "" };
+  if (r.status === "OPEN_RSVP" || (type === "rsvp" && !r.status)) return { state: "rsvp", label: detailCopy("event.rsvpCta", "RSVP"), action: "himi.open", caption: "", notice: "" };
+  void now;
+  return { state: "none", label: "", action: "", caption: "", notice: "" };
 }
 
 /** External registration URL / event page URL from the raw payload ("" when absent). */
@@ -365,48 +593,6 @@ export function eventPageUrlOf(e: WixEvent): string {
   return "";
 }
 
-/** Geo coordinates → a 0/1-entry marker set for the inline schematic map. */
-export function eventMapMarkers(e: WixEvent): MapMarker[] {
-  const loc = e.location as unknown as {
-    name?: string;
-    location?: { latitude?: number; longitude?: number; lat?: number; lng?: number };
-    coordinates?: { latitude?: number; longitude?: number; lat?: number; lng?: number };
-  } | undefined;
-  const geo = loc?.coordinates ?? loc?.location;
-  const latitude = geo?.latitude ?? geo?.lat;
-  const longitude = geo?.longitude ?? geo?.lng;
-  if (typeof latitude !== "number" || typeof longitude !== "number") return [];
-  return [{ latitude, longitude, ...(loc?.name ? { label: loc.name } : {}) }];
-}
-
-/** Best-effort attendee summary: "N going" + up-to-6 initials for the avatar
- *  strip. The guest-list endpoint is owner-scoped — a visitor rung throws and
- *  the caller collapses the strip (never fails the screen). */
-async function attendeeSummary(eventId: string): Promise<{ goingLabel: string; avatars: AttendeeAvatar[] }> {
-  const nameOf = (g: WixGuestRsvp | WixGuestTicket): string =>
-    [g.firstName, g.lastName].filter(Boolean).join(" ").trim();
-  try {
-    let list = await getEventGuestList(eventId, { ticketed: false });
-    if (!(list.rsvps?.length || list.total)) {
-      list = await getEventGuestList(eventId, { ticketed: true });
-    }
-    const guests: Array<WixGuestRsvp | WixGuestTicket> = list.rsvps?.length ? list.rsvps : (list.tickets ?? []);
-    const going = guests
-      .filter((g) => {
-        const status = (g.status ?? "").toUpperCase();
-        return !status || ["YES", "ARRIVED", "PAID", "FREE", "OFFLINE_PENDING", "WAITING"].includes(status);
-      });
-    const total = list.facets?.status?.total ?? list.total ?? going.length;
-    if (!total) return { goingLabel: "", avatars: [] };
-    return {
-      goingLabel: copyTemplate("event.goingLabel", "{count} going", { count: total }),
-      avatars: going.slice(0, 6).map((g) => ({ initials: initials(nameOf(g) || g.email || "Guest") })),
-    };
-  } catch {
-    return { goingLabel: "", avatars: [] };
-  }
-}
-
 /** The description pair: the v3 Ricos `description` for RichContent, and its plain text. A string description
  *  (or none) keeps `eventDescription`'s legacy read, with no document. */
 function eventBody(e: WixEvent): { description: string; descriptionJson: string } {
@@ -415,33 +601,41 @@ function eventBody(e: WixEvent): { description: string; descriptionJson: string
   return { description: bodyText, descriptionJson: bodyJson };
 }
 
-/** getEvent returns the slim BASE fieldset (no `registration`); enrich from the
- *  richer query when the type is unknown — best-effort, find-by-id. */
-async function enrichRegistration(id: string, e: WixEvent): Promise<WixEvent> {
-  if (e.eventType) return e;
+type WixCall = (method: string, path: string, body?: unknown) => Promise<unknown>;
+function wixCall(): WixCall | undefined { return (globalThis as { himalaya?: { wixApi?: { call?: WixCall } } }).himalaya?.wixApi?.call; }
+type OptionalRead = { ok: true; value: Record<string, unknown> } | { ok: false; code: "unavailable" };
+async function bestEffort(method: string, path: string, body?: unknown): Promise<OptionalRead> {
   try {
-    const list = await queryEvents({ limit: 100 });
-    const match = (list.events ?? []).find((candidate) => candidate.id === id);
-    if (!match) return e;
-    // [rico] #3372 — the query's rows are read without TEXTS, so they carry no Ricos `description`: keep the
-    // one this detail fetched, or the enrichment would silently drop the document on every real site.
-    const description = (e as unknown as { description?: unknown }).description;
-    return description === undefined ? match : ({ ...match, description } as unknown as WixEvent);
+    const call = wixCall();
+    return call ? { ok: true, value: await call(method, path, body) as Record<string, unknown> } : { ok: false, code: "unavailable" };
   } catch {
-    return e;
+    return { ok: false, code: "unavailable" };
   }
 }
+async function signedInMember(): Promise<boolean> {
+  try { const identity = await dispatch("himi.wix.memberIdentity") as { email?: string } | null; return !!identity?.email; } catch { return false; }
+}
 
-const defineService = withOnlineWrites(registerService, ["buyApple", "openRegistration"], {
+const defineService = withOnlineWrites(registerService, ["buyApple", "openRegistration", "checkout", "cancelRsvp"], {
   derive,
-  messageFields: ["actionMessage"],
+  messageFields: ["snackbarMessage"],
   requiresConnectivity: (action, state) => action !== "openRegistration"
     || (state.registrationKind === "tickets" && !!state.id && !isHostedWorker()),
 });
-const svc = defineService<S, {
+type DetailActions = {
   load: (s: S, arg?: unknown) => Promise<S | undefined>;
   openMap: (s: S) => Promise<S>;
-  selectTier: (s: S, arg?: unknown) => Promise<S | undefined>;
+  openTickets: (s: S) => Promise<S | undefined>;
+  closeTickets: (s: S) => S;
+  setQuantity: (s: S, arg?: unknown) => Promise<S | undefined>;
+  setGuestPrice: (s: S, arg?: unknown) => S;
+  checkout: (s: S) => Promise<S | undefined>;
+  openRsvpActions: (s: S) => S;
+  closeRsvpActions: (s: S) => S;
+  beginCancelRsvp: (s: S) => S;
+  keepRsvp: (s: S) => S;
+  cancelRsvp: (s: S) => Promise<S>;
+  noop: (s: S) => S;
   openRegistration: (s: S) => Promise<S>;
   share: (s: S) => Promise<S>;
   addToCalendar: (s: S) => Promise<S>;
@@ -452,16 +646,65 @@ const svc = defineService<S, {
   iapPublish: (s: S) => S;
   iapRefresh: (s: S) => Promise<S>;
   iapPoll: (s: S) => Promise<S>;
-}>("himiEventDetail", {
-  notHydrated: [...ATTENDANCE_NOT_HYDRATED, "ticketPurchaseBlocked"],
+};
+const svc: ReturnType<typeof defineService<S, DetailActions>> = defineService<S, DetailActions>("himiEventDetail", {
+  notHydrated: [...ATTENDANCE_NOT_HYDRATED, "ticketPurchaseBlocked", "ticketSheetOpen", "rsvpActionsOpen", "cancelConfirmOpen", "rsvpId", "rsvpState", "rsvpLabel"],
   state: derive({
     ...ATTENDANCE_INITIAL,
     status: "loading",
     id: inputId(),
     title: "",
-    initial: "E",
     when: "",
     location: "",
+    place: "",
+    placeIcon: "location",
+    noPlace: true,
+    hidePlaceStatic: true,
+    price: "",
+    zone: "",
+    noPrice: true,
+    hideMapTap: true,
+    shortDescription: "",
+    noShortDescription: true,
+    noDescription: true,
+    noDate: true,
+    dateNotTappable: true,
+    hideDateStatic: true,
+    registrationState: "none",
+    footerLabel: "",
+    footerAction: "",
+    footerCaption: "",
+    hideFooter: true,
+    noFooterButton: true,
+    noFooterCaption: true,
+    notice: "",
+    exploreLabel: detailCopy("event.exploreCta", "Explore Events"),
+    noNotice: true,
+    rsvpLabel: "",
+    rsvpId: "",
+    rsvpState: "none",
+    hideRsvpChip: true,
+    hideGoingChip: true,
+    hideWaitlistedChip: true,
+    hideCancelRsvp: true,
+    hideCancelConfirm: true,
+    hideRsvpOptions: false,
+    ticketSheetOpen: false,
+    rsvpActionsOpen: false,
+    cancelConfirmOpen: false,
+    ticketTotal: formatCurrency(0, "USD", "en"),
+    ticketCountLabel: copyParam("event.ticketCount", "{n} tickets, plus fees").replace("{n}", "0"),
+    checkoutDisabled: true,
+    schedule: [],
+    fullSchedule: [],
+    noSchedule: true,
+    noFullSchedule: true,
+    moreDates: [],
+    allDates: [],
+    noMoreDates: true,
+    noAllDates: true,
+    policies: [],
+    noPolicies: true,
     description: "",
     descriptionJson: "",
     hasDescriptionJson: false,
@@ -469,24 +712,25 @@ const svc = defineService<S, {
     hasImage: false,
     noImage: true,
     mapUrl: "",
-    noMap: true,
-    mapMarkers: [],
-    hasMapMarkers: false,
-    noMapMarkers: true,
-    goingLabel: "",
-    attendeeAvatars: [],
-    hasAttendees: false,
-    noAttendees: true,
     registrationKind: "rsvp",
     ticketPurchaseBlocked: true,
-    regularTicketsHidden: true,
     showRsvp: true,
     hideRsvp: false,
     showTickets: false,
     hideTickets: true,
     showExternal: false,
     hideExternal: true,
+    hideScheduled: true,
+    hideWaitlist: true,
+    memberOnly: false,
+    hideMemberRsvp: true,
+    hideMemberWaitlist: true,
+    hideMemberTickets: true,
+    hideMemberScheduled: true,
     ticketTiers: [],
+    ticketCurrency: "USD",
+    ticketLimitPerOrder: 99,
+    regularTicketsHidden: true,
     hasTiers: false,
     noTiers: true,
     showTierPicker: false,
@@ -498,9 +742,9 @@ const svc = defineService<S, {
     shareUrl: "",
     calendarStart: 0,
     calendarEnd: 0,
-    actionMessage: "",
+    snackbarMessage: "",
+    noSnackbar: true,
     isAddingCalendar: false,
-    statusLabel: "",
     emptyText: "",
     errored: false,
     notErrored: true,
@@ -509,18 +753,285 @@ const svc = defineService<S, {
     noEmpty: true,
   }),
   actions: {
-    iapPublish: (s) => derive(lastReady ?? s),
+    openTickets: async (s) => {
+      if (s.ticketTiers.length) return derive({ ...s, ticketSheetOpen: true });
+      const version = ticketSelectionVersion;
+      const loaded = await loadTiers(s.id);
+      const current = svc.getState();
+      if (version !== ticketSelectionVersion || current.id !== s.id) return;
+      if (!loaded.rows.length) return derive({ ...current, ticketSheetOpen: false, snackbarMessage: detailCopy("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+      paymentTickets = loaded.tickets;
+      ticketSelectionState = derive({ ...current, ticketTiers: loaded.rows.map((row) => ({ ...row, rowLimit: Math.min(row.rowLimit ?? 99, s.ticketLimitPerOrder) })), ticketCurrency: loaded.tickets.values().next().value?.price?.currency || s.ticketCurrency, ticketSheetOpen: true, snackbarMessage: "" });
+      lastReady = ticketSelectionState;
+      return ticketSelectionState;
+    },
+    closeTickets: (s) => derive({ ...s, ticketSheetOpen: false }),
+    openRsvpActions: (s) => derive({ ...s, rsvpActionsOpen: true, cancelConfirmOpen: false, snackbarMessage: "" }),
+    closeRsvpActions: (s) => derive({ ...s, rsvpActionsOpen: false, cancelConfirmOpen: false }),
+    beginCancelRsvp: (s) => derive({ ...s, cancelConfirmOpen: !!s.rsvpId, snackbarMessage: "" }),
+    keepRsvp: (s) => derive({ ...s, cancelConfirmOpen: false }),
+    cancelRsvp: async (s): Promise<S> => {
+      if (!s.rsvpId || !s.id || cancelRsvpInFlight) return derive({ ...s, rsvpActionsOpen: false, cancelConfirmOpen: false });
+      cancelRsvpInFlight = true;
+      try {
+        const call = wixCall();
+        if (!call) throw new Error("Wix API is unavailable");
+        await call("DELETE", `/events/v2/rsvps/${encodeURIComponent(s.rsvpId)}`);
+        forgetRsvp(s.id);
+        return derive({
+          ...s,
+          rsvpId: "",
+          rsvpState: "none",
+          rsvpLabel: "",
+          rsvpActionsOpen: false,
+          cancelConfirmOpen: false,
+          snackbarMessage: copyParam("event.rsvpCanceled", "Your RSVP is canceled."),
+        });
+      } catch {
+        return derive({
+          ...s,
+          rsvpActionsOpen: false,
+          cancelConfirmOpen: false,
+          snackbarMessage: copyParam("event.cancelFailed", "Couldn't cancel your RSVP. Try again."),
+        });
+      } finally {
+        cancelRsvpInFlight = false;
+      }
+    },
+    noop: (s) => derive(s),
+    setQuantity: async (inputState, arg): Promise<S | undefined> => {
+      if (ticketCheckoutInFlight) return derive(inputState);
+      const input = arg as { id?: string; value?: number; quantity?: number } | undefined;
+      const id = typeof input === "string" ? input : input?.id;
+      const next = Number(input?.value ?? input?.quantity ?? 0);
+      if (!id || !Number.isFinite(next)) return derive(inputState);
+      // Invalidate the previous Apple form synchronously with the row action.
+      // A purchase tapped before the async route/price checks finish must not
+      // submit details belonging to the ticket that was selected previously.
+      const version = ++ticketSelectionVersion;
+      ticketCheckoutDenied = false;
+      applePurchase.invalidate();
+      ticketSelectionQueue = ticketSelectionQueue.catch(() => {}).then(async () => {
+        if (ticketCheckoutInFlight) return;
+        // Worker actions can overlap while capability checks await. Start each
+        // update from the last selection so edits to independent rows compose.
+        const serviceState = svc.getState();
+        const base = serviceState.status === "ready" && serviceState.id === inputState.id ? { ...inputState, ...serviceState } : inputState;
+        const s = ticketSelectionState?.status === "ready" && ticketSelectionState.id === base.id
+          ? { ...base, selectedTierId: ticketSelectionState.selectedTierId, ticketTiers: ticketSelectionState.ticketTiers }
+          : base;
+        const ticketTiers = s.ticketTiers.map((row) => row.id !== id || !row.available ? row : { ...row, quantity: Math.max(0, Math.min(row.maxQuantity ?? 99, Math.floor(next))) });
+        const chosen = ticketTiers.filter((row) => (row.quantity ?? 0) > 0);
+        let selectedTierId = s.selectedTierId;
+        if (chosen.length === 1) selectedTierId = chosen[0]!.id;
+        else if (chosen.length === 0 && id === selectedTierId) selectedTierId = ticketTiers.find((row) => row.available)?.id ?? "";
+        const selected = ticketTiers.find((row) => row.id === selectedTierId);
+        let regularAllowed: boolean;
+        if (chosen.length <= 1 && (chosen.length === 0 || chosen[0]!.quantity === 1)) {
+          regularAllowed = await mayUseRegularTicketCheckout(paymentEvent, selected ? selectedPaymentTicket(selected) : undefined);
+        } else {
+          regularAllowed = (await Promise.all(chosen.map((row) => mayUseRegularTicketCheckout(paymentEvent, selectedPaymentTicket(row))))).every(Boolean);
+        }
+        if (version === ticketSelectionVersion) ticketCheckoutAllowed = regularAllowed;
+        const selectionState = derive({ ...s, selectedTierId, ticketTiers: ticketTiers.map((row) => ({ ...row, isSelected: row.id === selectedTierId, notSelected: row.id !== selectedTierId })) });
+        ticketSelectionState = selectionState;
+        if (selectionState.status === "ready") lastReady = selectionState;
+        if (version === ticketSelectionVersion && selectedTierId && chosen.length === 1 && !regularAllowed) {
+          const ticketId = selected?.ticketDefinitionId ?? selectedTierId;
+          if (!await priceTicket(paymentEvent, ticketId, version, selected ? selectedPaymentTicket(selected) : undefined)) return;
+        }
+        // Keep edits and sheet state made while route and price checks awaited.
+        const currentServiceState = svc.getState();
+        const latest = currentServiceState.status === "ready" && currentServiceState.id === s.id ? { ...s, ...currentServiceState } : s;
+        const quantities = new Map(ticketTiers.map((row) => [row.id, row.quantity ?? 0]));
+        const latestRows = latest.ticketTiers.map((row) => ({ ...row, quantity: quantities.get(row.id) ?? row.quantity ?? 0, isSelected: row.id === selectedTierId, notSelected: row.id !== selectedTierId }));
+        ticketSelectionState = derive({ ...latest, selectedTierId, ticketTiers: latestRows });
+        if (ticketSelectionState.status === "ready") lastReady = ticketSelectionState;
+      });
+      await ticketSelectionQueue;
+      return ticketSelectionState;
+    },
+    setGuestPrice: (s, arg) => {
+      if (ticketCheckoutInFlight) return derive(s);
+      const input = arg as { id?: string; value?: string; text?: string } | undefined;
+      const id = input?.id;
+      const value = String(input?.value ?? input?.text ?? "").replace(/[^\d.]/g, "");
+      if (!id || !/^\d*(?:\.\d{0,2})?$/.test(value)) return derive(s);
+      ticketSelectionState = derive({ ...s, ticketTiers: s.ticketTiers.map((row) => row.id === id ? { ...row, guestPrice: value, priceAmount: Number(value || row.minPrice || 0) } : row) });
+      if (ticketSelectionState.status === "ready") lastReady = ticketSelectionState;
+      return ticketSelectionState;
+    },
+    checkout: async (initial) => {
+      if (ticketCheckoutInFlight) return derive(initial);
+      // A Stepper action can still be awaiting its IAP/price route check when
+      // Checkout is tapped. Wait until the selection queue stops growing, then
+      // take the service's latest state before validating or reserving.
+      while (true) {
+        const pendingSelection = ticketSelectionQueue;
+        await pendingSelection;
+        if (pendingSelection === ticketSelectionQueue) break;
+      }
+      if (ticketCheckoutInFlight) return derive(svc.getState());
+      const current = svc.getState();
+      let s = ticketSelectionState?.status === "ready" && ticketSelectionState.id === initial.id
+        ? ticketSelectionState
+        : current.status === "ready" && current.id === initial.id ? current : initial;
+      const quantities = s.ticketTiers.filter((row) => row.available && (row.quantity ?? 0) > 0).map((row) => ({ ticketDefinitionId: row.ticketDefinitionId ?? row.id, quantity: row.quantity ?? 0, ...(row.isGuestPrice ? { priceOverride: row.guestPrice } : {}), ...(row.pricingOptionId ? { ticketDetails: [{ pricingOptionId: row.pricingOptionId }] } : {}) }));
+      const guestPriceInvalid = s.ticketTiers.some((row) => row.isGuestPrice && (row.quantity ?? 0) > 0 && (!String(row.guestPrice ?? "").trim() || !Number.isFinite(Number(row.guestPrice)) || Number(row.guestPrice) < (row.minPrice ?? 0)));
+      const aggregateInvalid = s.ticketTiers.some((row) => {
+        const definitionId = row.ticketDefinitionId ?? row.id;
+        const definitionQuantity = s.ticketTiers.reduce((sum, other) => sum + ((other.ticketDefinitionId ?? other.id) === definitionId ? other.quantity ?? 0 : 0), 0);
+        return (row.quantity ?? 0) > (row.maxQuantity ?? 99) || definitionQuantity > (row.rowLimit ?? 99);
+      });
+      if (ticketCheckoutInFlight) return derive(s);
+      if (quantities.length === 0) return derive({ ...s, snackbarMessage: detailCopy("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+      if (guestPriceInvalid || aggregateInvalid || quantities.reduce((sum, row) => sum + row.quantity, 0) > s.ticketLimitPerOrder) return derive(s);
+      ticketCheckoutInFlight = true;
+      let reservationId = "";
+      let result: S | undefined;
+      try {
+        // Re-read ticket definitions immediately before checkout. A free ticket
+        // can become paid (or an IAP ticket) while this screen is open; in that
+        // case the regular Events reservation API must not run.
+        const latestResponse = await queryAvailableTickets(s.id);
+        const latestDefinitions = latestResponse.definitions ?? [];
+        const fresh = loadedTiers(latestDefinitions);
+        const latestTickets = fresh.tickets;
+        const previousSelected = s.ticketTiers.filter((row) => (row.quantity ?? 0) > 0);
+        const previousRows = new Map(s.ticketTiers.map((row) => [row.id, row]));
+        const refreshedByDefinition = new Map<string, number>();
+        let refreshedCount = 0;
+        const refreshedRows = fresh.rows.map((row) => {
+          const previous = previousRows.get(row.id);
+          const definitionId = row.ticketDefinitionId ?? row.id;
+          const rowLimit = Math.min(row.rowLimit ?? 99, s.ticketLimitPerOrder);
+          const used = refreshedByDefinition.get(definitionId) ?? 0;
+          const quantity = row.available ? Math.max(0, Math.min(previous?.quantity ?? 0, rowLimit - used, s.ticketLimitPerOrder - refreshedCount)) : 0;
+          refreshedByDefinition.set(definitionId, used + quantity);
+          refreshedCount += quantity;
+          return { ...row, rowLimit,
+            quantity, guestPrice: previous?.guestPrice ?? "",
+            priceAmount: row.isGuestPrice ? Number(previous?.guestPrice || row.minPrice || 0) : row.priceAmount,
+            isSelected: row.id === s.selectedTierId, notSelected: row.id !== s.selectedTierId };
+        });
+        const termsChanged = previousSelected.some((previous) => {
+          const row = refreshedRows.find((next) => next.id === previous.id);
+          return !row || row.priceAmount !== previous.priceAmount || row.minPrice !== previous.minPrice
+            || row.isGuestPrice !== previous.isGuestPrice || row.available !== previous.available
+            || row.rowLimit !== previous.rowLimit || row.quantity !== previous.quantity
+            || latestTickets.get(previous.ticketDefinitionId ?? previous.id)?.price?.currency !== paymentTickets.get(previous.ticketDefinitionId ?? previous.id)?.price?.currency;
+        });
+        const current = svc.getState();
+        s = { ...s, ...(current.status === "ready" && current.id === s.id ? current : {}), ticketTiers: refreshedRows,
+          ticketCurrency: latestTickets.values().next().value?.price?.currency || s.ticketCurrency };
+        const selectedRows = refreshedRows.filter((row) => (row.quantity ?? 0) > 0);
+        const latestSelected = selectedRows.map((row) => selectedPaymentTicket(row, latestTickets));
+        const routesAllowed = selectedRows.length === previousSelected.length
+          && latestSelected.every((ticket) => !!ticket && tierAvailable(ticket))
+          && (await Promise.all(latestSelected.map((ticket) => mayUseRegularTicketCheckout(paymentEvent, ticket)))).every(Boolean);
+        if (!routesAllowed) {
+          paymentTickets = latestTickets;
+          ticketCheckoutAllowed = false;
+          ticketCheckoutDenied = true;
+          if (selectedRows.length === 1 && selectedRows[0]!.quantity === 1) {
+            await priceTicket(paymentEvent, selectedRows[0]!.ticketDefinitionId ?? selectedRows[0]!.id, ticketSelectionVersion, latestSelected[0]);
+          }
+          const current = svc.getState();
+          const latest = current.status === "ready" && current.id === s.id ? { ...s, ...current } : s;
+          result = derive({ ...latest, ticketTiers: refreshedRows, ticketCurrency: s.ticketCurrency, snackbarMessage: copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") });
+          ticketSelectionState = result;
+          if (result.status === "ready") lastReady = result;
+        } else {
+          paymentTickets = latestTickets;
+          ticketCheckoutAllowed = true;
+          ticketCheckoutDenied = false;
+          if (termsChanged) {
+            ticketCheckoutInFlight = false;
+            result = derive({ ...s, snackbarMessage: detailCopy("event.ticketsChanged", "Ticket details changed. Review your selection and try again.") });
+            ticketSelectionState = result;
+            lastReady = result;
+          } else if (isHostedWorker()) {
+            if (hostedOpenInFlight) result = derive(svc.getState());
+            else {
+              hostedOpenInFlight = true;
+              try {
+                const opened = await hostedSitePageOpener({ page: "event", eventId: s.id })(async () => {
+                  try {
+                    const fresh = await queryAvailableTickets(s.id);
+                    const byId = new Map((fresh.definitions ?? []).filter((ticket) => ticket.id).map((ticket) => [ticket.id!, ticket]));
+                    const freshSelected = selectedRows.map((row) => selectedPaymentTicket(row, byId));
+                    const stillAllowed = freshSelected.every((ticket) => !!ticket && tierAvailable(ticket))
+                      && (await Promise.all(freshSelected.map((ticket) => mayUseRegularTicketCheckout(paymentEvent, ticket)))).every(Boolean);
+                    if (stillAllowed) paymentTickets = byId;
+                    return stillAllowed;
+                  } catch { return false; }
+                });
+                const latestServiceState = svc.getState();
+                const latest = latestServiceState.status === "ready" && latestServiceState.id === s.id ? { ...s, ...latestServiceState } : s;
+                result = opened === true
+                  ? { ...latest, ticketSheetOpen: false, snackbarMessage: detailCopy("event.checkoutOpened", "Complete checkout in the browser to get your tickets.") }
+                  : opened === "withdrawn" ? latest : { ...latest, snackbarMessage: detailCopy("event.registrationOpenFailed", "Could not open the registration page.") };
+              } finally { hostedOpenInFlight = false; }
+            }
+          } else {
+            const held = await createTicketReservation(s.id, quantities);
+            if (!held.id) throw new Error("Reservation did not return an id");
+            reservationId = held.id;
+            const placed = await checkoutReservation(s.id, held.id);
+            const snapshotId = placed.order?.snapshotId ?? "";
+            if (!snapshotId) result = { ...s, ticketSheetOpen: false, snackbarMessage: detailCopy("event.ticketIssued", "You're in — your ticket is confirmed.") };
+            else {
+              const msid = await wixPlatformSession.signedInstanceStatus().then((st) => st.msid ?? "").catch(() => "");
+              const pay = await payCashierOrder({ appId: WIX_EVENTS_APP_ID, snapshotId, msid, amount: placed.order?.totalPrice?.amount, currency: placed.order?.totalPrice?.currency, cashierUrl: async () => (await createRedirectSession({ eventsCheckout: { reservationId: held.id! } })).redirectSession?.fullUrl });
+              if (pay.kind === "paid") result = { ...s, ticketSheetOpen: false, snackbarMessage: detailCopy("event.ticketIssued", "You're in — your ticket is confirmed.") };
+              else if (pay.kind === "handoff") result = { ...s, ticketSheetOpen: false, snackbarMessage: detailCopy("event.checkoutOpened", "Complete checkout in the browser to get your tickets.") };
+              else if (pay.kind === "cancelled") result = { ...s, snackbarMessage: detailCopy("event.ticketCancelled", "Payment cancelled — no ticket was issued.") };
+              else throw new Error("Payment could not be completed");
+            }
+          }
+        }
+      } catch {
+        try {
+          // A public event page is not pinned to this selection or price. Only
+          // continue in hosted checkout when a reservation already holds it.
+          const params = reservationId ? { reservationId } : undefined;
+          if (params) {
+            const redirect = await createRedirectSession({ eventsCheckout: params });
+            const url = redirect.redirectSession?.fullUrl;
+            if (url) {
+              const opened = await open(url, "in_app_browser");
+              result = { ...s, ticketSheetOpen: false, snackbarMessage: opened.opened ? detailCopy("event.checkoutOpened", "Complete checkout in the browser to get your tickets.") : detailCopy("event.registrationOpenFailed", "Could not open the registration page.") };
+            }
+          }
+        } catch { /* report below */ }
+        if (!result) result = { ...s, snackbarMessage: detailCopy("event.purchaseUnavailable", "Purchasing is temporarily unavailable.") };
+      } finally { ticketCheckoutInFlight = false; }
+      return derive(result!);
+    },
+    iapPublish: (s) => {
+      // Prefer the live ready state so an asynchronous StoreKit publication
+      // cannot overwrite a newer selection or checkout snackbar with the
+      // original load snapshot.
+      const next = derive(s.status === "ready" ? s : lastReady ?? s);
+      if (next.status === "ready") lastReady = next;
+      return next;
+    },
     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 });
+      const selected = s.ticketTiers.find((t) => t.id === s.selectedTierId);
+      if (!selected || !selected.available || selected.quantity !== 1 || s.ticketTiers.some((t) => t.id !== s.selectedTierId && (t.quantity ?? 0) > 0)) return derive(s);
+      await applePurchase.buy({ key: selected.ticketDefinitionId ?? selected.id, eventId: s.id });
       return derive(svc.getState());
     },
     load: async (s: S, arg?: unknown): Promise<S | undefined> => {
       const selectionVersion = ++ticketSelectionVersion;
       ticketCheckoutAllowed = false;
+      ticketCheckoutDenied = false;
+      ticketSelectionState = undefined;
+      lastReady = undefined;
+      s = { ...s, ticketSheetOpen: false, rsvpActionsOpen: false, cancelConfirmOpen: false, rsvpId: "", rsvpState: "none", rsvpLabel: "" };
       applePurchase.invalidate();
       stashCopy(arg);
       const id = s.id || inputId();
@@ -531,72 +1042,164 @@ const svc = defineService<S, {
         // URLS adds `eventPageUrl` — the registration fallback and the share link. Without URLS a
         // ticket flow that cannot complete in-app had no page to send the buyer to.
         const res = await getEvent(id, { fields: EVENT_DETAIL_FIELDSETS });
-        let e = ((res as unknown as { event?: WixEvent }).event ?? res) as WixEvent;
-        e = await enrichRegistration(id, e);
-        const attendees = await attendeeSummary(id);
+        const e = ((res as unknown as { event?: WixEvent }).event ?? res) as WixEvent;
         // Ticketed events load their tiers with the event, so the price is on
         // 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 loaded = kind === "tickets" ? await loadTiers(id) : { rows: [], tickets: new Map<string, WixAvailableTicket>() };
-        const tiers = loaded.rows;
+        const orderLimit = Number((e as unknown as { registration?: { tickets?: { ticketLimitPerOrder?: number } } }).registration?.tickets?.ticketLimitPerOrder ?? 99);
+        const tiers = loaded.rows.map((row) => ({ ...row, rowLimit: Math.min(row.rowLimit ?? 99, orderLimit), maxQuantity: Math.min(row.maxQuantity ?? 99, orderLimit) }));
         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));
+        const selectedTicketId = tiers.find((row) => row.id === selectedTierId)?.ticketDefinitionId ?? selectedTierId;
+        const regular = kind !== "tickets" || await mayUseRegularTicketCheckout(e, loaded.tickets.get(selectedTicketId));
         if (selectionVersion !== ticketSelectionVersion) return undefined;
         paymentEvent = e;
         paymentTickets = loaded.tickets;
         ticketCheckoutAllowed = regular;
-        if (kind === "tickets" && !await priceTicket(e, selectedTierId, selectionVersion)) return undefined;
+        if (kind === "tickets" && !await priceTicket(e, selectedTicketId, 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));
         const image = eventImage(e);
-        const title = e.title || "Event";
-        return derive({
+        const title = e.title || "";
+        const dates = detailDate(e);
+        const place = detailPlace(e);
+        const registration = registrationUi(e, Date.now());
+        const rawEvent = e as unknown as { shortDescription?: string; agendaSettings?: { enabled?: boolean }; dateAndTimeSettings?: { recurrenceStatus?: string; recurringEvents?: { categoryId?: string } }; registration?: { allowedGuestTypes?: string; tickets?: { lowestPrice?: EventDetailMoney; highestPrice?: EventDetailMoney } } };
+        const lowest = detailMoney(rawEvent.registration?.tickets?.lowestPrice);
+        const highest = detailMoney(rawEvent.registration?.tickets?.highestPrice);
+        const price = kind === "tickets" && lowest ? (highest && highest !== lowest ? detailCopy("event.priceFrom", "From {price}").replace("{price}", lowest) : lowest) : "";
+        const memberProbeNeeded = kind === "rsvp" || rawEvent.registration?.allowedGuestTypes === "MEMBER";
+        const isMember = memberProbeNeeded ? await signedInMember() : false;
+        const [scheduleResponse, policyResponse, rsvpResponse] = await Promise.all([
+          rawEvent.agendaSettings?.enabled ? bestEffort("GET", `/events/v1/schedule?eventId=${encodeURIComponent(id)}`) : undefined,
+          bestEffort("POST", "/events-policies/v2/policies/query", { query: { filter: { eventId: { $eq: id } }, paging: { limit: 100 } } }),
+          kind === "rsvp" && isMember ? bestEffort("GET", `/events/v2/rsvps/current?eventId=${encodeURIComponent(id)}`) : undefined,
+        ]);
+        let optionalReadFailed = [scheduleResponse, policyResponse, rsvpResponse].some((response) => response?.ok === false);
+        const scheduleRaw = (scheduleResponse?.ok ? scheduleResponse.value : undefined) as { agenda?: Array<Record<string, unknown>>; schedule?: Array<Record<string, unknown>>; items?: Array<Record<string, unknown>>; agendaItems?: Array<Record<string, unknown>> } | undefined;
+        const fullSchedule = (scheduleRaw?.agenda ?? scheduleRaw?.agendaItems ?? scheduleRaw?.schedule ?? scheduleRaw?.items ?? []).map((item) => {
+          const slot = item.timeSlot as { start?: string; end?: string; timeZoneId?: string } | undefined;
+          const start = String(slot?.start ?? item.startTime ?? item.startDate ?? item.time ?? "");
+          const date = start ? new Date(start) : undefined;
+          return {
+            time: date && !Number.isNaN(date.getTime()) ? formatWeekdayDateTime(date, "en-US", slot?.timeZoneId) : start,
+            name: String(item.name ?? item.title ?? ""),
+            detail: String(item.stageName ?? item.stage ?? item.host ?? ""),
+          };
+        });
+        const scheduleItems = fullSchedule.slice(0, 3);
+        const rawPolicies = (((policyResponse?.ok ? policyResponse.value : undefined) as { policies?: Array<Record<string, unknown>> } | undefined)?.policies ?? []);
+        const policies = rawPolicies.map((policy) => ({ name: String(policy.name ?? ""), text: String(policy.body ?? "") })).filter((policy) => policy.name || policy.text);
+        const rsvpPayload = (rsvpResponse?.ok ? rsvpResponse.value : undefined) as { rsvps?: Array<{ id?: string; status?: string }>; rsvp?: { id?: string; status?: string } } | undefined;
+        const rsvps = rsvpPayload?.rsvps ?? (rsvpPayload?.rsvp ? [rsvpPayload.rsvp] : []);
+        const heldRsvp = rsvps.find((r) => ["YES", "WAITLIST", "WAITING"].includes((r.status ?? "").toUpperCase()));
+        const rsvpState = !heldRsvp ? "none" : /(WAITLIST|WAITING)/i.test(heldRsvp.status ?? "") ? "waitlist" : "going";
+        const rsvpLabel = rsvpState === "waitlist" ? detailCopy("event.waitlisted", "You're on the waitlist") : rsvpState === "going" ? detailCopy("event.going", "You're going") : "";
+        const memberOnly = rawEvent.registration?.allowedGuestTypes === "MEMBER" && !isMember && ["rsvp", "waitlist", "tickets", "scheduled"].includes(registration.state);
+        const registrationRaw = rawEvent.registration as { status?: string; registrationPaused?: boolean; tickets?: { soldOut?: boolean } } | undefined;
+        const registrationClosed = !!registrationRaw?.registrationPaused || ["CLOSED_AUTOMATICALLY", "CLOSED_MANUALLY"].includes(registrationRaw?.status ?? "");
+        const soldOut = kind === "tickets" && !!registrationRaw?.tickets?.soldOut;
+        const formMessages = (e as unknown as { form?: { messages?: { registrationClosed?: { exploreEventsActionLabel?: string }; ticketsUnavailable?: { exploreEventsActionLabel?: string } } } }).form?.messages;
+        const exploreLabel = registrationClosed
+          ? formMessages?.registrationClosed?.exploreEventsActionLabel
+          : soldOut ? formMessages?.ticketsUnavailable?.exploreEventsActionLabel : undefined;
+        let moreDates: Array<{ id: string; date: string }> = [];
+        const recurrence = rawEvent.dateAndTimeSettings?.recurringEvents;
+        if (recurrence?.categoryId && rawEvent.dateAndTimeSettings?.recurrenceStatus !== "ONE_TIME") {
+          try {
+            const series: WixEvent[] = [];
+            // The Events V3 category endpoint is the supported scoped series read.
+            // Page in bounded batches, since a single 100-row response can omit later dates.
+            for (let offset = 0; offset < 1000; offset += 100) {
+              const page = await bestEffort("GET", `/events/v3/events/category/${encodeURIComponent(recurrence.categoryId)}?paging.limit=100&paging.offset=${offset}&fields=DETAILS&fields=TEXTS&fields=REGISTRATION`);
+              if (!page.ok) { optionalReadFailed = true; break; }
+              const pageEvents = (page.value.events ?? []) as WixEvent[];
+              series.push(...pageEvents);
+              if (pageEvents.length < 100) break;
+            }
+            const now = Date.now();
+            moreDates = series.filter((item) => {
+              const itemRaw = item as unknown as { status?: string; dateAndTimeSettings?: { recurringEvents?: { categoryId?: string } } };
+              const start = eventStartMillis(item);
+              return item.id !== id && itemRaw.dateAndTimeSettings?.recurringEvents?.categoryId === recurrence.categoryId && !["ENDED", "CANCELED", "DRAFT"].includes((itemRaw.status ?? "").toUpperCase()) && (start == null || start >= now);
+            }).sort((a, b) => (eventStartMillis(a) ?? 0) - (eventStartMillis(b) ?? 0)).map((item) => ({ id: item.id ?? "", date: eventWhen(item) })).filter((item) => !!item.id);
+          } catch { moreDates = []; optionalReadFailed = true; }
+        }
+        const readyState = derive({
           ...s,
           status: "ready",
           errored: false,
           id,
           ticketTiers: tiers,
+          ticketCurrency: (e as unknown as { registration?: { tickets?: { currency?: string } } }).registration?.tickets?.currency || loaded.tickets.values().next().value?.price?.currency || "USD",
+          ticketLimitPerOrder: orderLimit,
           // Default the pick to the cheapest AVAILABLE tier so the CTA is never
           // dead; the buyer's tap overrides it from there.
           selectedTierId,
           title,
-          initial: (title.trim()[0] || "E").toUpperCase(),
-          when: eventWhen(e),
+          when: dates.line,
           location: eventLocation(e),
+          place: place.value,
+          placeIcon: place.icon,
+          noPlace: !place.value,
+          hidePlaceStatic: !place.value || !!place.mapUrl,
+          price,
+          zone: dates.zone,
+          mapUrl: place.mapUrl,
+          shortDescription: rawEvent.shortDescription || "",
+          noShortDescription: !rawEvent.shortDescription || rawEvent.shortDescription === eventBody(e).description,
+          noDescription: !eventBody(e).description && !eventBody(e).descriptionJson,
+          noDate: !dates.line,
+          registrationState: registration.state,
+          footerLabel: registration.label,
+          footerAction: registration.action,
+          footerCaption: memberOnly ? (kind === "tickets" ? detailCopy("event.membersOnlyTickets", "Only members can buy tickets.") : detailCopy("event.membersOnlyRsvp", "Only members can RSVP.")) : registration.caption,
+          memberOnly,
+          notice: registration.notice,
+          exploreLabel: exploreLabel || detailCopy("event.exploreCta", "Explore Events"),
+          rsvpLabel,
+          rsvpId: heldRsvp?.id ?? "",
+          rsvpState,
+          schedule: scheduleItems,
+          fullSchedule: fullSchedule.slice(3),
+          noSchedule: scheduleItems.length === 0,
+          policies,
+          noPolicies: policies.length === 0,
+          moreDates: moreDates.slice(0, 3),
+          allDates: moreDates.slice(3),
+          noMoreDates: moreDates.length === 0,
           // The Ricos description when the event has one (its own text is the plain copy); the legacy
           // string fields otherwise.
           ...eventBody(e),
           image,
           hasImage: !!image,
           noImage: !image,
-          mapUrl: eventMapUrl(e),
-          mapMarkers: eventMapMarkers(e),
-          goingLabel: attendees.goingLabel,
-          attendeeAvatars: attendees.avatars,
+          hideMapTap: place.hideMapTap,
           registrationKind: registrationKindOf(e),
           registrationUrl: registrationUrlOf(e),
           eventSlug: eventSlugOf(e),
           shareUrl: eventPageUrlOf(e),
-          calendarStart: eventStartMillis(e) ?? 0,
-          calendarEnd: eventEndMillis(e) ?? 0,
-          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),
+          calendarStart: dates.start,
+          calendarEnd: dates.end,
+          snackbarMessage: optionalReadFailed ? detailCopy("event.detailsUnavailable", "Some event details couldn't load. Try again.") : "",
         });
-      } catch {
+        ticketSelectionState = readyState;
+        lastReady = readyState;
+        return readyState;
+      } catch (error) {
         // 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";
-          return derive({
+          const cachedState = derive({
             ...s,
             status: "ready",
             errored: false,
             id,
             title,
-            initial: (title.trim()[0] || "E").toUpperCase(),
             when: cached.dateLine,
             location: cached.location,
             // The cached list row carries no description: an offline retry of THIS event keeps the pair it
@@ -605,193 +1208,31 @@ const svc = defineService<S, {
             image: cached.image,
             hasImage: !!cached.image,
             noImage: !cached.image,
-            statusLabel: titleCase(cached.status),
           });
+          lastReady = cachedState;
+          return cachedState;
         }
-        return derive({ ...s, status: "ready", errored: true, title: "" });
+        const errorState = derive({ ...s, status: "ready", errored: true, title: "" });
+        lastReady = errorState;
+        return errorState;
       }
     },
     openMap: async (s) => {
-      if (!s.mapUrl) return derive({ ...s, actionMessage: copyParam("event.noMapMessage", "This event does not have a mapped location yet.") });
+      if (!s.mapUrl) return derive({ ...s, snackbarMessage: copyParam("event.noMapMessage", "This event does not have a mapped location yet.") });
       try {
         const result = await open(s.mapUrl, "external_app");
-        return derive({ ...s, actionMessage: result.opened ? "" : copyParam("event.mapOpenFailed", "Could not open maps on this device.") });
+        return derive({ ...s, snackbarMessage: result.opened ? "" : copyParam("event.mapOpenFailed", "Could not open maps on this device.") });
       } catch {
-        return derive({ ...s, actionMessage: copyParam("event.mapOpenFailed", "Could not open maps on this device.") });
+        return derive({ ...s, snackbarMessage: copyParam("event.mapOpenFailed", "Could not open maps on this device.") });
       }
     },
-    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: ticketCheckoutAllowed || !applePurchase.fields(true, false).iapBuyHidden ? "" : copyParam("event.purchaseUnavailable", "Purchasing is temporarily unavailable."),
-      });
-    },
     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
-      // otherwise. A FREE ticket comes back with no `snapshotId` and is already
-      // confirmed — no payment step at all, which the hosted redirect made
-      // needlessly heavy.
-      //
-      // Every failure degrades one rung at a time, never to a dead button:
-      //   native chain → hosted eventsCheckout (pinned to the SAME reservation
-      //   when we got one, else the slug) → the event page / registration URL.
-      // Hosted inside a host shell (Spaces) neither in-app rung can finish: the classic
-      // `checkoutReservation` needs a buyer + guest form this screen does not collect, and the
-      // redirect session needs a headless OAuth client a hosted app does not have. Skip both —
-      // the native chain would also leave a ticket reservation held for nothing — and open the
-      // event's own page, where the member registers on the site: signed in by the host where it can
-      // (`himi.host.memberSitePage`), else as a visitor.
-      if (s.registrationKind === "tickets" && s.id && !isHostedWorker()) {
-        let reservationId = "";
-        try {
-          // Buy what the buyer PICKED. `load` seeds the pick with the cheapest
-          // available tier so the CTA is never dead, and `selectTier` follows the
-          // tap after that — silently charging for the cheapest tier when a buyer
-          // had chosen another one would be the wrong kind of "helpful".
-          //
-          // The re-read is deliberate: the tier list on screen may be seconds or
-          // minutes old, and a tier can sell out in between. Re-reading also
-          // covers the case where `load`'s best-effort tier read failed and the
-          // picker is collapsed.
-          const tickets = await queryAvailableTickets(s.id);
-          const live = (tickets.definitions ?? []).filter(tierAvailable);
-          // 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 ?? "";
-            if (reservationId) {
-              const placed = await checkoutReservation(s.id, reservationId);
-              const order = placed.order;
-              const snapshotId = order?.snapshotId ?? "";
-              if (!snapshotId) {
-                // Nothing to charge ⇒ the ticket is already issued.
-                return derive({ ...s, actionMessage: copyParam("event.ticketIssued", "You're in — your ticket is confirmed.") });
-              }
-              const msid = await wixPlatformSession
-                .signedInstanceStatus()
-                .then((st) => st.msid ?? "")
-                .catch(() => "");
-              const pay = await payCashierOrder({
-                appId: WIX_EVENTS_APP_ID,
-                snapshotId,
-                msid,
-                amount: order?.totalPrice?.amount,
-                currency: order?.totalPrice?.currency,
-                // Wallet-less apps keep the hosted events checkout, IN-APP — and
-                // pinned to the reservation we already hold, so the buyer doesn't
-                // restart tier selection from the slug.
-                cashierUrl: async () => {
-                  const redirect = await createRedirectSession({ eventsCheckout: { reservationId } });
-                  return redirect.redirectSession?.fullUrl;
-                },
-              });
-              if (pay.kind === "paid") {
-                return derive({ ...s, actionMessage: copyParam("event.ticketIssued", "You're in — your ticket is confirmed.") });
-              }
-              if (pay.kind === "handoff") return derive({ ...s, actionMessage: copyParam("event.checkoutOpened", "Complete checkout in the browser to get your tickets.") });
-              if (pay.kind === "cancelled") {
-                return derive({ ...s, actionMessage: copyParam("event.ticketCancelled", "Payment cancelled — no ticket was issued.") });
-              }
-            }
-          }
-        } catch {
-          // 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) {
-            const redirect = await createRedirectSession({ eventsCheckout: params });
-            const url = redirect.redirectSession?.fullUrl;
-            if (url) {
-              const result = await open(url, "in_app_browser");
-              return derive({
-                ...s,
-                actionMessage: result.opened
-                  ? copyParam("event.checkoutOpened", "Complete checkout in the browser to get your tickets.")
-                  : copyParam("event.registrationOpenFailed", "Could not open the registration page."),
-              });
-            }
-          }
-        } catch {
-          // fall through to registrationUrl
-        }
-      }
-      // Hosted: the HOST opens the event's own page signed in as the lent member — ids only; it
-      // reads the page URL from Wix and refuses (a custom domain → a visitor page; no published Events
-      // 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.
-        if (hostedOpenInFlight) return s;
-        hostedOpenInFlight = true;
-        let opened: boolean | "withdrawn";
-        try {
-          opened = await hostedSitePageOpener({ page: "event", eventId: s.id })(async () => true);
-        } finally {
-          hostedOpenInFlight = false;
-        }
-        if (opened === true) {
-          return derive({
-            ...s,
-            actionMessage: s.registrationKind === "tickets"
-              ? copyParam("event.checkoutOpened", "Complete checkout in the browser to get your tickets.")
-              : "",
-          });
-        }
-      }
-      if (!s.registrationUrl) {
-        return derive({ ...s, actionMessage: copyParam("event.registrationOnPage", "Registration for this event happens on the event page.") });
-      }
+      if (s.registrationKind !== "external" || !s.registrationUrl) return derive(s);
       try {
         const result = await open(s.registrationUrl, "in_app_browser");
-        return derive({ ...s, actionMessage: result.opened ? "" : copyParam("event.registrationOpenFailed", "Could not open the registration page.") });
+        return derive({ ...s, snackbarMessage: result.opened ? "" : copyParam("event.registrationOpenFailed", "Could not open the registration page.") });
       } catch {
-        return derive({ ...s, actionMessage: copyParam("event.registrationOpenFailed", "Could not open the registration page.") });
+        return derive({ ...s, snackbarMessage: copyParam("event.registrationOpenFailed", "Could not open the registration page.") });
       }
     },
     share: async (s) => {
@@ -801,11 +1242,11 @@ const svc = defineService<S, {
         await shareSheet({ subject: s.title, text, ...(s.shareUrl ? { url: s.shareUrl } : {}) });
         return s;
       } catch {
-        return derive({ ...s, actionMessage: copyParam("event.shareUnavailable", "Sharing is not available on this device.") });
+        return derive({ ...s, snackbarMessage: copyParam("event.shareUnavailable", "Sharing is not available on this device.") });
       }
     },
     addToCalendar: async (s) => {
-      if (!s.calendarStart) return derive({ ...s, actionMessage: copyParam("event.noDateMessage", "This event does not have a date yet.") });
+      if (!s.calendarStart) return derive({ ...s, rsvpActionsOpen: false, snackbarMessage: copyParam("event.noDateMessage", "This event does not have a date yet.") });
       const end = s.calendarEnd > s.calendarStart ? s.calendarEnd : s.calendarStart + 60 * 60 * 1000;
       try {
         let permission = await getPermissionStatus();
@@ -814,7 +1255,7 @@ const svc = defineService<S, {
         }
         if (permission !== "granted" && permission !== "limited") {
           const fallback = await open(calendarFallbackUrl(s, end), "in_app_browser");
-          return derive({ ...s, actionMessage: fallback.opened ? copyParam("event.calendarOpened", "Opened calendar.") : copyParam("event.calendarPermissionDenied", "Calendar permission was not granted.") });
+          return derive({ ...s, rsvpActionsOpen: false, snackbarMessage: fallback.opened ? copyParam("event.calendarOpened", "Opened calendar.") : copyParam("event.calendarPermissionDenied", "Calendar permission was not granted.") });
         }
         const created = await createEvent({
           title: s.title || "Event",
@@ -825,25 +1266,26 @@ const svc = defineService<S, {
         });
         if (!created.id) {
           const fallback = await open(calendarFallbackUrl(s, end), "in_app_browser");
-          return derive({ ...s, actionMessage: fallback.opened ? copyParam("event.calendarOpened", "Opened calendar.") : copyParam("event.calendarAddFailed", "Could not add this event to calendar."), isAddingCalendar: false });
+          return derive({ ...s, rsvpActionsOpen: false, snackbarMessage: fallback.opened ? copyParam("event.calendarOpened", "Opened calendar.") : copyParam("event.calendarAddFailed", "Could not add this event to calendar."), isAddingCalendar: false });
         }
         return derive({
           ...s,
-          actionMessage: copyParam("event.calendarAdded", "Added to calendar."),
+          rsvpActionsOpen: false,
+          snackbarMessage: copyParam("event.calendarAdded", "Added to calendar."),
           isAddingCalendar: false,
         });
       } catch {
-        return derive({ ...s, actionMessage: copyParam("event.calendarAddFailed", "Could not add this event to calendar."), isAddingCalendar: false });
+        return derive({ ...s, rsvpActionsOpen: false, snackbarMessage: copyParam("event.calendarAddFailed", "Could not add this event to calendar."), isAddingCalendar: false });
       }
     },
     // Only http(s), mailto and tel links reach open_url; a refused link, or one nothing opened, says so, and a
     // link that opens clears an earlier message.
     openLink: async (s, arg) => derive({
       ...s,
-      actionMessage: (await openRichLink(arg)) ? "" : copyParam("event.linkOpenFailed", "This link could not be opened."),
+      snackbarMessage: (await openRichLink(arg)) ? "" : copyParam("event.linkOpenFailed", "This link could not be opened."),
     }),
   },
 });
-resetUnhydratedKeysOnOlderRuntime(svc, { ...svc.getState(), ...ATTENDANCE_INITIAL, ticketPurchaseBlocked: true }, [...ATTENDANCE_NOT_HYDRATED, "ticketPurchaseBlocked"]);
+resetUnhydratedKeysOnOlderRuntime(svc, { ...svc.getState(), ...ATTENDANCE_INITIAL, ticketPurchaseBlocked: true, ticketSheetOpen: false, rsvpActionsOpen: false, cancelConfirmOpen: false, rsvpId: "", rsvpState: "none", rsvpLabel: "" }, [...ATTENDANCE_NOT_HYDRATED, "ticketPurchaseBlocked", "ticketSheetOpen", "rsvpActionsOpen", "cancelConfirmOpen", "rsvpId", "rsvpState", "rsvpLabel"]);
 svc.load();
 export { svc };