@acms-subir/core 0.3.40 → 0.3.42

package/src/components/editor/EventPanel.tsx

@@ -21,8 +21,8 @@ export interface EventMeta {
   calendarIds: string[];
   fields: Record<string, string>;
   // closesAt: wall time like start; closeBefore: minutes before each date (0 = until it ends);
-  // notifyStaff: the hosts get an email about each new or cancelled RSVP
-  rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number; closesAt?: string | null; closeBefore?: number; notifyStaff?: boolean; form?: FormDefinition };
+  // notifyStaff: the hosts get an email about each new or cancelled RSVP; waitlist: a full date takes places in line
+  rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number; closesAt?: string | null; closeBefore?: number; notifyStaff?: boolean; waitlist?: boolean; form?: FormDefinition };
   roomHold: RoomHoldValue;
 }
 

package/src/components/editor/PostEditor.tsx

@@ -169,7 +169,7 @@ const NO_MAPS: MapsStatus = { enabled: false, provider: '', label: '', search: f
 const NO_EVENT: EventMeta = {
   start: '', end: '', allDay: false, timezone: '', rrule: '', exdates: [], cancelled: false,
   location: NO_LOCATION, cta: { label: '', href: '', style: 'primary' }, calendarIds: [], fields: {},
-  rsvp: { enabled: false, capacity: 0, autoConfirm: true, maxSeats: 4, closesAt: null, closeBefore: 0, notifyStaff: true },
+  rsvp: { enabled: false, capacity: 0, autoConfirm: true, maxSeats: 4, closesAt: null, closeBefore: 0, notifyStaff: true, waitlist: false },
   roomHold: NO_HOLD,
 };
 

package/src/components/editor/event/RegistrationCard.tsx

@@ -77,6 +77,11 @@ export function RegistrationCard({ meta, onChange, eventId, title = '' }: { even
               <span><b>Email the hosts</b><small>About each new RSVP and cancellation. Without hosts, the contact email in Settings → Legal gets them</small></span>
               <input type="checkbox" role="switch" className="pe-switch" checked={meta.rsvp.notifyStaff !== false} onChange={(e) => onChange({ rsvp: { ...meta.rsvp, notifyStaff: e.target.checked } })} />
             </label>
+            {/* a waitlist needs a limit to be full */}
+            <label className="pe-switch-row">
+              <span><b>Offer a waitlist when it’s full</b><small>{meta.rsvp.capacity ? 'People join a line. When a seat opens, the next person is emailed and it’s held for them for 24 hours' : 'Set a number of seats to use it'}</small></span>
+              <input type="checkbox" role="switch" className="pe-switch" disabled={!meta.rsvp.capacity} checked={Boolean(meta.rsvp.waitlist && meta.rsvp.capacity)} onChange={(e) => onChange({ rsvp: { ...meta.rsvp, waitlist: e.target.checked } })} />
+            </label>
           </div>
           <Deadline meta={meta} onChange={onChange} />
           <div className="pe-evr-form">

package/src/components/editor/event/registration.ts

@@ -9,7 +9,7 @@ export type RegistrationMode = 'none' | 'link' | 'rsvp';
 
 interface RegistrationData {
   cta: EventCta;
-  rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number; closesAt?: string | null; closeBefore?: number; notifyStaff?: boolean };
+  rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number; closesAt?: string | null; closeBefore?: number; notifyStaff?: boolean; waitlist?: boolean };
 }
 
 export function registrationMode({ cta, rsvp }: RegistrationData): RegistrationMode {

package/src/lib/announcements/api.ts

@@ -10,8 +10,9 @@ import { localeOnlyQuery, localeQuery, mobileLocale } from '../mobile/locale';
 import { PUSH } from '../push/config';
 import { deviceLocale, knownTopics, pushTopics, siteOriginOf, sitePath } from '../push/service';
 import { linkTargets } from '../push/api';
+import { sendTest } from '../push/staff';
 import { ANNOUNCEMENTS } from './config';
-import { announcementJson, isLive, publishAnnouncement, type PublishOptions } from './service';
+import { URGENT_CHANNEL, announcementJson, isLive, localizeAnnouncement, publishAnnouncement, type PublishOptions } from './service';
 import { announcementStrings } from './words';
 import { ANNOUNCEMENT_KINDS, AnnouncementInput, AnnouncementKind, LIMITS, type Announcement, type AnnouncementWords } from './types';
 
@@ -115,6 +116,8 @@ export const AdminAnnouncementAction = z.discriminatedUnion('action', [
   z.object({ action: z.literal('archive'), id }).strict(),
   z.object({ action: z.literal('restore'), id }).strict(),
   z.object({ action: z.literal('delete'), id }).strict(),
+  // "Send test to my phone": the draft as it stands, in the preview's language, to the sender's linked phones
+  z.object({ action: z.literal('test'), announcement: AnnouncementInput, locale: z.string().max(35).optional() }).strict(),
 ]);
 export type AdminAnnouncementAction = z.infer<typeof AdminAnnouncementAction>;
 
@@ -156,7 +159,7 @@ export function scheduleProblem(a: Pick<Announcement, 'title' | 'message' | 'lis
   return null;
 }
 
-export interface AdminContext extends PublishOptions { url: URL; author: string }
+export interface AdminContext extends PublishOptions { url: URL; author: string; userId?: string }
 
 export async function adminAnnouncementAction(repo: ContentRepository, input: AdminAnnouncementAction, ctx: AdminContext) {
   requireAnnouncements();
@@ -166,6 +169,7 @@ export async function adminAnnouncementAction(repo: ContentRepository, input: Ad
     return { recipients: await countRecipients(repo, input.kind === 'urgent' ? ['*'] : await checkAudience(repo, input.audience)) };
   }
   if (input.action === 'save') return save(repo, input, ctx, now);
+  if (input.action === 'test') return test(repo, input, ctx);
   const a = await repo.announcements.get(input.id);
   if (!a) throw new ApiError(404, 'Announcement not found.');
   if (input.action === 'archive') {
@@ -184,6 +188,19 @@ export async function adminAnnouncementAction(repo: ContentRepository, input: Ad
   return { deleted: a.id };
 }
 
+// a tap opens the button's link, else the app (a draft has no page yet); urgent uses its channel so it looks the part
+async function test(repo: ContentRepository, input: Extract<AdminAnnouncementAction, { action: 'test' }>, ctx: AdminContext) {
+  if (!PUSH.enabled) throw new ApiError(400, 'Push notifications are off on this site (acms({ mobile: { push } })).');
+  const a = input.announcement;
+  const w = localizeAnnouncement({ ...a, translations: cleanTranslations(a.translations) }, input.locale ?? null);
+  if (!w.title) throw new ApiError(400, 'Add a title.');
+  const notification = await sendTest(repo, {
+    userId: ctx.userId ?? '', author: ctx.author, title: w.title, body: w.message, url: a.link, locale: input.locale ?? null,
+    channel: a.kind === 'urgent' ? URGENT_CHANNEL : undefined, data: { announcementKind: a.kind },
+  }, { ...ctx, origin: ctx.origin ?? siteOriginOf(await repo.getSettings(), ctx.url.origin) });
+  return { notification };
+}
+
 async function save(repo: ContentRepository, input: Extract<AdminAnnouncementAction, { action: 'save' }>, ctx: AdminContext, now: number) {
   const body = input.announcement;
   const existing = input.id ? await repo.announcements.get(input.id) : null;

package/src/lib/announcements/service.ts

@@ -15,7 +15,7 @@ import type { Announcement, AnnouncementWords } from './types';
 export const URGENT_CHANNEL = 'urgent';
 
 /** Each field in `locale`, falling back to the main words; `translated` = the language has its own title. */
-export function localizeAnnouncement(a: Announcement, locale: string | null | undefined): AnnouncementWords & { translated: boolean } {
+export function localizeAnnouncement(a: AnnouncementWords & Pick<Announcement, 'translations'>, locale: string | null | undefined): AnnouncementWords & { translated: boolean } {
   const main = { title: a.title, message: a.message, details: a.details, buttonLabel: a.buttonLabel };
   if (!locale || locale === I18N.defaultLocale) return { ...main, translated: true };
   const t = a.translations[locale] ?? a.translations[locale.toLowerCase().split('-')[0]];

package/src/lib/booking/agent.ts

@@ -18,7 +18,7 @@ export const BookingToolInputs = [
     minutes: z.number().int().optional(),
   }).strict() }).strict(),
   z.object({ tool: z.literal('list_bookings'), arguments: z.object({
-    status: z.enum(['pending', 'confirmed', 'declined', 'cancelled']).optional(), resource: z.string().optional(),
+    status: z.enum(['pending', 'confirmed', 'declined', 'cancelled', 'waitlisted', 'offered', 'expired']).optional(), resource: z.string().optional(),
     from: z.string().optional(), limit: z.number().int().min(1).max(100).default(25),
   }).strict() }).strict(),
   z.object({ tool: z.literal('create_booking'), arguments: z.object({

package/src/lib/booking/emails.ts

@@ -44,6 +44,11 @@ export function whenText(b: Pick<Booking, 'start' | 'end'>, tz: string, settings
   return `${f({ weekday: 'long', month: 'long', day: 'numeric' }).format(b.start)} · ${f({ hour: 'numeric', minute: '2-digit' }).format(b.start)} – ${f({ hour: 'numeric', minute: '2-digit' }).format(b.end)} ${zone}`.trim();
 }
 
+/** until when a freed spot is held, in the booking's language and the event's zone: "Fri, Nov 7, 6:00 PM UTC" */
+export function untilText(at: number, tz: string, settings: Settings): string {
+  return new Intl.DateTimeFormat(siteLocale(settings), { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZoneName: 'short', timeZone: tz }).format(at);
+}
+
 const utc = (ms: number) => new Date(ms).toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
 
 // lang: the description's language ("Manage: <url>")
@@ -80,6 +85,8 @@ interface Ctx {
   rsvpStaff?: { date: string; taken: number; capacity: number; why: RsvpStaffNotice['why']; via: Booking['source'] };
   /** manageUrl is the recipient's My events page (a host without Manage bookings) */
   mineLink?: boolean;
+  /** waitlist emails: the place in line (null once it isn't in line), how many hours a freed spot is held, and until when this one is */
+  waitlist?: { position: number | null; hours: number; until: string };
 }
 
 // own: a staff email's own rows and footer instead of the details and reference
@@ -104,8 +111,11 @@ ${button ? `<p style="margin:22px 0 0"><a href="${esc(button.href)}" style="disp
 }
 
 // link: the booking's own link again, after someone tried to make it twice.
-// staff-rsvp(-cancelled): the hosts hear about a new RSVP, or one the person cancelled
-export type BookingEmail = 'received' | 'confirmed' | 'declined' | 'cancelled' | 'rescheduled' | 'updated' | 'reminder' | 'link' | 'staff-new' | 'staff-rsvp' | 'staff-rsvp-cancelled';
+// waitlisted / offered / left: they joined a full date's waitlist, a spot
+// opened and is held for them, or they're off the waitlist (left it, released
+// the spot or staff removed them). staff-rsvp(-cancelled): the hosts hear
+// about a new RSVP, or one the person cancelled
+export type BookingEmail = 'received' | 'confirmed' | 'declined' | 'cancelled' | 'rescheduled' | 'updated' | 'reminder' | 'link' | 'waitlisted' | 'offered' | 'left' | 'staff-new' | 'staff-rsvp' | 'staff-rsvp-cancelled';
 
 export function bookingEmail(kind: BookingEmail, c: Ctx): Mail {
   const w = bookingStrings(c.lang);
@@ -115,8 +125,9 @@ export function bookingEmail(kind: BookingEmail, c: Ctx): Mail {
   // null: no button (nothing left to change)
   const guest = (k: Exclude<BookingEmail, `staff-${string}`>, extra: Partial<Ctx> = {}, button: { href: string; label: string } | null = manage) => {
     const copy = mailCopy(w, k, rsvp);
-    const vars = { name: c.booking.name || c.booking.email, title: c.title, when: c.when };
-    return { to: c.booking.email, subject: fill(copy.subject, vars), ...layout(copy.heading, fill(copy.intro, vars), { ...c, ...extra }, w, button ?? undefined) };
+    const vars = { name: c.booking.name || c.booking.email, title: c.title, when: c.when,
+      position: String(c.waitlist?.position ?? ''), hours: String(c.waitlist?.hours ?? ''), until: c.waitlist?.until ?? '' };
+    return { to: c.booking.email, subject: fill(copy.subject, vars), ...layout(fill(copy.heading, vars), fill(copy.intro, vars), { ...c, ...extra }, w, button ?? undefined) };
   };
   switch (kind) {
     case 'received': return guest('received');
@@ -126,7 +137,11 @@ export function bookingEmail(kind: BookingEmail, c: Ctx): Mail {
     case 'updated': return { ...guest('updated'), attachments: ics() };
     case 'rescheduled': return { ...guest('rescheduled'), attachments: ics() };
     case 'reminder': return guest('reminder');
-    case 'link': return guest('link');
+    // asked again while in line or holding a spot: that email again
+    case 'link': return c.booking.status === 'waitlisted' || c.booking.status === 'offered' ? bookingEmail(c.booking.status, c) : guest('link');
+    case 'waitlisted': return guest('waitlisted', {}, { href: c.manageUrl, label: w.waitlist.manage });
+    case 'offered': return guest('offered', {}, { href: c.manageUrl, label: w.waitlist.confirm });
+    case 'left': return guest('left', {}, null);
     case 'staff-new': {
       const pending = c.booking.status === 'pending';
       const who = [c.booking.name, c.booking.email, c.booking.phone].filter(Boolean).join(' · ');

package/src/lib/booking/service.ts

@@ -18,7 +18,7 @@ import { eventTimeZone, locationLine, occurrenceKey, rsvpDeadline } from '../cal
 import { normalizePageLocale } from '../i18n';
 import { localizeDoc } from '../translations';
 import { bookingStrings } from '../email/booking-words';
-import { bookingEmail, bookingLanguage, bookingManagePath, whenText, type BookingEmail } from './emails';
+import { bookingEmail, bookingLanguage, bookingManagePath, untilText, whenText, type BookingEmail } from './emails';
 import { holdOf, isBookable, resourceZone, spanEnd, type AvailabilityContext, type Interval } from './availability';
 import { decideStatus, linkApproval } from './approval';
 import { eventHolds } from './holds';
@@ -43,6 +43,9 @@ const token = () => {
   return btoa(String.fromCharCode(...bytes)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 };
 
+/** how long a spot freed for the next person on a waitlist is held for them (ms) */
+export const WAITLIST_HOLD = 24 * 3_600_000;
+
 // ---- availability context ------------------------------------------------
 
 const busyCache = new Map<string, { at: number; intervals: Interval[] }>();
@@ -147,11 +150,16 @@ export async function bookingMail(repo: ContentRepository, b: Booking, kind: Boo
   // a host without Manage bookings (a member who hosts) gets their My events
   // page for the event instead of an admin page they can't open
   const mine = counts && d.event && recipient ? await memberHostPath(repo, d.event, recipient) : '';
+  // a place in line (its number when sent) or a held spot (until when, in the event's zone)
+  const waitlist = b.status === 'waitlisted' || b.status === 'offered' ? {
+    position: await waitlistPosition(repo, b), hours: WAITLIST_HOLD / 3_600_000,
+    until: b.holdUntil === null ? '' : untilText(b.holdUntil, d.tz, settings),
+  } : undefined;
   return bookingEmail(kind, { booking:b,resource:d.resource,link:d.link,title:d.title,location:d.location,when:d.when,
     manageUrl:mine ? origin + mine : staff ? adminBookingUrl(origin, b, kind) : origin + bookingManagePath({ manageToken: b.manageToken, locale: language.locale }),
     mineLink: !!mine,
     siteTitle:settings.siteTitle,host:new URL(origin).host,organizer:parseFrom(from)?.email,message:snapshot?.message,
-    allDay:d.link?.mode==='day'||!!d.event?.allDay||(!d.event&&!!snapshot?.eventAllDay), lang:language.lang, rsvpStaff: counts });
+    allDay:d.link?.mode==='day'||!!d.event?.allDay||(!d.event&&!!snapshot?.eventAllDay), lang:language.lang, rsvpStaff: counts, waitlist });
 }
 
 /** The member's My events page for an event they host, when they can't manage bookings in the admin ('' otherwise). */
@@ -239,10 +247,13 @@ export function guestChanges(b: Booking, link: BookingLink | null, now = Date.no
   const active = b.status === 'pending' || b.status === 'confirmed';
   const cutoff = b.kind === 'booking' ? (link?.changeCutoff ?? 0) : 0;
   const closed = active && cutoff > 0 && b.start - now < cutoff * 3_600_000;
-  const open = active && b.end > now && !closed;
+  // a place in line or a held spot can be left until the date ends
+  const open = (active || b.status === 'waitlisted' || b.status === 'offered') && b.end > now && !closed;
   return {
     cancel: open,
-    reschedule: open && b.kind === 'booking' && b.start > now && !!link?.active,
+    reschedule: open && active && b.kind === 'booking' && b.start > now && !!link?.active,
+    // a spot offered from the waitlist, still held for them
+    confirm: b.status === 'offered' && (b.holdUntil ?? 0) > now && b.end > now,
     // hours before the start when guest changes close; 0 = until it ends
     cutoffHours: cutoff,
     closed,
@@ -255,8 +266,9 @@ export async function guestCancel(repo: ContentRepository, b: Booking, opts: Flo
   if (b.status === 'cancelled') return b;
   const can = guestChanges(b, link, opts.now);
   if (!can.cancel) throw new BookingError(409, can.closed ? `Changes close ${can.cutoffHours} hours before the start. Please contact us to cancel.` : 'This booking can’t be cancelled.');
-  // the person cancelled an RSVP: its hosts hear about it (staff cancelling never emails staff)
-  const event = b.kind === 'rsvp' && b.eventId ? await repo.getEvent(b.eventId) : null;
+  // the person cancelled an RSVP: its hosts hear about it (staff cancelling never emails staff;
+  // leaving the waitlist or a held spot isn't an RSVP to them)
+  const event = b.kind === 'rsvp' && b.eventId && (b.status === 'pending' || b.status === 'confirmed') ? await repo.getEvent(b.eventId) : null;
   return setBookingStatus(repo, b, 'cancelled', opts, undefined, event ? await rsvpStaff(repo, event, await repo.getSettings(), via) : undefined);
 }
 
@@ -313,14 +325,34 @@ export async function createBlock(repo: ContentRepository, resource: Resource, s
   });
 }
 
+// pending, confirmed and held (offered) RSVPs take seats, as in the capacity
+// check; a place in line doesn't
+const seated = (s: BookingStatus) => s === 'pending' || s === 'confirmed' || s === 'offered';
 export async function seatsTaken(repo: ContentRepository, eventId: string, start: number): Promise<number> {
-  const list = await repo.listBookings({ eventId, from: start - 1, to: start + 1, statuses: ['pending', 'confirmed'], kinds: ['rsvp'] });
+  const list = await repo.listBookings({ eventId, from: start - 1, to: start + 1, statuses: ['pending', 'confirmed', 'offered'], kinds: ['rsvp'] });
   return list.filter((b) => b.start === start).reduce((n, b) => n + b.seats, 0);
 }
 
+/** whether a full date takes places in line: the event keeps a waitlist and has a capacity */
+export const waitlistOn = (e: CalEvent) => e.rsvp.enabled && e.rsvp.waitlist && e.rsvp.capacity > 0;
+
+/** a date's waitlist in order: who joined first, then by id */
+export async function waitlistLine(repo: ContentRepository, eventId: string, start: number): Promise<Booking[]> {
+  const list = await repo.listBookings({ eventId, from: start - 1, to: start + 1, statuses: ['waitlisted'], kinds: ['rsvp'] });
+  return list.filter((b) => b.start === start).sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+
+/** a waitlisted RSVP's place in its date's line (1 = next), else null */
+export async function waitlistPosition(repo: ContentRepository, b: Booking): Promise<number | null> {
+  if (b.status !== 'waitlisted') return null;
+  const i = (await waitlistLine(repo, b.eventId, b.start)).findIndex((x) => x.id === b.id);
+  return i < 0 ? null : i + 1;
+}
+
 export async function createRsvp(
   repo: ContentRepository,
-  args: { event: CalEvent; start: number; end: number; seats: number; booker: BookerInput; source?: Booking['source'] },
+  // waitlist: a full date (fewer seats left than asked) takes a place in line instead, when the event keeps one
+  args: { event: CalEvent; start: number; end: number; seats: number; booker: BookerInput; source?: Booking['source']; waitlist?: boolean },
   opts: FlowOptions
 ): Promise<Booking> {
   const e = args.event;
@@ -343,15 +375,20 @@ export async function createRsvp(
   const once = args.source !== 'admin';
   const source = args.source ?? 'web';
   // the hosts' email is queued with the RSVP: a duplicate or a replay inserts nothing, so it emails no one
-  const b = await repo.createBooking({
-    kind: 'rsvp', resourceId: '', linkId: '', eventId: e.id, status: e.rsvp.autoConfirm ? 'confirmed' : 'pending',
+  const data = {
+    kind: 'rsvp' as const, resourceId: '', linkId: '', eventId: e.id, status: (e.rsvp.autoConfirm ? 'confirmed' : 'pending') as BookingStatus,
     start: args.start, end: args.end, holdStart: args.start, holdEnd: args.end, timezone: e.timezone, ...booker, seats,
     formResponse, notes: '', manageToken: token(), source, locale: normalizePageLocale(args.booker.locale ?? ''),
-  }, { capacity: e.rsvp.capacity, oncePerEmail: once, idempotency: opts.idempotency, staff: await rsvpStaff(repo, e, settings, source) });
+  };
+  let b = await repo.createBooking(data, { capacity: e.rsvp.capacity, oncePerEmail: once, idempotency: opts.idempotency, staff: await rsvpStaff(repo, e, settings, source) });
+  // full: a place in line, which takes no seats and emails no staff (still one per address and date)
+  if (!b && args.waitlist && waitlistOn(e) && !(opts.idempotency && await repo.getBookingRequest(opts.idempotency.keyHash))) {
+    b = await repo.createBooking({ ...data, status: 'waitlisted' }, { oncePerEmail: once, idempotency: opts.idempotency });
+  }
   if (!b) {
     // a retry of a request that just committed: the caller replays that one
     const retry = opts.idempotency ? await repo.getBookingRequest(opts.idempotency.keyHash) : null;
-    const mine = once && !retry ? (await repo.listBookings({ eventId: e.id, email: booker.email, from: args.start - 1, to: args.start + 1, statuses: ['pending', 'confirmed'], kinds: ['rsvp'] })).find((x) => x.start === args.start) : undefined;
+    const mine = once && !retry ? (await repo.listBookings({ eventId: e.id, email: booker.email, from: args.start - 1, to: args.start + 1, statuses: ['pending', 'confirmed', 'offered', 'waitlisted'], kinds: ['rsvp'] })).find((x) => x.start === args.start) : undefined;
     if (mine) {
       await resendManageLink(repo, mine, args.booker.locale === undefined ? mine.locale : normalizePageLocale(args.booker.locale), opts);
       // anyone can type an address: say only that it has one
@@ -365,6 +402,95 @@ export async function createRsvp(
   return b;
 }
 
+/**
+ * Offers a date's freed seats to its waitlist, in order: each person whose
+ * seats fit what's free gets them held for WAITLIST_HOLD, with an email to
+ * confirm; larger requests keep their place. Runs after anything that frees
+ * seats (a cancellation, a decline, a spot that ran out, a capacity raised)
+ * and from the scheduler. Only while the event keeps a waitlist and before
+ * the date starts, past its RSVP deadline too: those in line joined in time.
+ * Each offer re-checks the seats in the database, so racing runs (or a new
+ * RSVP) never take more than the capacity. Returns how many it offered.
+ */
+export async function offerWaitlist(repo: ContentRepository, eventId: string, start: number, opts: FlowOptions): Promise<number> {
+  const now = opts.now ?? Date.now();
+  if (start <= now) return 0;
+  const line = await waitlistLine(repo, eventId, start);
+  if (!line.length) return 0;
+  const e = await repo.getEvent(eventId);
+  // turning the waitlist off only stops new people joining: those already in line still get their turn
+  if (!e || !e.rsvp.enabled || e.cancelled) return 0;
+  if (e.cancelledDates?.length && e.cancelledDates.includes(occurrenceKey(e, start, await repo.getSettings()))) return 0;
+  const cap = e.rsvp.capacity;
+  const free = async () => (cap ? cap - await seatsTaken(repo, eventId, start) : Infinity);
+  let left = await free(), offered = 0;
+  for (const b of line) {
+    if (left <= 0) break;
+    if (b.seats > left) continue;
+    if (await repo.offerBooking(b.id, now + WAITLIST_HOLD, cap)) { left -= b.seats; offered++; }
+    // someone took seats meanwhile: count again
+    else left = await free();
+  }
+  if (offered) await kickEmail(repo, opts.locals, opts.waitUntil);
+  return offered;
+}
+
+/** every upcoming date of one event with people in line (after an edit that may have freed seats) */
+export async function offerEventWaitlist(repo: ContentRepository, eventId: string, opts: FlowOptions): Promise<number> {
+  const now = opts.now ?? Date.now();
+  const starts = new Set((await repo.listBookings({ eventId, from: now, statuses: ['waitlisted'], kinds: ['rsvp'] })).map((b) => b.start));
+  let offered = 0;
+  for (const start of starts) offered += await offerWaitlist(repo, eventId, start, opts);
+  return offered;
+}
+
+/**
+ * The person takes the spot held for them (manage page, app): confirmed, or
+ * pending when the event approves each RSVP, with the usual email and the
+ * hosts' "New RSVP" one. Past its hold the spot is released (410) and goes
+ * to the next person in line. Repeating it is harmless.
+ */
+export async function confirmOffer(repo: ContentRepository, b: Booking, opts: FlowOptions, via: Booking['source'] = 'web'): Promise<Booking> {
+  const now = opts.now ?? Date.now();
+  if (b.status === 'confirmed' || b.status === 'pending') return b;
+  if (b.status === 'offered' && (b.holdUntil ?? 0) <= now) {
+    await releaseOffer(repo, b, opts);
+    throw new BookingError(410, 'This held spot was released.');
+  }
+  if (b.status === 'expired') throw new BookingError(410, 'This held spot was released.');
+  if (b.status !== 'offered') throw new BookingError(409, 'There’s no held spot to confirm.');
+  if (b.end <= now) throw new BookingError(410, 'This event has already happened.');
+  const event = b.eventId ? await repo.getEvent(b.eventId) : null;
+  try {
+    return await setBookingStatus(repo, b, event?.rsvp.autoConfirm === false ? 'pending' : 'confirmed', opts, undefined, event ? await rsvpStaff(repo, event, await repo.getSettings(), via) : undefined);
+  } catch (err) {
+    if ((await repo.getBooking(b.id))?.status === 'expired') throw new BookingError(410, 'This held spot was released.');
+    throw err;
+  }
+}
+
+// a held spot nobody confirmed in time: expired (no email; only if it's still
+// offered), and its seats go to the next person in line
+async function releaseOffer(repo: ContentRepository, b: Booking, opts: FlowOptions) {
+  if (await repo.expireBooking(b.id, opts.now ?? Date.now())) await offerWaitlist(repo, b.eventId, b.start, opts);
+}
+
+// cron: held spots past their time run out, and every upcoming date with
+// people in line is offered what's free (catching up on seats freed by edits,
+// or by a change that lost a race)
+export async function sweepWaitlist(repo: ContentRepository, opts: FlowOptions): Promise<number> {
+  const now = opts.now ?? Date.now();
+  const list = await repo.listBookings({ from: now, statuses: ['waitlisted', 'offered'], kinds: ['rsvp'] });
+  const dates = new Map<string, { eventId: string; start: number }>();
+  for (const b of list) {
+    if (b.status === 'offered' && (b.holdUntil ?? 0) <= now) await repo.expireBooking(b.id, now);
+    dates.set(`${b.eventId}:${b.start}`, { eventId: b.eventId, start: b.start });
+  }
+  let offered = 0;
+  for (const d of dates.values()) offered += await offerWaitlist(repo, d.eventId, d.start, opts);
+  return offered;
+}
+
 // The address gets its RSVP's own link again, in the language it just used,
 // at most once per 10 minutes per RSVP so the form can't flood an inbox.
 async function resendManageLink(repo: ContentRepository, b: Booking, locale: string, opts: FlowOptions) {
@@ -379,6 +505,10 @@ const TRANSITIONS: Record<BookingStatus, BookingStatus[]> = {
   confirmed: ['cancelled'],
   declined: ['confirmed'],
   cancelled: ['confirmed'],
+  // only offerWaitlist offers a place in line, and only the clock expires a held spot
+  waitlisted: ['cancelled'],
+  offered: ['confirmed', 'pending', 'cancelled'],
+  expired: [],
 };
 
 // staff: who to tell that the person cancelled (guestCancel); staff changes tell no one
@@ -391,13 +521,17 @@ export async function setBookingStatus(repo: ContentRepository, b: Booking, stat
       .some((x) => x.id !== b.id && x.kind !== 'rsvp' && x.holdStart < b.holdEnd && x.holdEnd > b.holdStart);
     if (clash) throw new BookingError(409, 'That time has been booked since — it can’t be restored.');
   }
-  await repo.updateBooking(b.id, { status, notificationMessage: message, staff });
+  // only from the status it was read in: a spot that ran out meanwhile can't be confirmed
+  await repo.updateBooking(b.id, { status, from: b.status, notificationMessage: message, staff });
   const next = (await repo.getBooking(b.id))!;
   if (!next || next.status !== status) throw new BookingError(409, 'This booking changed. Refresh and try again.');
   if (b.kind !== 'block') {
     await notify(repo, next, [status === 'confirmed' ? 'confirmed' : status === 'declined' ? 'declined' : 'cancelled'], opts, message);
-    await hook(repo, status === 'confirmed' ? 'booking.confirmed' : status === 'declined' ? 'booking.declined' : 'booking.cancelled', next, opts);
+    // a held spot taken up for approval is no webhook yet (approving it is)
+    if (status !== 'pending') await hook(repo, status === 'confirmed' ? 'booking.confirmed' : status === 'declined' ? 'booking.declined' : 'booking.cancelled', next, opts);
   }
+  // the seats it held go to the next people in line
+  if (b.kind === 'rsvp' && seated(b.status) && !seated(status)) await offerWaitlist(repo, b.eventId, b.start, opts);
   return next;
 }
 

package/src/lib/calendar/rsvp-words.ts

@@ -1,8 +1,9 @@
 // Words of the built-in RSVP: the event page's RSVP block, the RSVP's own
 // page (book/manage) and the app's default button (GET /events/:slug/rsvp).
 // The same wording as the app's RSVP panel (packages/native strings.ts).
-// Plain strings with {count}, {email}, {title}, {date} and {time} slots
-// (live/words.ts `fill`); of a pair (`spotLeft`/`spotsLeft`), the first is for 1 and the
+// Plain strings with {count}, {email}, {title}, {date}, {time}, {position},
+// {seats} and {hours} slots (live/words.ts `fill`); of a pair
+// (`spotLeft`/`spotsLeft`), the first is for 1 and the
 // second for any other number. The event's own form title, questions and
 // button keep their words. Other languages fall back to English.
 export interface RsvpStrings {
@@ -28,6 +29,31 @@ export interface RsvpStrings {
   duplicate: string;
   duplicateNote: string;
   saveError: string;
+  /** a full date with a waitlist: "Full", "40 going · no spots left", the note and the button (also the form's) */
+  fullTag: string;
+  noSpotsLeft: string;
+  waitlistNote: string;
+  joinWaitlist: string;
+  /** the RSVP's own page for a place in line: "#3 in line · 2 seats" ({seats}: `seat`/`seats`), and the promise ({hours}) */
+  onWaitlist: string;
+  inLine: string;
+  seat: string;
+  seats: string;
+  waitlistPromise: string;
+  leaveWaitlist: string;
+  leaveConfirm: string;
+  /** off the line: they left it, released the spot or staff removed them */
+  offWaitlist: string;
+  offWaitlistText: string;
+  /** a spot held for them ({date} and {time}: until when), and one they didn't confirm in time */
+  spotOpened: string;
+  spotYours: string;
+  confirmSpot: string;
+  releaseSpot: string;
+  releaseConfirm: string;
+  released: string;
+  releasedText: string;
+  confirmError: string;
   /** the RSVP's own page */
   booked: string;
   yours: string;
@@ -44,7 +70,7 @@ export interface RsvpStrings {
   where: string;
   status: string;
   reference: string;
-  statuses: Record<'pending' | 'confirmed' | 'cancelled' | 'declined', string>;
+  statuses: Record<'pending' | 'confirmed' | 'cancelled' | 'declined' | 'waitlisted' | 'offered' | 'expired', string>;
   addToCalendar: string;
   downloadIcs: string;
   cancel: string;
@@ -61,11 +87,18 @@ const STRINGS: Record<string, RsvpStrings> = {
     full: 'This event is full.', closed: 'RSVPs are closed.', saveError: 'Couldn’t save your RSVP. Please try again.',
     closesOn: 'RSVPs close {date} at {time}', closedOn: 'They closed on {date}. Questions? Contact us.',
     duplicate: 'You already have an RSVP for this date.', duplicateNote: 'We sent you an email with a link to change it. Need more seats? Change it there.',
+    fullTag: 'Full', noSpotsLeft: 'no spots left', waitlistNote: 'Join the waitlist and we’ll email you if a spot opens.', joinWaitlist: 'Join the waitlist',
+    onWaitlist: 'You’re on the waitlist', inLine: '#{position} in line · {seats}', seat: '{count} seat', seats: '{count} seats',
+    waitlistPromise: 'If a spot opens, we’ll email you and save it for {hours} hours.', leaveWaitlist: 'Leave the waitlist', leaveConfirm: 'Leave the waitlist?',
+    offWaitlist: 'You’re off the waitlist', offWaitlistText: 'You’re no longer on the waitlist for this date.',
+    spotOpened: 'A spot opened', spotYours: 'A spot is yours until {date} at {time}', confirmSpot: 'Confirm my spot', releaseSpot: 'Release it',
+    releaseConfirm: 'Release this spot? It goes to the next person in line.', released: 'This held spot was released',
+    releasedText: 'We held it for {hours} hours, then offered it to the next person in line.', confirmError: 'Couldn’t confirm — please try again.',
     booked: 'You’re booked', yours: 'Your booking', requestSent: 'Request sent', awaitingApproval: 'Waiting for approval', notAvailable: 'Not available', cancelledTitle: 'Booking cancelled',
     emailWhenApproved: 'We’ll email {email} once it’s approved.', confirmationOnItsWay: 'A confirmation is on its way to {email}.',
     declined: 'Sorry, the organiser couldn’t confirm it.', cancelledText: 'This booking is cancelled.',
     what: 'What', when: 'When', where: 'Where', status: 'Status', reference: 'Reference',
-    statuses: { pending: 'Pending', confirmed: 'Confirmed', cancelled: 'Cancelled', declined: 'Declined' },
+    statuses: { pending: 'Pending', confirmed: 'Confirmed', cancelled: 'Cancelled', declined: 'Declined', waitlisted: 'On the waitlist', offered: 'Spot held for you', expired: 'Released' },
     addToCalendar: 'Add to calendar', downloadIcs: 'Download .ics', cancel: 'Cancel RSVP', cancelConfirm: 'Cancel this RSVP?', cancelError: 'Couldn’t cancel — please try again.',
     backTo: 'Back to {title}', keepLink: 'Keep this link — anyone with it can change this booking.',
   },
@@ -75,11 +108,18 @@ const STRINGS: Record<string, RsvpStrings> = {
     full: 'Este evento está lleno.', closed: 'Las confirmaciones están cerradas.', saveError: 'No se pudo guardar tu confirmación. Inténtalo de nuevo.',
     closesOn: 'Las confirmaciones cierran el {date}, {time}', closedOn: 'Cerraron el {date}. ¿Preguntas? Contáctanos.',
     duplicate: 'Ya tienes una confirmación para esta fecha.', duplicateNote: 'Te enviamos un correo con un enlace para cambiarla. ¿Necesitas más lugares? Cámbiala ahí.',
+    fullTag: 'Lleno', noSpotsLeft: 'no quedan lugares', waitlistNote: 'Únete a la lista de espera y te escribiremos si se libera un lugar.', joinWaitlist: 'Unirme a la lista de espera',
+    onWaitlist: 'Estás en la lista de espera', inLine: '#{position} en la fila · {seats}', seat: '{count} lugar', seats: '{count} lugares',
+    waitlistPromise: 'Si se libera un lugar, te escribiremos y te lo apartaremos {hours} horas.', leaveWaitlist: 'Salir de la lista de espera', leaveConfirm: '¿Salir de la lista de espera?',
+    offWaitlist: 'Ya no estás en la lista de espera', offWaitlistText: 'Ya no estás en la lista de espera para esta fecha.',
+    spotOpened: 'Se liberó un lugar', spotYours: 'El lugar es tuyo hasta el {date}, {time}', confirmSpot: 'Confirmar mi lugar', releaseSpot: 'Liberarlo',
+    releaseConfirm: '¿Liberar este lugar? Pasará a la siguiente persona en la fila.', released: 'Se liberó el lugar que te apartamos',
+    releasedText: 'Te lo apartamos {hours} horas y luego se lo ofrecimos a la siguiente persona en la fila.', confirmError: 'No se pudo confirmar. Inténtalo de nuevo.',
     booked: 'Ya tienes tu lugar', yours: 'Tu confirmación', requestSent: 'Solicitud enviada', awaitingApproval: 'En espera de aprobación', notAvailable: 'No se pudo confirmar', cancelledTitle: 'Confirmación cancelada',
     emailWhenApproved: 'Te escribiremos a {email} cuando se apruebe.', confirmationOnItsWay: 'Te enviamos la confirmación a {email}.',
     declined: 'Lo sentimos, el organizador no pudo confirmarla.', cancelledText: 'Esta confirmación se canceló.',
     what: 'Qué', when: 'Cuándo', where: 'Dónde', status: 'Estado', reference: 'Referencia',
-    statuses: { pending: 'Pendiente', confirmed: 'Confirmado', cancelled: 'Cancelado', declined: 'Rechazado' },
+    statuses: { pending: 'Pendiente', confirmed: 'Confirmado', cancelled: 'Cancelado', declined: 'Rechazado', waitlisted: 'En lista de espera', offered: 'Lugar apartado para ti', expired: 'Liberado' },
     addToCalendar: 'Agregar al calendario', downloadIcs: 'Descargar .ics', cancel: 'Cancelar mi confirmación', cancelConfirm: '¿Cancelar tu confirmación?', cancelError: 'No se pudo cancelar. Inténtalo de nuevo.',
     backTo: 'Volver a {title}', keepLink: 'Guarda este enlace: quien lo tenga puede cambiar esta confirmación.',
   },
@@ -89,11 +129,18 @@ const STRINGS: Record<string, RsvpStrings> = {
     full: 'Cet événement est complet.', closed: 'Les inscriptions sont closes.', saveError: 'Impossible d’enregistrer votre inscription. Veuillez réessayer.',
     closesOn: 'Les inscriptions ferment le {date} à {time}', closedOn: 'Elles ont fermé le {date}. Des questions ? Contactez-nous.',
     duplicate: 'Vous avez déjà une inscription pour cette date.', duplicateNote: 'Nous vous avons envoyé un e-mail avec un lien pour la modifier. Besoin de plus de places ? Modifiez-la depuis ce lien.',
+    fullTag: 'Complet', noSpotsLeft: 'plus de place', waitlistNote: 'Inscrivez-vous sur la liste d’attente : nous vous écrirons si une place se libère.', joinWaitlist: 'Rejoindre la liste d’attente',
+    onWaitlist: 'Vous êtes sur la liste d’attente', inLine: 'N° {position} dans la file · {seats}', seat: '{count} place', seats: '{count} places',
+    waitlistPromise: 'Si une place se libère, nous vous écrirons et vous la garderons {hours} heures.', leaveWaitlist: 'Quitter la liste d’attente', leaveConfirm: 'Quitter la liste d’attente ?',
+    offWaitlist: 'Vous n’êtes plus sur la liste d’attente', offWaitlistText: 'Vous n’êtes plus sur la liste d’attente pour cette date.',
+    spotOpened: 'Une place s’est libérée', spotYours: 'Une place est à vous jusqu’au {date} à {time}', confirmSpot: 'Confirmer ma place', releaseSpot: 'La libérer',
+    releaseConfirm: 'Libérer cette place ? Elle ira à la personne suivante dans la file.', released: 'La place gardée pour vous a été libérée',
+    releasedText: 'Nous l’avons gardée {hours} heures, puis proposée à la personne suivante dans la file.', confirmError: 'Impossible de confirmer. Veuillez réessayer.',
     booked: 'Votre place est réservée', yours: 'Votre inscription', requestSent: 'Demande envoyée', awaitingApproval: 'En attente de validation', notAvailable: 'Non confirmée', cancelledTitle: 'Inscription annulée',
     emailWhenApproved: 'Nous écrirons à {email} dès qu’elle sera validée.', confirmationOnItsWay: 'Une confirmation est en route vers {email}.',
     declined: 'Désolés, l’organisateur n’a pas pu la confirmer.', cancelledText: 'Cette inscription est annulée.',
     what: 'Quoi', when: 'Quand', where: 'Où', status: 'Statut', reference: 'Référence',
-    statuses: { pending: 'En attente', confirmed: 'Confirmée', cancelled: 'Annulée', declined: 'Refusée' },
+    statuses: { pending: 'En attente', confirmed: 'Confirmée', cancelled: 'Annulée', declined: 'Refusée', waitlisted: 'Sur liste d’attente', offered: 'Place gardée pour vous', expired: 'Libérée' },
     addToCalendar: 'Ajouter au calendrier', downloadIcs: 'Télécharger le .ics', cancel: 'Annuler mon inscription', cancelConfirm: 'Annuler cette inscription ?', cancelError: 'Impossible d’annuler. Veuillez réessayer.',
     backTo: 'Retour à {title}', keepLink: 'Conservez ce lien : toute personne qui l’a peut modifier cette inscription.',
   },
@@ -103,11 +150,18 @@ const STRINGS: Record<string, RsvpStrings> = {
     full: 'Diese Veranstaltung ist ausgebucht.', closed: 'Anmeldungen sind geschlossen.', saveError: 'Ihre Anmeldung konnte nicht gespeichert werden. Bitte versuchen Sie es erneut.',
     closesOn: 'Anmeldung bis {date}, {time}', closedOn: 'Die Anmeldung endete am {date}. Fragen? Kontaktieren Sie uns.',
     duplicate: 'Sie haben für diesen Termin schon eine Anmeldung.', duplicateNote: 'Wir haben Ihnen eine E-Mail mit einem Link zum Ändern geschickt. Mehr Plätze nötig? Ändern Sie sie dort.',
+    fullTag: 'Ausgebucht', noSpotsLeft: 'keine Plätze frei', waitlistNote: 'Tragen Sie sich auf die Warteliste ein. Wird ein Platz frei, schreiben wir Ihnen.', joinWaitlist: 'Auf die Warteliste',
+    onWaitlist: 'Sie stehen auf der Warteliste', inLine: 'Nr. {position} auf der Warteliste · {seats}', seat: '{count} Platz', seats: '{count} Plätze',
+    waitlistPromise: 'Wird ein Platz frei, schreiben wir Ihnen und halten ihn {hours} Stunden für Sie frei.', leaveWaitlist: 'Warteliste verlassen', leaveConfirm: 'Die Warteliste verlassen?',
+    offWaitlist: 'Sie stehen nicht mehr auf der Warteliste', offWaitlistText: 'Sie stehen für diesen Termin nicht mehr auf der Warteliste.',
+    spotOpened: 'Ein Platz ist frei geworden', spotYours: 'Der Platz ist bis {date}, {time} für Sie reserviert', confirmSpot: 'Platz bestätigen', releaseSpot: 'Freigeben',
+    releaseConfirm: 'Diesen Platz freigeben? Er geht an die nächste Person auf der Warteliste.', released: 'Der für Sie reservierte Platz wurde freigegeben',
+    releasedText: 'Wir haben ihn {hours} Stunden für Sie freigehalten und dann der nächsten Person auf der Warteliste angeboten.', confirmError: 'Bestätigung fehlgeschlagen. Bitte versuchen Sie es erneut.',
     booked: 'Ihr Platz ist reserviert', yours: 'Ihre Anmeldung', requestSent: 'Anfrage gesendet', awaitingApproval: 'Wartet auf Freigabe', notAvailable: 'Nicht bestätigt', cancelledTitle: 'Anmeldung storniert',
     emailWhenApproved: 'Wir schreiben an {email}, sobald sie freigegeben ist.', confirmationOnItsWay: 'Eine Bestätigung ist unterwegs an {email}.',
     declined: 'Leider konnte der Veranstalter sie nicht bestätigen.', cancelledText: 'Diese Anmeldung ist storniert.',
     what: 'Was', when: 'Wann', where: 'Wo', status: 'Status', reference: 'Referenz',
-    statuses: { pending: 'Ausstehend', confirmed: 'Bestätigt', cancelled: 'Storniert', declined: 'Abgelehnt' },
+    statuses: { pending: 'Ausstehend', confirmed: 'Bestätigt', cancelled: 'Storniert', declined: 'Abgelehnt', waitlisted: 'Auf der Warteliste', offered: 'Platz für Sie reserviert', expired: 'Freigegeben' },
     addToCalendar: 'Zum Kalender hinzufügen', downloadIcs: '.ics herunterladen', cancel: 'Anmeldung stornieren', cancelConfirm: 'Diese Anmeldung stornieren?', cancelError: 'Stornieren fehlgeschlagen. Bitte versuchen Sie es erneut.',
     backTo: 'Zurück zu {title}', keepLink: 'Bewahren Sie diesen Link auf – wer ihn hat, kann diese Anmeldung ändern.',
   },
@@ -117,11 +171,18 @@ const STRINGS: Record<string, RsvpStrings> = {
     full: 'Este evento está lotado.', closed: 'As inscrições estão encerradas.', saveError: 'Não foi possível salvar sua inscrição. Tente novamente.',
     closesOn: 'As inscrições se encerram em {date}, {time}', closedOn: 'Elas se encerraram em {date}. Dúvidas? Fale com a gente.',
     duplicate: 'Você já tem uma inscrição para esta data.', duplicateNote: 'Enviamos um e-mail com um link para alterá-la. Precisa de mais vagas? Altere por lá.',
+    fullTag: 'Lotado', noSpotsLeft: 'nenhuma vaga', waitlistNote: 'Entre na lista de espera e avisaremos por e-mail se abrir uma vaga.', joinWaitlist: 'Entrar na lista de espera',
+    onWaitlist: 'Você está na lista de espera', inLine: 'Nº {position} na fila · {seats}', seat: '{count} vaga', seats: '{count} vagas',
+    waitlistPromise: 'Se abrir uma vaga, avisaremos por e-mail e vamos guardá-la por {hours} horas.', leaveWaitlist: 'Sair da lista de espera', leaveConfirm: 'Sair da lista de espera?',
+    offWaitlist: 'Você não está mais na lista de espera', offWaitlistText: 'Você não está mais na lista de espera desta data.',
+    spotOpened: 'Abriu uma vaga', spotYours: 'A vaga é sua até {date}, {time}', confirmSpot: 'Confirmar minha vaga', releaseSpot: 'Liberar',
+    releaseConfirm: 'Liberar esta vaga? Ela passa para a próxima pessoa da fila.', released: 'A vaga guardada para você foi liberada',
+    releasedText: 'Nós a guardamos por {hours} horas e depois a oferecemos à próxima pessoa da fila.', confirmError: 'Não foi possível confirmar. Tente novamente.',
     booked: 'Sua vaga está reservada', yours: 'Sua inscrição', requestSent: 'Solicitação enviada', awaitingApproval: 'Aguardando aprovação', notAvailable: 'Não confirmada', cancelledTitle: 'Inscrição cancelada',
     emailWhenApproved: 'Vamos escrever para {email} assim que for aprovada.', confirmationOnItsWay: 'Uma confirmação está a caminho de {email}.',
     declined: 'Desculpe, o organizador não pôde confirmá-la.', cancelledText: 'Esta inscrição foi cancelada.',
     what: 'O quê', when: 'Quando', where: 'Onde', status: 'Status', reference: 'Referência',
-    statuses: { pending: 'Pendente', confirmed: 'Confirmada', cancelled: 'Cancelada', declined: 'Recusada' },
+    statuses: { pending: 'Pendente', confirmed: 'Confirmada', cancelled: 'Cancelada', declined: 'Recusada', waitlisted: 'Na lista de espera', offered: 'Vaga guardada para você', expired: 'Liberada' },
     addToCalendar: 'Adicionar ao calendário', downloadIcs: 'Baixar .ics', cancel: 'Cancelar inscrição', cancelConfirm: 'Cancelar esta inscrição?', cancelError: 'Não foi possível cancelar. Tente novamente.',
     backTo: 'Voltar para {title}', keepLink: 'Guarde este link: qualquer pessoa com ele pode alterar esta inscrição.',
   },