@acms-subir/core 0.3.37 → 0.3.39

package/src/lib/email/booking-words.ts

@@ -0,0 +1,212 @@
+// 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' | 'link';
+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.' },
+      link: { subject: 'Your booking: {title}', heading: 'You already have this booking', intro: 'We got another request for this date with your email address, so nothing changed. To see or change your booking, use the button below.' },
+    },
+    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.' },
+      link: { subject: 'Su reservación: {title}', heading: 'Ya tiene esta reservación', intro: 'Recibimos otra solicitud para este horario con su correo, así que no cambió nada. Para ver o cambiar su reservación, use el botón de abajo.' },
+    },
+    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.' },
+      link: { subject: 'Su confirmación para {title}', heading: 'Ya tiene una confirmación', intro: 'Recibimos otra confirmación para esta fecha con su correo, así que no cambió nada. Para cambiar la suya, o agregar lugares, use el botón de abajo.' },
+    },
+    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.' },
+      link: { subject: 'Votre réservation : {title}', heading: 'Vous avez déjà cette réservation', intro: 'Nous avons reçu une autre demande pour ce créneau avec votre adresse e-mail, donc rien n’a changé. Pour voir ou modifier votre réservation, utilisez le bouton ci-dessous.' },
+    },
+    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.' },
+      link: { subject: 'Votre inscription : {title}', heading: 'Vous avez déjà une inscription', intro: 'Nous avons reçu une autre inscription pour cette date avec votre adresse e-mail, donc rien n’a changé. Pour modifier la vôtre ou ajouter des places, utilisez le bouton ci-dessous.' },
+    },
+    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.' },
+      link: { subject: 'Ihre Buchung: {title}', heading: 'Sie haben diese Buchung schon', intro: 'Wir haben eine weitere Anfrage für diesen Termin mit Ihrer E-Mail-Adresse erhalten, es hat sich also nichts geändert. Über den Button unten sehen oder ändern Sie 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.' },
+      link: { subject: 'Ihre Anmeldung: {title}', heading: 'Sie sind schon angemeldet', intro: 'Wir haben eine weitere Anmeldung für diesen Termin mit Ihrer E-Mail-Adresse erhalten, es hat sich also nichts geändert. Über den Button unten ändern Sie Ihre Anmeldung oder fügen Plätze hinzu.' },
+    },
+    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.' },
+      link: { subject: 'Sua reserva: {title}', heading: 'Você já tem esta reserva', intro: 'Recebemos outro pedido para este horário com seu e-mail, então nada mudou. Para ver ou alterar sua reserva, use o botão abaixo.' },
+    },
+    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.' },
+      link: { subject: 'Sua inscrição em {title}', heading: 'Você já tem uma inscrição', intro: 'Recebemos outra inscrição para esta data com seu e-mail, então nada mudou. Para alterar a sua, ou adicionar vagas, use o botão abaixo.' },
+    },
+    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);
@@ -59,7 +66,7 @@ export async function submitBooking(repo: ContentRepository, request: Request, l
       if (body.seats > (event.rsvp.maxSeats || 1)) throw new ApiError(400, 'Too many seats for one RSVP.');
       // the app must have seen the current questions: a changed form then answers 409, as on the website
       // (closed dates fall through to createRsvp's own answer)
-      if (!body.formVersion && rsvpQuestions(event) && !rsvpClosed(occurrence)) throw new ApiError(400, 'This event asks questions. Send formVersion from GET /api/v1/events/{slug}/rsvp with the answers.');
+      if (!body.formVersion && rsvpQuestions(event) && !rsvpClosed(occurrence, settings)) throw new ApiError(400, 'This event asks questions. Send formVersion from GET /api/v1/events/{slug}/rsvp with the answers.');
       booking = await createRsvp(repo, { event, start, end: occurrence.end, seats: body.seats, booker, source: 'app' }, flow);
     } else {
       const resource = await repo.getResourceBySlug(body.resource);

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),
       };
     }),

package/src/lib/mobile/http.ts

@@ -33,7 +33,7 @@ export function failure(error: unknown) {
   const status = error instanceof ApiError || error instanceof BookingError ? error.status : error instanceof z.ZodError ? 400 : 500;
   const codes: Record<number, string> = { 400: 'invalid_request', 401: 'unauthorized', 403: 'forbidden', 404: 'not_found', 405: 'method_not_allowed', 409: 'conflict', 410: 'gone', 413: 'payload_too_large', 415: 'unsupported_media_type', 429: 'rate_limited', 502: 'upstream_error' };
   return Response.json({ version: 1, error: {
-    code: codes[status] ?? 'internal_error',
+    code: (error instanceof BookingError && error.code) || (codes[status] ?? 'internal_error'),
     message: status === 500 ? 'Request failed. Please try again.' : error instanceof z.ZodError ? 'Invalid request parameters.' : (error as Error).message,
     ...(error instanceof z.ZodError ? { issues: error.issues.map(({ path, message }) => ({ path, message })) } : {}),
   } }, { status, headers: { ...headers, ...(status === 429 ? { 'Retry-After': String((error as ApiError).retryAfter ?? 60) } : {}),

package/src/lib/mobile/manage.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import type { Booking, BookingLink, CalEvent, Resource, Settings } from '../schema';
 import { ApiError, readJson } from '../api';
-import { bookingsEnabled, eventUrl, manageUrl } from '../calendar/config';
+import { bookingsEnabled, eventUrl } from '../calendar/config';
 import { eventTimeZone, locationLine } from '../calendar/events';
 import { resourceZone, linkLengths } from '../booking/availability';
-import { bookingIcs } from '../booking/emails';
+import { bookingIcs, bookingLanguage, bookingManagePath } from '../booking/emails';
+import { localePath } from '../i18n';
 import { guestCancel, guestChanges, guestMoveLink, guestReschedule } from '../booking/service';
 import { siteOrigin } from '../seo';
 import { waitUntilFrom } from '../webhooks';
@@ -59,9 +60,10 @@ function view(m: Managed, booking = m.booking) {
     location: event ? locationLine(event.location) : resource?.name ?? '',
     resource: resource ? { slug: resource.slug, name: resource.name } : null,
     link: link ? { slug: link.slug, name: link.name, mode: link.mode, lengths: linkLengths(link) } : null,
-    event: event ? { slug: event.slug, title: event.title, url: origin + eventUrl(event.slug) } : null,
+    // the web pages in the language it was booked in, as the emails link them
+    event: event ? { slug: event.slug, title: event.title, url: origin + localePath(eventUrl(event.slug), bookingLanguage(booking, settings).locale) } : null,
     // the web page for this booking (the same private link the emails carry)
-    manageUrl: origin + manageUrl(booking.manageToken),
+    manageUrl: origin + bookingManagePath(booking),
     can,
     // the RSVP form as it was when they sent it (like the web page), else the booking type's message
     confirmation: booking.formResponse?.definition.confirmation || link?.confirmMessage || null,
@@ -106,7 +108,7 @@ export async function managedIcs(c: PublicContext) {
   z.object({}).strict().parse(queryParams(c.url));
   const m = await managed(c);
   const v = view(m);
-  const body = bookingIcs(m.booking, v.title, v.location, v.manageUrl, new URL(m.origin).host, m.booking.status === 'cancelled' ? 'CANCEL' : 'REQUEST', { allDay: v.booking.allDay });
+  const body = bookingIcs(m.booking, v.title, v.location, v.manageUrl, new URL(m.origin).host, m.booking.status === 'cancelled' ? 'CANCEL' : 'REQUEST', { allDay: v.booking.allDay, lang: bookingLanguage(m.booking, m.settings).lang });
   return new Response(body, { headers: {
     'Content-Type': 'text/calendar; charset=utf-8', 'Content-Disposition': 'attachment; filename="booking.ics"',
     'Cache-Control': 'no-store', 'Access-Control-Allow-Origin': '*', 'X-Content-Type-Options': 'nosniff',

package/src/lib/mobile/openapi.ts

@@ -79,7 +79,7 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
   paths['/api/v1/bookings'] = {
     post: {
       summary: 'Create a guest booking or an RSVP, or replay an existing request; RSVPs require calendar, room bookings also bookings',
-      description: '20 attempts/minute/client address. JSON body up to 50,000 bytes. Responses use no-store. Reuse a random UUID v4 once per booking intent. Checkbox groups send a list of answers. An RSVP to an event with questions needs formVersion from GET /events/{slug}/rsvp; a changed form answers 409.',
+      description: '20 attempts/minute/client address. JSON body up to 50,000 bytes. Responses use no-store. Reuse a random UUID v4 once per booking intent. Checkbox groups send a list of answers. An RSVP to an event with questions needs formVersion from GET /events/{slug}/rsvp; a changed form answers 409. An RSVP from an email that already has one for that date answers 409 with code duplicate (and emails that RSVP’s link again); past the event’s RSVP deadline, 410.',
       parameters: [{ name: 'Idempotency-Key', in: 'header', required: true, schema: { type: 'string', format: 'uuid', pattern: '^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$' } }],
       requestBody: { required: true, content: media(jsonSchema(bookingInput)) },
       responses: { ...errors,

package/src/lib/mobile/rsvp.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import type { ContentRepository } from '../repo/types';
-import type { CalEvent } from '../schema';
+import type { CalEvent, Settings } from '../schema';
 import { ApiError } from '../api';
 import { answerFields } from '../forms/schema';
-import { eventIsPublic, expandEvents, type Occurrence } from '../calendar/events';
+import { eventIsPublic, expandEvents, rsvpDeadline, type Occurrence } from '../calendar/events';
 import { seatsTaken } from '../booking/service';
 import { localizeDoc } from '../translations';
 import { siteLang } from '../dates';
@@ -15,8 +15,8 @@ import { localeQuery, mobileLocale } from './locale';
 
 // RSVP status of one date of an event, for apps: whether it takes RSVPs now,
 // live seats and the questions with their version. The same rules as the
-// event's web page: open until the date ends, no deadline or waitlist.
-// Never cached; seats change with every RSVP. POST /bookings saves one.
+// event's web page: open until the event's deadline or the date ends, no
+// waitlist. Never cached; seats change with every RSVP. POST /bookings saves one.
 
 /** a public event (slug or id) and its occurrence starting exactly at `start` */
 export async function rsvpOccurrence(repo: ContentRepository, ref: string, start: string): Promise<Occurrence> {
@@ -31,11 +31,13 @@ export async function rsvpOccurrence(repo: ContentRepository, ref: string, start
 }
 /** the RSVP form when it asks something; apps must then send its version */
 export const rsvpQuestions = (e: CalEvent) => e.rsvp.form && answerFields(e.rsvp.form).length ? e.rsvp.form : null;
-/** why this date takes no RSVPs (seats aside), or null */
-export function rsvpClosed(o: Occurrence, now = Date.now()) {
+/** why this date takes no RSVPs (seats aside), or null: closed = past the event's deadline */
+export function rsvpClosed(o: Occurrence, settings: Pick<Settings, 'timezone'>, now = Date.now()) {
   if (!o.event.rsvp.enabled) return 'disabled' as const;
   if (o.cancelled) return 'cancelled' as const;
   if (o.end <= now) return 'ended' as const;
+  const deadline = rsvpDeadline(o, settings);
+  if (deadline !== null && deadline <= now) return 'closed' as const;
   return null;
 }
 
@@ -48,24 +50,28 @@ export async function getRsvpStatus(repo: ContentRepository, url: URL, slug: str
   const q = rsvpQuery.parse(queryParams(url));
   const locale = mobileLocale(q.locale);
   const o = await rsvpOccurrence(repo, slug, q.start);
+  const settings = await repo.getSettings();
   const { rsvp } = o.event;
   // pending and confirmed RSVPs hold seats, as in the capacity check
   const going = rsvp.enabled ? await seatsTaken(repo, o.event.id, o.start) : 0;
   const left = rsvp.capacity ? Math.max(0, rsvp.capacity - going) : null;
-  const closed = rsvpClosed(o);
+  const closed = rsvpClosed(o, settings);
+  const deadline = rsvp.enabled ? rsvpDeadline(o, settings) : null;
   const reason = closed ?? (left === 0 ? 'full' as const : null);
   const form = rsvpQuestions(o.event);
   const title = localizeDoc(o.event, locale ?? undefined).title;
   // the built-in button speaks the app's language (the site's own without languages set up)
   let submitLabel = form?.submitLabel ?? '';
   if (form && !submitLabel) {
-    const words = rsvpStrings(locale ?? siteLang(await repo.getSettings()));
+    const words = rsvpStrings(locale ?? siteLang(settings));
     submitLabel = rsvp.autoConfirm ? words.confirmSeat : words.requestSeat;
   }
   return {
     event: { id: o.event.id, slug: o.event.slug, title },
     start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(),
     open: !reason, reason, going, left, capacity: rsvp.capacity,
+    // when RSVPs to this date close, if before it ends
+    closesAt: deadline === null ? null : new Date(deadline).toISOString(),
     // seats one RSVP may take right now
     maxSeats: Math.min(rsvp.maxSeats || 1, left ?? Infinity), autoConfirm: rsvp.autoConfirm,
     form: form ? { ...await formJson(form), submitLabel } : null,

package/src/lib/mobile/schemas.ts

@@ -32,6 +32,8 @@ export const Event = CalEvent.pick({
   allDay: true, timezone: true, rrule: true, exdates: true, cancelledDates: true, location: true, cta: true, tags: true, fields: true,
 }).extend({ rsvp: CalEvent.shape.rsvp.optional(), url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
   calendars: z.array(z.object({ id: str, slug: str, name: str, color: str })),
+  // push topics told about date, time or place changes (Admin → Mobile app → When an event changes); [] = none
+  notify: z.object({ changes: strings }),
 });
 export const Events = z.object({ locale, timezone: str, from: date, to: date, pagination: Pagination,
   occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, event: Event })),
@@ -70,8 +72,10 @@ export const Form = z.object({
 export const FormReceipt = z.object({ received: z.literal(true), confirmation: str });
 export const RsvpStatus = z.object({
   event: z.object({ id: str, slug: str, title: str }), start: date, end: date,
-  open: bool, reason: z.enum(['disabled', 'ended', 'cancelled', 'full']).nullable(),
+  open: bool, reason: z.enum(['disabled', 'ended', 'closed', 'cancelled', 'full']).nullable(),
   going: z.number().int(), left: z.number().int().nullable(), capacity: z.number().int(), maxSeats: z.number().int(), autoConfirm: bool,
+  // the event's RSVP deadline for this date (null: open until it ends)
+  closesAt: date.nullable(),
   form: Form.omit({ id: true }).nullable(),
 });
 const GuestChanges = z.object({ cancel: bool, reschedule: bool, cutoffHours: z.number().int(), closed: bool });
@@ -133,6 +137,7 @@ export const LiveStatus = z.object({
   display: z.object({ style: z.enum(['poster', 'split', 'row']), bar: bool, header: bool, dock: bool }),
 });
 export const Error = z.object({ version: z.literal(1), error: z.object({
-  code: z.enum(['invalid_request', 'unauthorized', 'forbidden', 'not_found', 'method_not_allowed', 'conflict', 'gone', 'payload_too_large', 'unsupported_media_type', 'rate_limited', 'upstream_error', 'internal_error']),
+  // duplicate (409): that email already has an RSVP for the date
+  code: z.enum(['invalid_request', 'unauthorized', 'forbidden', 'not_found', 'method_not_allowed', 'conflict', 'duplicate', 'gone', 'payload_too_large', 'unsupported_media_type', 'rate_limited', 'upstream_error', 'internal_error']),
   message: str, issues: z.array(z.object({ path: z.array(z.union([str, z.number()])), message: str })).optional(),
 }) });

package/src/lib/mobile/search.ts

@@ -87,7 +87,7 @@ export async function search(repo: ContentRepository, url: URL) {
         snippet: plainSnippet(snippet),
         // the next occurrence, or the latest one when the event is over
         occurrence: o ? { start: iso(o.start), end: iso(o.end), allDay: o.allDay, cancelled: o.cancelled } : null,
-        event: publicEventDto(e, origin, listed, settings.timezone, locale),
+        event: publicEventDto(e, origin, listed, settings, locale),
       };
     }),
     more: { posts: posts.length > q.limit, pages: pages.length > q.limit, events: events.length > q.limit },

package/src/lib/mobile/site.ts

@@ -13,6 +13,7 @@ import { queryParams } from './http';
 import { localeOnlyQuery, localizedUrl, mobileLocale } from './locale';
 import { guestSignInReady } from './guest';
 import { LEGAL } from '../legal/config';
+import { siteStrings } from '../site-words';
 
 export async function getSite(repo: ContentRepository, url: URL, _id = '', locals?: unknown) {
   // locale: the legal links point at that language's pages (/es/privacy)
@@ -23,16 +24,19 @@ export async function getSite(repo: ContentRepository, url: URL, _id = '', local
   const origin = siteOrigin(settings, url);
   const bases = new Set(Object.values(CONTENT.collections).map(c => c.base));
   const header = nav.filter(n => n.area === 'header').sort((a, b) => a.order - b.order);
+  // the same list the website's header shows in that language: the owner's
+  // menu as written, or the automatic one with its words translated
+  const words = siteStrings(locale || settings.locale || 'en');
   const menu = header.length ? header : [
-    { label: 'Home', url: '/' },
+    { label: words.home, url: '/' },
     ...pages.filter(p => p.status === 'published' && !p.isHome).map(p => ({ label: p.title, url: `/${p.slug}` })),
     ...Object.values(CONTENT.collections).map(c => ({ label: c.plural, url: c.base })),
-    { label: 'Links', url: '/links' },
+    { label: words.links, url: '/links' },
   ];
   return {
     name: settings.siteTitle, description: settings.tagline,
     logo: safeUrl(settings.siteLogo, origin), logoDark: safeUrl(settings.siteLogoDark, origin), icon: safeUrl(settings.siteFavicon, origin),
-    menu: menu.map(n => ({ label: n.label, href: safeUrl(n.url, origin, true) })),
+    menu: menu.map(n => ({ label: n.label, href: localizedUrl(safeUrl(n.url, origin, true), origin, locale) })),
     languages: { default: I18N.defaultLocale || null, locales: I18N.locales.map(code => ({ code, name: localeName(code, true) })) },
     features: {
       // redirectFrom: old addresses the website 301s to url, so apps can follow them too,

package/src/lib/push/api.ts

@@ -12,7 +12,7 @@ import { localeOnlyQuery, mobileLocale } from '../mobile/locale';
 import { EXPO_PUSH_BASE, PUSH, requirePush } from './config';
 import { expoOptions } from './expo';
 import { knownTopics, pushTopics, sendNotification, siteOriginOf, type PushRunOptions } from './service';
-import { PushAuto, type PushDevice } from './types';
+import { MAX_CHANGE_RULES, PushAuto, type PushDevice } from './types';
 
 export const pushToken = z.string().max(250).regex(/^Expo(?:nent)?PushToken\[[A-Za-z0-9_-]{8,200}\]$/, 'Use an Expo push token such as ExponentPushToken[…].');
 const topicList = z.array(z.string().min(1).max(200).regex(/^[a-z0-9][a-z0-9:_-]*$/i, 'Use topic ids from GET /api/v1/push/topics.')).max(50);
@@ -155,20 +155,19 @@ export async function adminPushAction(repo: ContentRepository, input: z.infer<ty
       const collections = new Set(Object.keys(CONTENT.collections));
       const calendars = new Set((CALENDAR.enabled ? await repo.listCalendars() : []).filter((c) => c.visibility === 'public').map((c) => c.id));
       const cals = (ids: string[]) => [...new Set(ids)].filter((id) => id === '*' || calendars.has(id));
-      const changes = input.auto.eventChanges;
-      const tags = changes?.tags ?? [];
       const known = await knownTopics(repo);
       const auto = {
         newPost: { collections: [...new Set(input.auto.newPost.collections)].filter((k) => collections.has(k)) },
         newEvent: { calendars: CALENDAR.enabled ? cals(input.auto.newEvent.calendars) : [] },
         startingSoon: { calendars: CALENDAR.enabled ? cals(input.auto.startingSoon.calendars) : [], minutes: input.auto.startingSoon.minutes },
         live: { enabled: input.auto.live?.enabled === true },
-        eventChanges: CALENDAR.enabled ? {
-          calendars: cals(changes?.calendars ?? []),
+        // a rule left without calendars is off: dropped
+        eventChanges: CALENDAR.enabled ? (input.auto.eventChanges ?? []).map((r) => ({
+          calendars: cals(r.calendars),
           // one of each tag, whatever its case (matching ignores case too)
-          tags: tags.filter((t, i) => tags.findIndex((x) => x.toLowerCase() === t.toLowerCase()) === i),
-          topics: [...new Set(changes?.topics ?? [])].filter((t) => known.has(t)),
-        } : { calendars: [], tags: [], topics: [] },
+          tags: r.tags.filter((t, i) => r.tags.findIndex((x) => x.toLowerCase() === t.toLowerCase()) === i),
+          topics: [...new Set(r.topics)].filter((t) => known.has(t)),
+        })).filter((r) => r.calendars.length).slice(0, MAX_CHANGE_RULES) : [],
       };
       await repo.updateSettings({ push: { auto } });
       return { auto };