@acms-subir/core 0.3.37 → 0.3.39

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

@@ -0,0 +1,171 @@
+// Words of the built-in event page (EventPage.astro) and the bits of it that
+// show elsewhere: the "Cancelled" flag on event cards and the calendar's
+// pop-up, "All day", and the repeat line ("Weekly on Sunday", rrule.ts
+// describeRepeat). Plain strings with {date} and {place} slots (live/words.ts
+// `fill`); the repeat line is built by functions, since word order differs
+// per language. No server imports: the event editor shares the repeat line.
+// The event's own words (title, button, fields) stay as written. Spanish
+// matches the push notices ("Cancelado el …"). Other languages fall back to
+// English.
+export interface EventStrings {
+  /** the flag on a card or in the calendar's pop-up */
+  cancelled: string;
+  /** the whole event: in bold, then the note */
+  eventCancelled: string;
+  eventCancelledNote: string;
+  /** one date of a repeating event */
+  dateCancelled: string;
+  dateCancelledNote: string;
+  /** the side column's landmark label */
+  details: string;
+  joinOnline: string;
+  map: string;
+  directionsTo: string;
+  mapOf: string;
+  /** when the place has neither a name nor an address */
+  directionsHere: string;
+  mapHere: string;
+  /** under the repeat line: the date this page shows */
+  showing: string;
+  addToCalendar: string;
+  downloadIcs: string;
+  share: string;
+  linkCopied: string;
+  moreEvents: string;
+  fullCalendar: string;
+  allDay: string;
+  repeat: RepeatWords;
+}
+
+/** Weekdays are 0 = Sunday; `n` is the interval (every n days/weeks/months/years). */
+export interface RepeatWords {
+  daily: (n: number) => string;
+  weekly: (n: number, days: number[]) => string;
+  /** `day`: the month day as written in the rule (BYMONTHDAY) */
+  monthlyOnDay: (n: number, day: string) => string;
+  /** `nth`: 1–5 or -1 (last); '' when the language can't word it */
+  monthlyOnWeekday: (n: number, nth: number, dow: number) => string;
+  yearly: (n: number) => string;
+  /** appended: ", 6 times", ", until Oct 3, 2026" */
+  times: (count: number) => string;
+  until: (date: string) => string;
+  /** a rule the editor doesn't offer */
+  other: string;
+}
+
+const list = (items: string[], and: string) =>
+  items.length <= 1 ? items.join('') : `${items.slice(0, -1).join(', ')} ${and} ${items[items.length - 1]}`;
+const cap = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
+
+const EN_DAYS = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+const EN_ORD: Record<number, string> = { 1: 'first', 2: 'second', 3: 'third', 4: 'fourth', 5: 'fifth', [-1]: 'last' };
+const ES_DAYS = ['domingo', 'lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado'];
+// "todos los domingos", "los lunes": only sábado and domingo change
+const ES_DAYS_PL = ['domingos', 'lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábados'];
+const ES_ORD: Record<number, string> = { 1: 'primer', 2: 'segundo', 3: 'tercer', 4: 'cuarto', 5: 'quinto', [-1]: 'último' };
+const FR_DAYS = ['dimanche', 'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi'];
+const FR_ORD: Record<number, string> = { 1: 'premier', 2: 'deuxième', 3: 'troisième', 4: 'quatrième', 5: 'cinquième', [-1]: 'dernier' };
+const DE_DAYS = ['Sonntag', 'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag'];
+const DE_ORD: Record<number, string> = { 1: 'ersten', 2: 'zweiten', 3: 'dritten', 4: 'vierten', 5: 'fünften', [-1]: 'letzten' };
+const PT_DAYS = ['domingo', 'segunda-feira', 'terça-feira', 'quarta-feira', 'quinta-feira', 'sexta-feira', 'sábado'];
+// segunda- to sexta-feira are feminine, sábado and domingo masculine
+const ptFem = (dow: number) => dow >= 1 && dow <= 5;
+const PT_ORD: Record<number, [string, string]> = { 1: ['primeiro', 'primeira'], 2: ['segundo', 'segunda'], 3: ['terceiro', 'terceira'], 4: ['quarto', 'quarta'], 5: ['quinto', 'quinta'], [-1]: ['último', 'última'] };
+
+const STRINGS: Record<string, EventStrings> = {
+  en: {
+    cancelled: 'Cancelled', eventCancelled: 'This event is cancelled.', eventCancelledNote: 'It stays listed so nobody is left wondering.',
+    dateCancelled: 'Cancelled on {date}.', dateCancelledNote: 'Other dates go ahead as usual.',
+    details: 'Event details', joinOnline: 'Join online', map: 'Map', directionsTo: 'Directions to {place}', mapOf: 'Map of {place}',
+    directionsHere: 'Directions to the location', mapHere: 'Map of the location', showing: 'Showing {date}',
+    addToCalendar: 'Add to calendar', downloadIcs: 'Download .ics', share: 'Share', linkCopied: 'Link copied',
+    moreEvents: 'More events', fullCalendar: 'See the full calendar →', allDay: 'All day',
+    repeat: {
+      daily: (n) => (n === 1 ? 'Daily' : `Every ${n} days`),
+      weekly: (n, days) => `${n === 1 ? 'Weekly' : `Every ${n} weeks`} on ${list(days.map((d) => EN_DAYS[d]), 'and')}`,
+      monthlyOnDay: (n, day) => `${n === 1 ? 'Monthly' : `Every ${n} months`} on day ${day}`,
+      monthlyOnWeekday: (n, nth, dow) => `${n === 1 ? 'Monthly' : `Every ${n} months`} on the ${EN_ORD[nth] ?? `${nth}th`} ${EN_DAYS[dow]}`,
+      yearly: (n) => (n === 1 ? 'Yearly' : `Every ${n} years`),
+      times: (c) => (c === 1 ? ', once' : `, ${c} times`),
+      until: (d) => `, until ${d}`,
+      other: 'Repeats',
+    },
+  },
+  es: {
+    cancelled: 'Cancelado', eventCancelled: 'Este evento está cancelado.', eventCancelledNote: 'Lo dejamos en la lista para que nadie se quede con la duda.',
+    dateCancelled: 'Cancelado el {date}.', dateCancelledNote: 'Las demás fechas siguen como siempre.',
+    details: 'Detalles del evento', joinOnline: 'Unirse en línea', map: 'Mapa', directionsTo: 'Cómo llegar a {place}', mapOf: 'Mapa de {place}',
+    directionsHere: 'Cómo llegar al lugar', mapHere: 'Mapa del lugar', showing: 'Mostrando el {date}',
+    addToCalendar: 'Agregar al calendario', downloadIcs: 'Descargar .ics', share: 'Compartir', linkCopied: 'Enlace copiado',
+    moreEvents: 'Más eventos', fullCalendar: 'Ver el calendario completo →', allDay: 'Todo el día',
+    repeat: {
+      daily: (n) => (n === 1 ? 'Todos los días' : `Cada ${n} días`),
+      weekly: (n, days) => `${n === 1 ? 'Todos los' : `Cada ${n} semanas, los`} ${list(days.map((d) => ES_DAYS_PL[d]), 'y')}`,
+      monthlyOnDay: (n, day) => `El día ${day}${n === 1 ? ' de cada mes' : `, cada ${n} meses`}`,
+      monthlyOnWeekday: (n, nth, dow) => (ES_ORD[nth] ? `El ${ES_ORD[nth]} ${ES_DAYS[dow]}${n === 1 ? ' de cada mes' : `, cada ${n} meses`}` : ''),
+      yearly: (n) => (n === 1 ? 'Cada año' : `Cada ${n} años`),
+      times: (c) => (c === 1 ? ', una vez' : `, ${c} veces`),
+      until: (d) => `, hasta el ${d}`,
+      other: 'Se repite',
+    },
+  },
+  fr: {
+    cancelled: 'Annulé', eventCancelled: 'Cet événement est annulé.', eventCancelledNote: 'Il reste affiché pour que personne ne se pose de questions.',
+    dateCancelled: 'Annulé le {date}.', dateCancelledNote: 'Les autres dates sont maintenues.',
+    details: 'Détails de l’événement', joinOnline: 'Rejoindre en ligne', map: 'Carte', directionsTo: 'Itinéraire vers {place}', mapOf: 'Carte de {place}',
+    directionsHere: 'Itinéraire vers le lieu', mapHere: 'Carte du lieu', showing: 'Date affichée : {date}',
+    addToCalendar: 'Ajouter au calendrier', downloadIcs: 'Télécharger le .ics', share: 'Partager', linkCopied: 'Lien copié',
+    moreEvents: 'Autres événements', fullCalendar: 'Voir tout le calendrier →', allDay: 'Toute la journée',
+    repeat: {
+      daily: (n) => (n === 1 ? 'Tous les jours' : `Tous les ${n} jours`),
+      weekly: (n, days) => (n === 1 ? `Tous les ${list(days.map((d) => `${FR_DAYS[d]}s`), 'et')}` : `Toutes les ${n} semaines, ${list(days.map((d) => `le ${FR_DAYS[d]}`), 'et')}`),
+      monthlyOnDay: (n, day) => `Le ${day === '1' ? '1er' : day}${n === 1 ? ' de chaque mois' : `, tous les ${n} mois`}`,
+      monthlyOnWeekday: (n, nth, dow) => (FR_ORD[nth] ? `Le ${FR_ORD[nth]} ${FR_DAYS[dow]}${n === 1 ? ' de chaque mois' : `, tous les ${n} mois`}` : ''),
+      yearly: (n) => (n === 1 ? 'Chaque année' : `Tous les ${n} ans`),
+      times: (c) => (c === 1 ? ', une fois' : `, ${c} fois`),
+      until: (d) => `, jusqu’au ${d}`,
+      other: 'Récurrent',
+    },
+  },
+  de: {
+    cancelled: 'Abgesagt', eventCancelled: 'Diese Veranstaltung ist abgesagt.', eventCancelledNote: 'Sie bleibt sichtbar, damit sich niemand wundert.',
+    dateCancelled: 'Abgesagt am {date}.', dateCancelledNote: 'Die anderen Termine finden wie gewohnt statt.',
+    details: 'Veranstaltungsdetails', joinOnline: 'Online teilnehmen', map: 'Karte', directionsTo: 'Route zu {place}', mapOf: 'Karte von {place}',
+    directionsHere: 'Route zum Ort', mapHere: 'Karte des Ortes', showing: 'Angezeigt: {date}',
+    addToCalendar: 'Zum Kalender hinzufügen', downloadIcs: '.ics herunterladen', share: 'Teilen', linkCopied: 'Link kopiert',
+    moreEvents: 'Weitere Veranstaltungen', fullCalendar: 'Ganzen Kalender ansehen →', allDay: 'Ganztägig',
+    repeat: {
+      daily: (n) => (n === 1 ? 'Täglich' : `Alle ${n} Tage`),
+      weekly: (n, days) => `${n === 1 ? 'Jeden' : `Alle ${n} Wochen am`} ${list(days.map((d) => DE_DAYS[d]), 'und')}`,
+      monthlyOnDay: (n, day) => `${n === 1 ? 'Monatlich' : `Alle ${n} Monate`} am ${day}.`,
+      monthlyOnWeekday: (n, nth, dow) => (DE_ORD[nth] ? (n === 1 ? `Jeden ${DE_ORD[nth]} ${DE_DAYS[dow]} im Monat` : `Alle ${n} Monate am ${DE_ORD[nth]} ${DE_DAYS[dow]}`) : ''),
+      yearly: (n) => (n === 1 ? 'Jährlich' : `Alle ${n} Jahre`),
+      times: (c) => (c === 1 ? ', einmal' : `, ${c}-mal`),
+      until: (d) => `, bis zum ${d}`,
+      other: 'Wiederkehrend',
+    },
+  },
+  pt: {
+    cancelled: 'Cancelado', eventCancelled: 'Este evento foi cancelado.', eventCancelledNote: 'Ele continua na lista para que ninguém fique na dúvida.',
+    dateCancelled: 'Cancelado em {date}.', dateCancelledNote: 'As outras datas continuam normalmente.',
+    details: 'Detalhes do evento', joinOnline: 'Participar on-line', map: 'Mapa', directionsTo: 'Como chegar a {place}', mapOf: 'Mapa de {place}',
+    directionsHere: 'Como chegar ao local', mapHere: 'Mapa do local', showing: 'Exibindo {date}',
+    addToCalendar: 'Adicionar ao calendário', downloadIcs: 'Baixar .ics', share: 'Compartilhar', linkCopied: 'Link copiado',
+    moreEvents: 'Mais eventos', fullCalendar: 'Ver o calendário completo →', allDay: 'Dia inteiro',
+    repeat: {
+      daily: (n) => (n === 1 ? 'Todos os dias' : `A cada ${n} dias`),
+      weekly: (n, days) => (n === 1
+        ? cap(list(days.map((d) => `${ptFem(d) ? 'toda' : 'todo'} ${PT_DAYS[d]}`), 'e'))
+        : `A cada ${n} semanas, ${list(days.map((d) => `${ptFem(d) ? 'na' : 'no'} ${PT_DAYS[d]}`), 'e')}`),
+      monthlyOnDay: (n, day) => `No dia ${day}${n === 1 ? ' de cada mês' : `, a cada ${n} meses`}`,
+      monthlyOnWeekday: (n, nth, dow) => (PT_ORD[nth] ? `${ptFem(dow) ? 'Na' : 'No'} ${PT_ORD[nth][ptFem(dow) ? 1 : 0]} ${PT_DAYS[dow]}${n === 1 ? ' de cada mês' : `, a cada ${n} meses`}` : ''),
+      yearly: (n) => (n === 1 ? 'Todo ano' : `A cada ${n} anos`),
+      times: (c) => (c === 1 ? ', uma vez' : `, ${c} vezes`),
+      until: (d) => `, até ${d}`,
+      other: 'Repete',
+    },
+  },
+};
+
+export const eventStrings = (locale: string | null | undefined): EventStrings =>
+  STRINGS[(locale || 'en').toLowerCase().split('-')[0]] ?? STRINGS.en;

package/src/lib/calendar/events.ts

@@ -4,6 +4,7 @@
 import type { CalEvent, Calendar, EventLocation, Settings } from '../schema';
 import { expandVEvents, tzParts, zonedToUtc, type CalendarWindow, type IcsTime, type VEvent } from './ics';
 import { cleanRrule } from './rrule';
+import { eventStrings } from './event-words';
 
 const DAY = 86_400_000;
 
@@ -153,6 +154,17 @@ export function expandEvents(events: CalEvent[], settings: Pick<Settings, 'timez
   return out.sort((a, b) => a.start - b.start || a.event.title.localeCompare(b.event.title));
 }
 
+// When RSVPs to one date close (UTC ms), or null when they stay open until it
+// ends: the event's closesAt (wall time in its zone, one instant for every
+// date), else closeBefore minutes before this date's start. A deadline at or
+// after the end isn't one.
+export function rsvpDeadline(o: Pick<Occurrence, 'event' | 'start' | 'end'>, settings: Pick<Settings, 'timezone'>): number | null {
+  const { closesAt, closeBefore } = o.event.rsvp;
+  const w = parseWall(closesAt);
+  const at = w && !w.dateOnly ? wallToMs(w, eventTimeZone(o.event, settings)) : closeBefore > 0 ? o.start - closeBefore * 60_000 : null;
+  return at !== null && at < o.end ? at : null;
+}
+
 // The occurrence of a series with this key (null when the series has no
 // such date: never generated, skipped by exdates, or the series moved)
 export function findOccurrence(e: CalEvent, key: string, settings: Pick<Settings, 'timezone'>, displayTz = settings.timezone || 'UTC'): Occurrence | null {
@@ -232,8 +244,10 @@ export function formatOccurrence(
   let time: string;
   let range: string;
   if (o.allDay) {
-    time = o.days > 1 ? `${shortFmt.format(o.start)} – ${shortFmt.format(o.end - DAY)}` : 'All day';
-    range = o.days > 1 ? time : `${shortFmt.format(o.start)} · All day`;
+    // "All day" in the dates' language
+    const allDay = eventStrings(locale).allDay;
+    time = o.days > 1 ? `${shortFmt.format(o.start)} – ${shortFmt.format(o.end - DAY)}` : allDay;
+    range = o.days > 1 ? time : `${shortFmt.format(o.start)} · ${allDay}`;
   } else {
     time = `${timeFmt.format(o.start)} – ${timeFmt.format(o.end)}${zone ? ` ${zone}` : ''}`;
     range = `${shortFmt.format(o.start)} · ${timeFmt.format(o.start)}`;

package/src/lib/calendar/render.ts

@@ -11,6 +11,7 @@ import { siteLocale } from '../dates';
 import { getCalendarEvents, tzParts, zonedToUtc } from './ics';
 import { calendarPageUrl } from './src';
 import { collectViewEvents, type ViewEvent } from './data';
+import { eventStrings } from './event-words';
 
 // Card sources are ICS feed URLs or native site calendars:
 //   'acms:all'         every public calendar (+ uncategorized events)
@@ -290,7 +291,8 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     min: [minY, minM],
     max: [maxY, maxM],
     months, monthsShort, dows, events, ws,
-    details: 'Details', cancelled: 'Cancelled',
+    // the pop-up's flag in the dates' language, like event cards
+    details: 'Details', cancelled: eventStrings(locale).cancelled,
   };
   const json = JSON.stringify(payload).replace(/</g, '\\u003c');
 

package/src/lib/calendar/rrule.ts

@@ -3,6 +3,7 @@
 // The editor offers the patterns community calendars actually use (daily,
 // weekly on chosen days, monthly by date or by "second Tuesday", yearly) plus
 // an end condition; anything else round-trips as a raw custom RRULE.
+import { eventStrings } from './event-words';
 
 export type RepeatFreq = 'none' | 'DAILY' | 'WEEKLY' | 'MONTHLY' | 'YEARLY' | 'custom';
 
@@ -18,8 +19,6 @@ export interface RepeatParts {
 }
 
 export const WEEKDAY_CODES = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'] as const;
-const WEEKDAY_NAMES = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-const ORDINALS: Record<number, string> = { 1: 'first', 2: 'second', 3: 'third', 4: 'fourth', 5: 'fifth', [-1]: 'last' };
 const ALLOWED_KEYS = new Set(['FREQ', 'INTERVAL', 'COUNT', 'UNTIL', 'BYDAY', 'BYMONTHDAY', 'BYMONTH', 'WKST']);
 
 export function rruleMap(rrule: string): Record<string, string> {
@@ -105,45 +104,42 @@ export function buildRepeat(parts: RepeatParts, start: string): string {
   return out.join(';');
 }
 
-const joinList = (items: string[]) =>
-  items.length <= 1 ? items.join('') : `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]}`;
-
 // "Weekly on Tuesday and Thursday", "Monthly on the first Sunday", "Every 2
-// weeks on Monday, 6 times". English on purpose: it's shown next to other
-// fixed UI copy. Unparseable rules fall back to a generic label.
-export function describeRepeat(rrule: string, start: string, formatDate?: (ymd: string) => string): string {
+// weeks on Monday, 6 times", in `locale` ("Todos los martes y jueves"; words
+// in event-words.ts, English by default). Unparseable rules fall back to a
+// generic label.
+export function describeRepeat(rrule: string, start: string, formatDate?: (ymd: string) => string, locale?: string): string {
   if (!rrule) return '';
+  const w = eventStrings(locale).repeat;
   const p = rruleMap(rrule);
   const n = Math.max(1, Number(p.INTERVAL) || 1);
   const wd = weekdayOf(start);
   let text: string;
   switch (p.FREQ) {
     case 'DAILY':
-      text = n === 1 ? 'Daily' : `Every ${n} days`;
+      text = w.daily(n);
       break;
     case 'WEEKLY': {
       const codes = (p.BYDAY ?? WEEKDAY_CODES[wd.dow]).split(',');
-      const names = WEEKDAY_CODES.filter((c) => codes.includes(c)).map((c) => WEEKDAY_NAMES[WEEKDAY_CODES.indexOf(c)]);
-      text = `${n === 1 ? 'Weekly' : `Every ${n} weeks`} on ${joinList(names)}`;
+      text = w.weekly(n, WEEKDAY_CODES.map((c, i) => (codes.includes(c) ? i : -1)).filter((i) => i >= 0));
       break;
     }
     case 'MONTHLY': {
-      const lead = n === 1 ? 'Monthly' : `Every ${n} months`;
       const m = (p.BYDAY ?? '').match(/^(-?\d)(SU|MO|TU|WE|TH|FR|SA)$/);
-      if (m) text = `${lead} on the ${ORDINALS[Number(m[1])] ?? `${m[1]}th`} ${WEEKDAY_NAMES[WEEKDAY_CODES.indexOf(m[2] as (typeof WEEKDAY_CODES)[number])]}`;
-      else text = `${lead} on day ${p.BYMONTHDAY || wd.day}`;
+      text = m ? w.monthlyOnWeekday(n, Number(m[1]), WEEKDAY_CODES.indexOf(m[2] as (typeof WEEKDAY_CODES)[number])) : w.monthlyOnDay(n, p.BYMONTHDAY || String(wd.day));
       break;
     }
     case 'YEARLY':
-      text = n === 1 ? 'Yearly' : `Every ${n} years`;
+      text = w.yearly(n);
       break;
     default:
-      return 'Repeats';
+      return w.other;
   }
-  if (p.COUNT) text += `, ${p.COUNT} times`;
+  if (!text) return w.other;
+  if (p.COUNT) text += w.times(Number(p.COUNT));
   else if (p.UNTIL) {
     const ymd = `${p.UNTIL.slice(0, 4)}-${p.UNTIL.slice(4, 6)}-${p.UNTIL.slice(6, 8)}`;
-    text += `, until ${formatDate ? formatDate(ymd) : ymd}`;
+    text += w.until(formatDate ? formatDate(ymd) : ymd);
   }
   return text;
 }

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

@@ -1,8 +1,8 @@
 // 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} and {title} slots (live/words.ts
-// `fill`); of a pair (`spotLeft`/`spotsLeft`), the first is for 1 and the
+// 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
 // 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 {
@@ -21,6 +21,12 @@ export interface RsvpStrings {
   requestSeat: string;
   full: string;
   closed: string;
+  /** the event's RSVP deadline ({date} and {time}: deadlineParts): before, and once it passed (under `closed`) */
+  closesOn: string;
+  closedOn: string;
+  /** the address already has an RSVP for this date (nothing else about it is shown) */
+  duplicate: string;
+  duplicateNote: string;
   saveError: string;
   /** the RSVP's own page */
   booked: string;
@@ -53,6 +59,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} going', peopleGoing: '{count} going', spotLeft: '{count} spot left', spotsLeft: '{count} spots left',
     saveSeat: 'Save my seat', nameField: 'Your name', emailField: 'Email', seatsField: 'Seats', confirmSeat: 'Confirm my seat', requestSeat: 'Request a seat',
     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.',
     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.',
@@ -65,6 +73,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} va', peopleGoing: '{count} van', spotLeft: '{count} lugar disponible', spotsLeft: '{count} lugares disponibles',
     saveSeat: 'Apartar mi lugar', nameField: 'Tu nombre', emailField: 'Correo electrónico', seatsField: 'Lugares', confirmSeat: 'Confirmar mi lugar', requestSeat: 'Solicitar un lugar',
     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í.',
     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ó.',
@@ -77,6 +87,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} participant', peopleGoing: '{count} participants', spotLeft: '{count} place restante', spotsLeft: '{count} places restantes',
     saveSeat: 'Réserver ma place', nameField: 'Votre nom', emailField: 'E-mail', seatsField: 'Places', confirmSeat: 'Confirmer ma place', requestSeat: 'Demander une place',
     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.',
     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.',
@@ -89,6 +101,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} Zusage', peopleGoing: '{count} Zusagen', spotLeft: '{count} Platz frei', spotsLeft: '{count} Plätze frei',
     saveSeat: 'Platz reservieren', nameField: 'Ihr Name', emailField: 'E-Mail', seatsField: 'Plätze', confirmSeat: 'Platz bestätigen', requestSeat: 'Platz anfragen',
     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.',
     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.',
@@ -101,6 +115,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} confirmado', peopleGoing: '{count} confirmados', spotLeft: '{count} vaga disponível', spotsLeft: '{count} vagas disponíveis',
     saveSeat: 'Reservar minha vaga', nameField: 'Seu nome', emailField: 'E-mail', seatsField: 'Vagas', confirmSeat: 'Confirmar minha vaga', requestSeat: 'Solicitar uma vaga',
     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á.',
     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.',
@@ -119,3 +135,16 @@ export function aroundCount(count: number, one: string, other: string): [string,
   const [before, after = ''] = (count === 1 ? one : other).split('{count}');
   return [before, after];
 }
+
+/** A deadline's date and time in the event's zone for closesOn/closedOn: { date: 'Fri, Oct 24', time: '9 PM' } (minutes only when it has some). */
+export function deadlineParts(at: number, tz: string, locale: string): { date: string; time: string } {
+  const f = (o: Intl.DateTimeFormatOptions) => {
+    try { return new Intl.DateTimeFormat(locale, { ...o, timeZone: tz }); }
+    catch { return new Intl.DateTimeFormat('en-US', { ...o, timeZone: 'UTC' }); }
+  };
+  const time = f({ hour: 'numeric', minute: '2-digit' });
+  const hour = f({ hour: 'numeric' }).format(at);
+  // "9 PM", "21 Uhr"; a bare "21" (Portuguese) keeps its minutes
+  const whole = time.formatToParts(at).find((p) => p.type === 'minute')?.value === '00' && /\D/.test(hour);
+  return { date: f({ weekday: 'short', month: 'short', day: 'numeric' }).format(at), time: whole ? hour : time.format(at) };
+}

package/src/lib/content-service.ts

@@ -6,7 +6,7 @@ import { ApiError } from './api';
 import { deniedMessage } from './permissions/catalog';
 import { CONTENT, collectionUrl } from './content';
 import { CALENDAR } from './calendar/config';
-import { isValidTimeZone, normalizeEventTimes } from './calendar/events';
+import { formatWall, isValidTimeZone, normalizeEventTimes, parseWall } from './calendar/events';
 import { eventChanged } from './calendar/hooks';
 import { normalizePageLocale } from './i18n';
 import { siteOrigin } from './seo';
@@ -37,10 +37,12 @@ export type PageSave = Omit<Parameters<ContentRepository['updatePage']>[1], 'blo
 // location (see mergeLocationInput) — older clients send name/address/url only
 // cancelledDates is left out: single dates are cancelled at once through
 // cancelOccurrence/restoreOccurrence (lib/calendar/schedule.ts), never staged
-export type EventSave = Partial<Omit<CalEvent, 'id' | 'draft' | 'startAt' | 'endAt' | 'createdAt' | 'updatedAt' | 'sourceUid' | 'publishedAt' | 'location' | 'cancelledDates'>> & {
+// rsvp may leave out the deadline (older clients): the current one stays
+export type EventSave = Partial<Omit<CalEvent, 'id' | 'draft' | 'startAt' | 'endAt' | 'createdAt' | 'updatedAt' | 'sourceUid' | 'publishedAt' | 'location' | 'cancelledDates' | 'rsvp'>> & {
   location?: Partial<EventLocation>;
+  rsvp?: Omit<CalEvent['rsvp'], 'closesAt' | 'closeBefore'> & Partial<Pick<CalEvent['rsvp'], 'closesAt' | 'closeBefore'>>;
 };
-type EventClean = Omit<EventSave, 'location'> & { location?: EventLocation };
+type EventClean = Omit<EventSave, 'location' | 'rsvp'> & { location?: EventLocation; rsvp?: CalEvent['rsvp'] };
 
 const live = (status: string) => status === 'published' || status === 'scheduled';
 /** publishing, scheduling, unpublishing or applying staged edits needs Publish content */
@@ -130,18 +132,28 @@ export async function applyPageUpdate(repo: ContentRepository, id: string, hooks
 // Validate + normalize an event save. Times are checked as a PAIR against the
 // merged (staged) state so a half-edited range can't slip through.
 export async function cleanEventInput(repo: ContentRepository, data: EventSave, before: CalEvent): Promise<EventClean> {
-  const { location, ...rest } = data;
+  const { location, rsvp, ...rest } = data;
   const out: EventClean = { ...rest };
-  // Older editor clients resend the original RSVP shape. Omission must not
-  // erase questions that were authored in a newer editor.
-  if (out.rsvp && !Object.hasOwn(out.rsvp, 'form')) {
-    const previous = mergeEventDraft(before).rsvp.form;
-    if (previous) out.rsvp = { ...out.rsvp, form: previous };
-  }
-  if (out.rsvp?.form !== undefined) {
-    const form = FormDefinition.safeParse(out.rsvp.form);
-    if (!form.success) throw new ApiError(400, form.error.issues[0]?.message || 'Invalid registration form.');
-    out.rsvp = { ...out.rsvp, form: form.data };
+  if (rsvp) {
+    // Older editor clients resend the original RSVP shape. Omission must not
+    // erase questions or a deadline that were authored in a newer editor.
+    const previous = mergeEventDraft(before).rsvp;
+    const next: CalEvent['rsvp'] = { ...rsvp, closesAt: rsvp.closesAt === undefined ? previous.closesAt ?? null : rsvp.closesAt || null, closeBefore: rsvp.closeBefore ?? previous.closeBefore ?? 0 };
+    if (!Object.hasOwn(rsvp, 'form') && previous.form) next.form = previous.form;
+    if (next.form !== undefined) {
+      const form = FormDefinition.safeParse(next.form);
+      if (!form.success) throw new ApiError(400, form.error.issues[0]?.message || 'Invalid registration form.');
+      next.form = form.data;
+    }
+    if (next.closesAt !== null) {
+      const w = parseWall(next.closesAt);
+      if (!w || w.dateOnly) throw new ApiError(400, 'The RSVP deadline must be a date and time (YYYY-MM-DDTHH:mm).');
+      next.closesAt = formatWall(w);
+    }
+    if (!Number.isInteger(next.closeBefore) || next.closeBefore < 0 || next.closeBefore > 60 * 1440) {
+      throw new ApiError(400, 'The RSVP deadline can be at most 60 days before each date (closeBefore: 0–86400 minutes).');
+    }
+    out.rsvp = next;
   }
   if (location !== undefined) out.location = mergeLocationInput(mergeEventDraft(before).location, location);
   if (out.slug !== undefined) {

package/src/lib/drafts.ts

@@ -52,6 +52,8 @@ export function pickEventDraft(draft: Record<string, unknown>): Partial<Pick<Cal
     const loc = EventLocation.safeParse(out.location);
     if (loc.success) out.location = loc.data; else delete out.location;
   }
+  // and before RSVP deadlines: none
+  if (out.rsvp) out.rsvp = { ...out.rsvp, closesAt: out.rsvp.closesAt ?? null, closeBefore: out.rsvp.closeBefore ?? 0 };
   return out;
 }
 export function pickPageDraft(draft: Record<string, unknown>): Partial<Pick<Page, PageDraftKey>> {

package/src/lib/editor/documents.ts

@@ -160,7 +160,9 @@ export const EventFields = z.object({ ...common, excerpt: text(1000), tags: z.ar
   }).partial({ lat: true, lng: true, placeId: true, showMap: true, mapImage: true, mapImageDark: true }).strict(),
   cta: z.object({ label: text(120), href: text(1000), style: z.enum(['primary', 'outline']) }).strict(),
   calendarIds: z.array(text(100)).max(50), fields: z.record(text(2000)),
-  rsvp: z.object({ enabled: z.boolean(), capacity: z.number().int().min(0).max(100000), autoConfirm: z.boolean(), maxSeats: z.number().int().min(1).max(50), form: FormDefinition.optional() }).strict(),
+  // closesAt: wall time in the event's zone ('YYYY-MM-DDTHH:mm'); closeBefore: minutes before each date. Left out = kept
+  rsvp: z.object({ enabled: z.boolean(), capacity: z.number().int().min(0).max(100000), autoConfirm: z.boolean(), maxSeats: z.number().int().min(1).max(50),
+    closesAt: text(40).nullable().optional(), closeBefore: z.number().int().min(0).max(86400).optional(), form: FormDefinition.optional() }).strict(),
 }).partial().strict();
 export const SaveInput = z.object({ revision: z.string().max(60), fields: z.record(z.unknown()) }).strict();
 

package/src/lib/editor/schemas.ts

@@ -47,7 +47,7 @@ export const EditorDocument = EditorDocumentSummary.extend({
   event: z.object({
     start: str, end: str, allDay: bool, timezone: str, rrule: str, exdates: z.array(str), cancelled: bool,
     location: z.object({ name: str, address: str, url: str, lat: num.nullable(), lng: num.nullable(), placeId: str, showMap: bool, mapImage: str, mapImageDark: str }), cta: z.object({ label: str, href: str, style: z.enum(['primary', 'outline']) }),
-    calendarIds: z.array(str), fields: z.record(str), rsvp: z.object({ enabled: bool, capacity: num, autoConfirm: bool, maxSeats: num, form: FormDefinition.optional() }),
+    calendarIds: z.array(str), fields: z.record(str), rsvp: z.object({ enabled: bool, capacity: num, autoConfirm: bool, maxSeats: num, closesAt: str.nullable(), closeBefore: num, form: FormDefinition.optional() }),
   }).nullable(),
   languages: z.array(str),
 });