@acms-subir/core 0.3.37 → 0.3.38

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;
 
@@ -232,8 +233,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/email/booking-words.ts

@@ -0,0 +1,203 @@
+// Words of the booking and RSVP emails (lib/booking/emails.ts), in the
+// language the person booked in, and of a room booking's own page
+// (book/manage; an RSVP's page words are in calendar/rsvp-words.ts). Emails
+// say usted in Spanish, like the privacy notice; the website's pages say tú,
+// like the RSVP words. Plain strings with {name}, {title}, {when}, {ref},
+// {url} and {hours} slots (live/words.ts `fill`). `rsvp` rewords a few
+// messages for a seat at an event (English says "booking" for both). Staff
+// emails use the site's main language. Other languages fall back to English.
+export type GuestMail = 'received' | 'confirmed' | 'declined' | 'cancelled' | 'updated' | 'rescheduled' | 'reminder';
+export interface MailCopy { subject: string; heading: string; intro: string }
+
+export interface BookingStrings {
+  mail: Record<GuestMail, MailCopy>;
+  /** the button to the booking's own page */
+  manage: string;
+  rsvp: { manage: string } & Partial<Record<GuestMail, Partial<MailCopy>>>;
+  /** the details table */
+  what: string;
+  when: string;
+  where: string;
+  seats: string;
+  reference: string;
+  /** the calendar file's description */
+  icsManage: string;
+  /** a pending booking nobody answered in time, declined automatically */
+  lateDecline: string;
+  staff: { pending: string; booked: string; review: string; open: string; pendingSubject: string; bookedSubject: string };
+  /** a room booking's own page: what differs from an RSVP's (rsvp-words.ts) */
+  page: {
+    untitled: string;
+    booked: string;
+    yours: string;
+    moved: string;
+    notAvailable: string;
+    cancelledTitle: string;
+    declined: string;
+    cancelledText: string;
+    statuses: Record<'pending' | 'confirmed' | 'cancelled' | 'declined', string>;
+    reschedule: string;
+    cancel: string;
+    cancelConfirm: string;
+    cutoff: string;
+    keepLink: string;
+  };
+}
+
+const STRINGS: Record<string, BookingStrings> = {
+  en: {
+    mail: {
+      received: { subject: 'Request received: {title}', heading: 'Request received', intro: 'Thanks, {name}. We\'ll confirm by email soon.' },
+      confirmed: { subject: 'Confirmed: {title} — {when}', heading: 'You’re booked', intro: 'It’s confirmed. Import the attached file to add it to your calendar.' },
+      declined: { subject: 'Not available: {title}', heading: 'We couldn’t confirm your request', intro: 'Sorry — this time isn’t available. You’re welcome to pick another.' },
+      cancelled: { subject: 'Cancelled: {title}', heading: 'Booking cancelled', intro: 'This booking has been cancelled.' },
+      updated: { subject: 'Updated: {title}', heading: 'Booking details updated', intro: 'Please review the latest details. Use the attached calendar file to update your calendar.' },
+      rescheduled: { subject: 'New time: {title} — {when}', heading: 'Booking moved', intro: 'Your booking has a new time. Import the attached calendar file to update your calendar.' },
+      reminder: { subject: 'Reminder: {title} — {when}', heading: 'Coming up soon', intro: 'A quick reminder about your booking.' },
+    },
+    manage: 'View or change your booking', rsvp: { manage: 'View or change your booking' },
+    what: 'What', when: 'When', where: 'Where', seats: 'Seats', reference: 'Reference {ref}', icsManage: 'Manage: {url}',
+    lateDecline: 'We weren’t able to confirm this booking in time. Please pick another time.',
+    staff: { pending: 'New request to approve', booked: 'New booking', review: 'Review in the admin', open: 'Open in the admin', pendingSubject: 'Approve: {title} — {when}', bookedSubject: 'New booking: {title} — {when}' },
+    page: {
+      untitled: 'Booking', booked: 'You’re booked', yours: 'Your booking', moved: 'Booking moved', notAvailable: 'Not available', cancelledTitle: 'Booking cancelled',
+      declined: 'Sorry — this time couldn’t be confirmed. You’re welcome to pick another.', cancelledText: 'This booking is cancelled.',
+      statuses: { pending: 'Pending', confirmed: 'Confirmed', cancelled: 'Cancelled', declined: 'Declined' },
+      reschedule: 'Reschedule', cancel: 'Cancel booking', cancelConfirm: 'Cancel this booking?',
+      cutoff: 'Changes close {hours} hours before the start. Please contact us to change or cancel.',
+      keepLink: 'Keep this link — anyone with it can change this booking.',
+    },
+  },
+  es: {
+    mail: {
+      received: { subject: 'Solicitud recibida: {title}', heading: 'Solicitud recibida', intro: 'Gracias, {name}. Le confirmaremos por correo muy pronto.' },
+      confirmed: { subject: 'Confirmada: {title} — {when}', heading: 'Su reservación está confirmada', intro: 'Ya está confirmada. Importe el archivo adjunto para agregarla a su calendario.' },
+      declined: { subject: 'No disponible: {title}', heading: 'No pudimos confirmar su solicitud', intro: 'Lo sentimos, este horario no está disponible. Puede elegir otro cuando guste.' },
+      cancelled: { subject: 'Cancelada: {title}', heading: 'Reservación cancelada', intro: 'Esta reservación se canceló.' },
+      updated: { subject: 'Actualizada: {title}', heading: 'Cambiaron los detalles de su reservación', intro: 'Revise los detalles más recientes. Use el archivo de calendario adjunto para actualizar su calendario.' },
+      rescheduled: { subject: 'Nuevo horario: {title} — {when}', heading: 'Su reservación cambió de horario', intro: 'Su reservación tiene un nuevo horario. Importe el archivo de calendario adjunto para actualizar su calendario.' },
+      reminder: { subject: 'Recordatorio: {title} — {when}', heading: 'Ya casi es la fecha', intro: 'Un breve recordatorio de su reservación.' },
+    },
+    manage: 'Ver o cambiar su reservación',
+    rsvp: {
+      manage: 'Ver o cambiar su confirmación',
+      confirmed: { subject: 'Confirmado: {title} — {when}', heading: 'Ya tiene su lugar', intro: 'Está confirmado. Importe el archivo adjunto para agregarlo a su calendario.' },
+      declined: { intro: 'Lo sentimos, el organizador no pudo confirmar su lugar.' },
+      cancelled: { subject: 'Cancelado: {title}', heading: 'Confirmación cancelada', intro: 'Esta confirmación se canceló.' },
+      updated: { subject: 'Actualizado: {title}', heading: 'Cambiaron los detalles' },
+      reminder: { intro: 'Un breve recordatorio: tiene un lugar apartado.' },
+    },
+    what: 'Qué', when: 'Cuándo', where: 'Dónde', seats: 'Lugares', reference: 'Referencia {ref}', icsManage: 'Ver o cambiar: {url}',
+    lateDecline: 'No pudimos confirmar esta reservación a tiempo. Por favor, elija otro horario.',
+    staff: { pending: 'Nueva solicitud por aprobar', booked: 'Nueva reservación', review: 'Revisar en el panel', open: 'Abrir en el panel', pendingSubject: 'Por aprobar: {title} — {when}', bookedSubject: 'Nueva reservación: {title} — {when}' },
+    page: {
+      untitled: 'Reservación', booked: 'Tu reservación está confirmada', yours: 'Tu reservación', moved: 'Tu reservación cambió de horario', notAvailable: 'No disponible', cancelledTitle: 'Reservación cancelada',
+      declined: 'Lo sentimos, no se pudo confirmar este horario. Puedes elegir otro.', cancelledText: 'Esta reservación se canceló.',
+      statuses: { pending: 'Pendiente', confirmed: 'Confirmada', cancelled: 'Cancelada', declined: 'Rechazada' },
+      reschedule: 'Cambiar horario', cancel: 'Cancelar reservación', cancelConfirm: '¿Cancelar esta reservación?',
+      cutoff: 'Los cambios se cierran {hours} horas antes del inicio. Escríbenos para cambiarla o cancelarla.',
+      keepLink: 'Guarda este enlace: quien lo tenga puede cambiar esta reservación.',
+    },
+  },
+  fr: {
+    mail: {
+      received: { subject: 'Demande reçue : {title}', heading: 'Demande reçue', intro: 'Merci, {name}. Nous vous confirmerons par e-mail très bientôt.' },
+      confirmed: { subject: 'Confirmée : {title} — {when}', heading: 'Votre réservation est confirmée', intro: 'C’est confirmé. Importez le fichier joint pour l’ajouter à votre calendrier.' },
+      declined: { subject: 'Indisponible : {title}', heading: 'Nous n’avons pas pu confirmer votre demande', intro: 'Désolés, ce créneau n’est pas disponible. N’hésitez pas à en choisir un autre.' },
+      cancelled: { subject: 'Annulée : {title}', heading: 'Réservation annulée', intro: 'Cette réservation a été annulée.' },
+      updated: { subject: 'Mise à jour : {title}', heading: 'Détails de la réservation mis à jour', intro: 'Veuillez vérifier les derniers détails. Utilisez le fichier de calendrier joint pour mettre à jour votre calendrier.' },
+      rescheduled: { subject: 'Nouvel horaire : {title} — {when}', heading: 'Réservation déplacée', intro: 'Votre réservation a un nouvel horaire. Importez le fichier de calendrier joint pour mettre à jour votre calendrier.' },
+      reminder: { subject: 'Rappel : {title} — {when}', heading: 'C’est bientôt', intro: 'Un petit rappel de votre réservation.' },
+    },
+    manage: 'Voir ou modifier votre réservation',
+    rsvp: {
+      manage: 'Voir ou modifier votre inscription',
+      confirmed: { heading: 'Votre place est réservée' },
+      declined: { intro: 'Désolés, l’organisateur n’a pas pu confirmer votre inscription.' },
+      cancelled: { heading: 'Inscription annulée', intro: 'Cette inscription a été annulée.' },
+      updated: { heading: 'Détails mis à jour' },
+      reminder: { intro: 'Un petit rappel de votre inscription.' },
+    },
+    what: 'Quoi', when: 'Quand', where: 'Où', seats: 'Places', reference: 'Référence {ref}', icsManage: 'Gérer : {url}',
+    lateDecline: 'Nous n’avons pas pu confirmer cette réservation à temps. Veuillez choisir un autre horaire.',
+    staff: { pending: 'Nouvelle demande à valider', booked: 'Nouvelle réservation', review: 'Examiner dans l’administration', open: 'Ouvrir dans l’administration', pendingSubject: 'À valider : {title} — {when}', bookedSubject: 'Nouvelle réservation : {title} — {when}' },
+    page: {
+      untitled: 'Réservation', booked: 'Votre réservation est confirmée', yours: 'Votre réservation', moved: 'Réservation déplacée', notAvailable: 'Indisponible', cancelledTitle: 'Réservation annulée',
+      declined: 'Désolés, ce créneau n’a pas pu être confirmé. N’hésitez pas à en choisir un autre.', cancelledText: 'Cette réservation est annulée.',
+      statuses: { pending: 'En attente', confirmed: 'Confirmée', cancelled: 'Annulée', declined: 'Refusée' },
+      reschedule: 'Changer d’horaire', cancel: 'Annuler la réservation', cancelConfirm: 'Annuler cette réservation ?',
+      cutoff: 'Les modifications ferment {hours} heures avant le début. Contactez-nous pour la modifier ou l’annuler.',
+      keepLink: 'Conservez ce lien : toute personne qui l’a peut modifier cette réservation.',
+    },
+  },
+  de: {
+    mail: {
+      received: { subject: 'Anfrage erhalten: {title}', heading: 'Anfrage erhalten', intro: 'Danke, {name}. Wir bestätigen sie Ihnen bald per E-Mail.' },
+      confirmed: { subject: 'Bestätigt: {title} — {when}', heading: 'Ihre Buchung ist bestätigt', intro: 'Alles bestätigt. Importieren Sie die angehängte Datei, um den Termin in Ihren Kalender aufzunehmen.' },
+      declined: { subject: 'Nicht verfügbar: {title}', heading: 'Wir konnten Ihre Anfrage nicht bestätigen', intro: 'Leider ist dieser Termin nicht verfügbar. Wählen Sie gern einen anderen.' },
+      cancelled: { subject: 'Storniert: {title}', heading: 'Buchung storniert', intro: 'Diese Buchung wurde storniert.' },
+      updated: { subject: 'Aktualisiert: {title}', heading: 'Buchungsdetails aktualisiert', intro: 'Bitte prüfen Sie die aktuellen Details. Mit der angehängten Kalenderdatei aktualisieren Sie Ihren Kalender.' },
+      rescheduled: { subject: 'Neuer Termin: {title} — {when}', heading: 'Buchung verschoben', intro: 'Ihre Buchung hat einen neuen Termin. Importieren Sie die angehängte Kalenderdatei, um Ihren Kalender zu aktualisieren.' },
+      reminder: { subject: 'Erinnerung: {title} — {when}', heading: 'Bald ist es so weit', intro: 'Eine kurze Erinnerung an Ihre Buchung.' },
+    },
+    manage: 'Buchung ansehen oder ändern',
+    rsvp: {
+      manage: 'Anmeldung ansehen oder ändern',
+      confirmed: { heading: 'Ihr Platz ist reserviert' },
+      declined: { intro: 'Leider konnte der Veranstalter Ihre Anmeldung nicht bestätigen.' },
+      cancelled: { heading: 'Anmeldung storniert', intro: 'Diese Anmeldung wurde storniert.' },
+      updated: { heading: 'Details aktualisiert' },
+      reminder: { intro: 'Eine kurze Erinnerung an Ihre Anmeldung.' },
+    },
+    what: 'Was', when: 'Wann', where: 'Wo', seats: 'Plätze', reference: 'Referenz {ref}', icsManage: 'Verwalten: {url}',
+    lateDecline: 'Wir konnten diese Buchung nicht rechtzeitig bestätigen. Bitte wählen Sie einen anderen Termin.',
+    staff: { pending: 'Neue Anfrage zur Freigabe', booked: 'Neue Buchung', review: 'In der Verwaltung prüfen', open: 'In der Verwaltung öffnen', pendingSubject: 'Freigeben: {title} — {when}', bookedSubject: 'Neue Buchung: {title} — {when}' },
+    page: {
+      untitled: 'Buchung', booked: 'Ihre Buchung ist bestätigt', yours: 'Ihre Buchung', moved: 'Buchung verschoben', notAvailable: 'Nicht verfügbar', cancelledTitle: 'Buchung storniert',
+      declined: 'Leider konnte dieser Termin nicht bestätigt werden. Wählen Sie gern einen anderen.', cancelledText: 'Diese Buchung ist storniert.',
+      statuses: { pending: 'Ausstehend', confirmed: 'Bestätigt', cancelled: 'Storniert', declined: 'Abgelehnt' },
+      reschedule: 'Verschieben', cancel: 'Buchung stornieren', cancelConfirm: 'Diese Buchung stornieren?',
+      cutoff: 'Änderungen sind bis {hours} Stunden vor Beginn möglich. Bitte kontaktieren Sie uns, um sie zu ändern oder zu stornieren.',
+      keepLink: 'Bewahren Sie diesen Link auf – wer ihn hat, kann diese Buchung ändern.',
+    },
+  },
+  pt: {
+    mail: {
+      received: { subject: 'Pedido recebido: {title}', heading: 'Pedido recebido', intro: 'Obrigado, {name}. Vamos confirmar por e-mail em breve.' },
+      confirmed: { subject: 'Confirmada: {title} — {when}', heading: 'Sua reserva está confirmada', intro: 'Está confirmada. Importe o arquivo anexo para adicioná-la ao seu calendário.' },
+      declined: { subject: 'Indisponível: {title}', heading: 'Não conseguimos confirmar seu pedido', intro: 'Desculpe, este horário não está disponível. Fique à vontade para escolher outro.' },
+      cancelled: { subject: 'Cancelada: {title}', heading: 'Reserva cancelada', intro: 'Esta reserva foi cancelada.' },
+      updated: { subject: 'Atualizada: {title}', heading: 'Detalhes da reserva atualizados', intro: 'Confira os detalhes mais recentes. Use o arquivo de calendário anexo para atualizar seu calendário.' },
+      rescheduled: { subject: 'Novo horário: {title} — {when}', heading: 'Reserva remarcada', intro: 'Sua reserva tem um novo horário. Importe o arquivo de calendário anexo para atualizar seu calendário.' },
+      reminder: { subject: 'Lembrete: {title} — {when}', heading: 'Está chegando', intro: 'Um lembrete rápido sobre sua reserva.' },
+    },
+    manage: 'Ver ou alterar sua reserva',
+    rsvp: {
+      manage: 'Ver ou alterar sua inscrição',
+      confirmed: { heading: 'Sua vaga está reservada' },
+      declined: { intro: 'Desculpe, o organizador não pôde confirmar sua inscrição.' },
+      cancelled: { heading: 'Inscrição cancelada', intro: 'Esta inscrição foi cancelada.' },
+      updated: { heading: 'Detalhes atualizados' },
+      reminder: { intro: 'Um lembrete rápido sobre sua inscrição.' },
+    },
+    what: 'O quê', when: 'Quando', where: 'Onde', seats: 'Vagas', reference: 'Referência {ref}', icsManage: 'Gerenciar: {url}',
+    lateDecline: 'Não conseguimos confirmar esta reserva a tempo. Por favor, escolha outro horário.',
+    staff: { pending: 'Novo pedido para aprovar', booked: 'Nova reserva', review: 'Revisar no painel', open: 'Abrir no painel', pendingSubject: 'Aprovar: {title} — {when}', bookedSubject: 'Nova reserva: {title} — {when}' },
+    page: {
+      untitled: 'Reserva', booked: 'Sua reserva está confirmada', yours: 'Sua reserva', moved: 'Reserva remarcada', notAvailable: 'Indisponível', cancelledTitle: 'Reserva cancelada',
+      declined: 'Desculpe, não foi possível confirmar este horário. Fique à vontade para escolher outro.', cancelledText: 'Esta reserva foi cancelada.',
+      statuses: { pending: 'Pendente', confirmed: 'Confirmada', cancelled: 'Cancelada', declined: 'Recusada' },
+      reschedule: 'Remarcar', cancel: 'Cancelar reserva', cancelConfirm: 'Cancelar esta reserva?',
+      cutoff: 'As alterações se encerram {hours} horas antes do início. Fale com a gente para alterar ou cancelar.',
+      keepLink: 'Guarde este link: qualquer pessoa com ele pode alterar esta reserva.',
+    },
+  },
+};
+
+export const bookingStrings = (locale: string | null | undefined): BookingStrings =>
+  STRINGS[(locale || 'en').toLowerCase().split('-')[0]] ?? STRINGS.en;
+
+/** one guest email's subject, heading and intro: a booking's, or an RSVP's where the language words it differently */
+export function mailCopy(w: BookingStrings, kind: GuestMail, rsvp: boolean): MailCopy {
+  return rsvp ? { ...w.mail[kind], ...w.rsvp[kind] } : w.mail[kind];
+}

package/src/lib/forms/events.ts

@@ -17,7 +17,8 @@ export async function prepareLegacyEventForm(event: CalEvent, start: number, dat
   }
 }
 
-export async function submitEventForm(repo: ContentRepository, event: CalEvent, occurrence: { start: number; end: number }, data: FormData, requestId: string, flow: Parameters<typeof createRsvp>[2]) {
+// locale: the page's language, so the RSVP's emails and links speak it
+export async function submitEventForm(repo: ContentRepository, event: CalEvent, occurrence: { start: number; end: number }, data: FormData, requestId: string, flow: Parameters<typeof createRsvp>[2], locale = '') {
   if (event.status !== 'published') throw new ApiError(404, 'Event not found.');
   if (Number(data.get('occurrence')) !== occurrence.start) throw new ApiError(409, 'The event time has changed. Review the date and try again.');
   const seats = Number(data.get('seats') || 1);
@@ -35,6 +36,7 @@ export async function submitEventForm(repo: ContentRepository, event: CalEvent,
   };
   const existing = await replay(); if (existing) return existing;
   await collectResponse(definition, booker.answers, booker.formVersion);
-  try { return await createRsvp(repo, { event, ...occurrence, seats, booker }, { ...flow, idempotency }); }
+  // the language isn't part of the retry check: it doesn't change what was asked for
+  try { return await createRsvp(repo, { event, ...occurrence, seats, booker: { ...booker, locale } }, { ...flow, idempotency }); }
   catch (e) { const existing = await replay(); if (existing) return existing; throw e; }
 }

package/src/lib/mobile/bookings.ts

@@ -9,12 +9,15 @@ import { waitUntilFrom } from '../webhooks';
 import { requireCalendar } from './calendar';
 import { appAnswers, joinAnswers } from './forms';
 import { rsvpClosed, rsvpOccurrence, rsvpQuestions } from './rsvp';
+import { localeQuery, mobileLocale } from './locale';
 
 const common = {
   start: z.string().datetime({ offset: true }),
   name: z.string().trim().min(1).max(120), email: z.string().trim().email().max(200).transform(v => v.toLowerCase()),
   phone: z.string().trim().max(40).default(''),
   answers: appAnswers.default({}),
+  // the app's language (one of the site's locales): the emails and links speak it
+  locale: localeQuery,
 };
 export const bookingInput = z.union([
   z.object({ ...common, resource: z.string().min(1).max(200), link: z.string().min(1).max(200),
@@ -36,7 +39,11 @@ export async function submitBooking(repo: ContentRepository, request: Request, l
   if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(key)) throw new ApiError(400, 'Send a random UUID v4 in Idempotency-Key and reuse it only for retries.');
   const body = bookingInput.parse(await readJson(request, 50000));
   if (!('event' in body)) requireCalendar(true);
-  const idempotency = { keyHash: await sha256Hex(key.toLowerCase()), requestHash: await sha256Hex(canonical(body)) };
+  const locale = mobileLocale(body.locale) ?? '';
+  // the language isn't a booking detail: a retry in another one replays the
+  // same booking, and keys saved before apps sent it still match
+  const { locale: _language, ...asked } = body;
+  const idempotency = { keyHash: await sha256Hex(key.toLowerCase()), requestHash: await sha256Hex(canonical(asked)) };
   const replay = async () => {
     const record = await repo.getBookingRequest(idempotency.keyHash);
     if (!record) return null;
@@ -51,7 +58,7 @@ export async function submitBooking(repo: ContentRepository, request: Request, l
     const settings = await repo.getSettings();
     const flow = { origin: siteOrigin(settings, new URL(request.url)), locals, waitUntil: waitUntilFrom(locals), idempotency };
     const start = Date.parse(body.start);
-    const booker = { ...body, answers: joinAnswers(body.answers) };
+    const booker = { ...body, answers: joinAnswers(body.answers), locale };
     let booking: Booking;
     if ('event' in body) {
       const occurrence = await rsvpOccurrence(repo, body.event, body.start);

package/src/lib/mobile/calendar.ts

@@ -13,6 +13,7 @@ import { pageQuery, isoDay, isoDayOrInstant, queryParams } from './http';
 import { localizeDoc } from '../translations';
 import { localeQuery, mobileLocale, localizedUrl } from './locale';
 import { confirmsInstantly, linkApproval } from '../booking/approval';
+import { changeTopics } from '../push/service';
 
 export function requireCalendar(bookings = false) {
   if (!CALENDAR.enabled || (bookings && !bookingsEnabled())) throw new ApiError(404, 'This feature is disabled.');
@@ -59,20 +60,21 @@ export async function listEvents(repo: ContentRepository, url: URL) {
     occurrences: occurrences.slice(start, start + q.limit).map(o => ({
       id: `${o.event.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay,
       cancelled: o.cancelled,
-      event: publicEventDto(o.event, origin, publicCalendars, settings.timezone, locale),
+      event: publicEventDto(o.event, origin, publicCalendars, settings, locale),
     })),
     pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
   };
 }
 // e is already localized; publicCalendars limits which calendars are named
-export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, siteTz: string, locale: string | null) {
-  const event = eventToJson(e, origin, publicCalendars, siteTz);
+export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, settings: Settings, locale: string | null) {
+  const event = eventToJson(e, origin, publicCalendars, settings.timezone);
   event.url = localizedUrl(event.url, origin, locale);
   // Only configured public event fields; no undeclared imported metadata, no private fields.
   event.fields = publicEventFields(e.fields);
   event.image = safeUrl(e.cover, origin);
   event.cta = { ...event.cta, href: localizedUrl(safeUrl(event.cta.href, origin, true), origin, locale) };
-  return event;
+  // which push topics hear about date, time or place changes ([] = none do)
+  return { ...event, notify: { changes: changeTopics(e, settings, publicCalendars) } };
 }
 export async function listResources(repo: ContentRepository, url: URL) {
   requireCalendar(true);

package/src/lib/mobile/guest.ts

@@ -4,7 +4,8 @@ import type { Booking } from '../schema';
 import { ApiError, readJson } from '../api';
 import { sha256Hex } from '../api-keys';
 import { randomToken, safeEqual } from '../editor/auth';
-import { CALENDAR, bookingsEnabled, manageUrl } from '../calendar/config';
+import { CALENDAR, bookingsEnabled } from '../calendar/config';
+import { bookingManagePath } from '../booking/emails';
 import { encrypt, encryptionAvailable, resolveConfig, validAddress } from '../email/config';
 import { kickEmail } from '../email/service';
 import { guestChanges } from '../booking/service';
@@ -144,7 +145,7 @@ export async function myBookings(c: PublicContext) {
         start: new Date(b.start).toISOString(), end: new Date(b.end).toISOString(), seats: b.seats,
         title: event ? event.title : [resource?.name, link?.name].filter(Boolean).join(' · ') || 'Booking',
         // use with the Booking-Token header on /bookings/manage/*
-        manageToken: b.manageToken, manageUrl: origin + manageUrl(b.manageToken),
+        manageToken: b.manageToken, manageUrl: origin + bookingManagePath(b),
         can: guestChanges(b, link, now),
       };
     }),