@acms-subir/core 0.3.38 → 0.3.40

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

@@ -6,7 +6,7 @@
 // {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 type GuestMail = 'received' | 'confirmed' | 'declined' | 'cancelled' | 'updated' | 'rescheduled' | 'reminder' | 'link';
 export interface MailCopy { subject: string; heading: string; intro: string }
 
 export interface BookingStrings {
@@ -25,6 +25,22 @@ export interface BookingStrings {
   /** a pending booking nobody answered in time, declined automatically */
   lateDecline: string;
   staff: { pending: string; booked: string; review: string; open: string; pendingSubject: string; bookedSubject: string };
+  /**
+   * the hosts' email about an RSVP (or the contact address's, for an event
+   * without hosts): a new one, or one the person cancelled. {seats}, {count}
+   * and {capacity} are numbers, {date} the date's short form ("Fri Nov 7");
+   * the footer is `via` · `hosts` or `noHosts`.
+   */
+  rsvpStaff: {
+    subject: string; cancelledSubject: string; heading: string; cancelledHeading: string;
+    name: string; email: string; phone: string; answers: string; now: string;
+    confirmed: string; pending: string; seatFreed: string; seatsFreed: string;
+    seatTaken: string; seatsTaken: string; seatsTakenOf: string;
+    via: Record<'web' | 'app' | 'staff', string>;
+    hosts: string; noHosts: string;
+    /** the button for a host without Manage bookings: their My events page */
+    openMine: string;
+  };
   /** a room booking's own page: what differs from an RSVP's (rsvp-words.ts) */
   page: {
     untitled: string;
@@ -54,11 +70,20 @@ const STRINGS: Record<string, BookingStrings> = {
       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}' },
+    rsvpStaff: {
+      subject: 'New RSVP: {title}, {date}', cancelledSubject: 'RSVP cancelled: {title}, {date}', heading: 'New RSVP for {title}', cancelledHeading: 'RSVP cancelled for {title}',
+      name: 'Name', email: 'Email', phone: 'Phone', answers: 'Answers', now: 'Now',
+      confirmed: '{seats} · Confirmed', pending: '{seats} · Waiting for your approval', seatFreed: '{seats} freed', seatsFreed: '{seats} freed',
+      seatTaken: '{count} seat taken', seatsTaken: '{count} seats taken', seatsTakenOf: '{count} of {capacity} seats taken',
+      via: { web: 'Sent from the website', app: 'Sent from the app', staff: 'Added by staff' }, openMine: 'Open in My events',
+      hosts: 'You get these because you host this event.', noHosts: 'You get these because no one hosts this event.',
+    },
     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.',
@@ -77,6 +102,7 @@ const STRINGS: Record<string, BookingStrings> = {
       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: {
@@ -86,10 +112,19 @@ const STRINGS: Record<string, BookingStrings> = {
       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}' },
+    rsvpStaff: {
+      subject: 'Nueva confirmación: {title}, {date}', cancelledSubject: 'Confirmación cancelada: {title}, {date}', heading: 'Nueva confirmación para {title}', cancelledHeading: 'Confirmación cancelada para {title}',
+      name: 'Nombre', email: 'Correo', phone: 'Teléfono', answers: 'Respuestas', now: 'Ahora',
+      confirmed: '{seats} · Confirmado', pending: '{seats} · Esperando su aprobación', seatFreed: '{seats} liberado', seatsFreed: '{seats} liberados',
+      seatTaken: '{count} lugar ocupado', seatsTaken: '{count} lugares ocupados', seatsTakenOf: '{count} de {capacity} lugares ocupados',
+      via: { web: 'Enviado desde el sitio web', app: 'Enviado desde la app', staff: 'Agregado por el equipo' }, openMine: 'Abrir en Mis eventos',
+      hosts: 'Recibe estos correos porque usted organiza este evento.', noHosts: 'Recibe estos correos porque este evento no tiene organizadores.',
+    },
     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ó.',
@@ -108,6 +143,7 @@ const STRINGS: Record<string, BookingStrings> = {
       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: {
@@ -117,10 +153,19 @@ const STRINGS: Record<string, BookingStrings> = {
       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}' },
+    rsvpStaff: {
+      subject: 'Nouvelle inscription : {title}, {date}', cancelledSubject: 'Inscription annulée : {title}, {date}', heading: 'Nouvelle inscription à {title}', cancelledHeading: 'Inscription à {title} annulée',
+      name: 'Nom', email: 'E-mail', phone: 'Téléphone', answers: 'Réponses', now: 'Maintenant',
+      confirmed: '{seats} · Confirmée', pending: '{seats} · En attente de votre validation', seatFreed: '{seats} libérée', seatsFreed: '{seats} libérées',
+      seatTaken: '{count} place prise', seatsTaken: '{count} places prises', seatsTakenOf: '{count} sur {capacity} places prises',
+      via: { web: 'Envoyée depuis le site', app: 'Envoyée depuis l’app', staff: 'Ajoutée par l’équipe' }, openMine: 'Ouvrir dans Mes événements',
+      hosts: 'Vous recevez ces e-mails parce que vous organisez cet événement.', noHosts: 'Vous recevez ces e-mails parce que cet événement n’a pas d’organisateur.',
+    },
     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.',
@@ -139,6 +184,7 @@ const STRINGS: Record<string, BookingStrings> = {
       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: {
@@ -148,10 +194,19 @@ const STRINGS: Record<string, BookingStrings> = {
       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}' },
+    rsvpStaff: {
+      subject: 'Neue Anmeldung: {title}, {date}', cancelledSubject: 'Anmeldung storniert: {title}, {date}', heading: 'Neue Anmeldung für {title}', cancelledHeading: 'Anmeldung für {title} storniert',
+      name: 'Name', email: 'E-Mail', phone: 'Telefon', answers: 'Antworten', now: 'Jetzt',
+      confirmed: '{seats} · Bestätigt', pending: '{seats} · Wartet auf Ihre Freigabe', seatFreed: '{seats} frei geworden', seatsFreed: '{seats} frei geworden',
+      seatTaken: '{count} Platz belegt', seatsTaken: '{count} Plätze belegt', seatsTakenOf: '{count} von {capacity} Plätzen belegt',
+      via: { web: 'Über die Website gesendet', app: 'Über die App gesendet', staff: 'Vom Team eingetragen' }, openMine: 'In Meine Veranstaltungen öffnen',
+      hosts: 'Sie erhalten diese E-Mails, weil Sie diese Veranstaltung betreuen.', noHosts: 'Sie erhalten diese E-Mails, weil niemand diese Veranstaltung betreut.',
+    },
     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.',
@@ -170,6 +225,7 @@ const STRINGS: Record<string, BookingStrings> = {
       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: {
@@ -179,10 +235,19 @@ const STRINGS: Record<string, BookingStrings> = {
       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}' },
+    rsvpStaff: {
+      subject: 'Nova inscrição: {title}, {date}', cancelledSubject: 'Inscrição cancelada: {title}, {date}', heading: 'Nova inscrição em {title}', cancelledHeading: 'Inscrição cancelada em {title}',
+      name: 'Nome', email: 'E-mail', phone: 'Telefone', answers: 'Respostas', now: 'Agora',
+      confirmed: '{seats} · Confirmada', pending: '{seats} · Aguardando sua aprovação', seatFreed: '{seats} liberada', seatsFreed: '{seats} liberadas',
+      seatTaken: '{count} vaga ocupada', seatsTaken: '{count} vagas ocupadas', seatsTakenOf: '{count} de {capacity} vagas ocupadas',
+      via: { web: 'Enviada pelo site', app: 'Enviada pelo app', staff: 'Adicionada pela equipe' }, openMine: 'Abrir em Meus eventos',
+      hosts: 'Você recebe estes e-mails porque organiza este evento.', noHosts: 'Você recebe estes e-mails porque este evento não tem organizadores.',
+    },
     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.',

package/src/lib/email/service.ts

@@ -22,7 +22,7 @@ async function render(repo: ContentRepository, job: EmailJob, locals?: unknown,
     const b = await repo.getBooking(payload.bookingId);
     if (!b || (b.notificationVersion ?? 0) !== payload.version) return null;
     if (payload.kind === 'reminder' && (b.status !== 'confirmed' || b.start <= Date.now())) return null;
-    const mail = await bookingMail(repo, b, payload.kind, origin, from, payload);
+    const mail = await bookingMail(repo, b, payload.kind, origin, from, payload, job.recipient);
     return { ...mail, to: job.recipient };
   }
   if (job.kind === 'auth') {

package/src/lib/email/store.ts

@@ -1,5 +1,5 @@
 import type { SqlDriver, SqlStatement } from '../repo/sql';
-import type { ConfigRecord, EmailConfig, EmailJob, Invitation, NewEmailJob, SendResult } from './types';
+import type { ConfigRecord, EmailConfig, EmailJob, Invitation, NewEmailJob, RsvpStaffNotice, SendResult } from './types';
 const record = (r: Record<string, unknown>): ConfigRecord => ({ version: Number(r.version), config: JSON.parse(String(r.config)), encrypted: String(r.encrypted), createdAt: Number(r.created_at) });
 function job(r: Record<string, unknown>): EmailJob {
   return { id: String(r.id), dedupe: String(r.dedupe), kind: String(r.kind), recipient: String(r.recipient), payload: String(r.payload), configVersion: Number(r.config_version), state: r.state as EmailJob['state'], attempts: Number(r.attempts), nextAt: Number(r.next_at), expiresAt: r.expires_at == null ? null : Number(r.expires_at), createdAt: Number(r.created_at), lease: String(r.lease), leaseUntil: r.lease_until == null ? null : Number(r.lease_until), provider: String(r.provider), providerId: String(r.provider_id), error: String(r.error), acceptedAt: r.accepted_at == null ? null : Number(r.accepted_at), updatedAt: Number(r.updated_at), fingerprint: String(r.fingerprint), rendered: String(r.rendered || '') };
@@ -25,6 +25,22 @@ export function bookingJobs(id: string, kind: string, version?: number, staff =
   });
   return [select('b.email', 'bookings b', kind), ...(staff ? [select('j.value', 'bookings b JOIN resources r ON r.id = b.resource_id, json_each(r.notify_emails) j', 'staff-new')] : [])];
 }
+// Staff hear about an RSVP (new, or cancelled by the person) at the addresses
+// the caller picked, in the same batch and only if the change landed.
+// `taken` is the date's seat count right after it.
+export function rsvpStaffJobs(id: string, kind: 'staff-rsvp' | 'staff-rsvp-cancelled', notice: RsvpStaffNotice | undefined, version: number, mutation = ''): SqlStatement[] {
+  if (!notice?.to.length) return [];
+  const now = Date.now();
+  return [{
+    sql: `INSERT OR IGNORE INTO email_jobs (id,dedupe,kind,recipient,payload,config_version,next_at,expires_at,created_at,updated_at)
+      SELECT lower(hex(randomblob(16))), b.id || ':' || b.notification_version || ':' || ? || ':' || lower(j.value), 'booking', lower(j.value),
+      json_object('bookingId',b.id,'version',b.notification_version,'kind',?,'why',?,'via',?,
+        'taken',(SELECT COALESCE(SUM(seats),0) FROM bookings WHERE kind='rsvp' AND event_id=b.event_id AND start_at=b.start_at AND status IN ('pending','confirmed'))),
+      COALESCE((SELECT MAX(version) FROM email_configs),0), ?, NULL, ?, ?
+      FROM bookings b, json_each(?) j WHERE b.id = ? AND b.kind = 'rsvp' AND j.value != '' AND b.notification_version = ? ${mutation ? 'AND b.email_mutation = ?' : ''}`,
+    args: [kind, kind, notice.why, notice.via, now, now, now, JSON.stringify(notice.to), id, version, ...(mutation ? [mutation] : [])],
+  }];
+}
 export class EmailStore {
   constructor(private getDriver: () => Promise<SqlDriver>) {}
   async config(version?: number): Promise<ConfigRecord | null> {

package/src/lib/email/types.ts

@@ -1,4 +1,4 @@
-import type { Role } from '../schema';
+import type { Booking, Role } from '../schema';
 export type Provider = 'resend' | 'mailgun' | 'ses' | 'cloudflare';
 export type ProviderChoice = Provider | 'auto' | 'none';
 export interface Attachment { filename: string; type: string; content: string }
@@ -19,6 +19,8 @@ export interface EmailJob {
   acceptedAt: number | null; updatedAt: number; fingerprint: string;
   rendered: string;
 }
+/** staff to tell about an RSVP (booking/service.ts rsvpStaff): to its hosts, else the contact address; via: where the person did it */
+export interface RsvpStaffNotice { to: string[]; why: 'hosts' | 'contact'; via: Booking['source'] }
 export interface NewEmailJob { id?: string; dedupe: string; kind: string; recipient: string; payload: string; configVersion: number; nextAt?: number; expiresAt?: number }
 export type SendResult = { state: 'accepted'; providerId: string } | { state: 'retrying' | 'failed' | 'unknown'; error: string; retryAfter?: number };
 export interface Invitation { id: string; email: string; name: string; role: Role; state: string; expiresAt: number; createdAt: number; invitedBy: string }

package/src/lib/legal/text-en.ts

@@ -42,7 +42,7 @@ export function privacyEn(f: LegalFacts, country: string): PolicySection[] {
     ] },
   ];
   if (f.calendar) s.push({ id: 'bookings', title: f.bookings ? 'Bookings and RSVPs' : 'Event RSVPs', text: [
-    `When you ${f.bookings ? 'book a time or ' : ''}RSVP to an event, we store your name, email address, any phone number and answers you give, the date and time, the number of seats and the status. We use them to manage your request, prevent duplicate submissions, and email you confirmations, changes and a reminder. Staff who manage the calendar can see them${f.bookings ? ', and the people a room or service notifies receive new bookings by email' : ''}.`,
+    `When you ${f.bookings ? 'book a time or ' : ''}RSVP to an event, we store your name, email address, any phone number and answers you give, the date and time, the number of seats and the status. We use them to manage your request, prevent duplicate submissions, and email you confirmations, changes and a reminder. Staff who manage the calendar can see them${f.bookings ? ', and the people a room or service notifies receive new bookings by email' : ''}. When you RSVP or cancel an RSVP, the event’s hosts (or our staff) get an email with your RSVP details.`,
     'Each booking has a private link to see, change or cancel it. Keep it private: anyone with the link can use it.',
   ] });
   s.push({ id: 'forms', title: 'Forms', text: [

package/src/lib/legal/text-es.ts

@@ -43,7 +43,7 @@ export function privacyEs(f: LegalFacts, country: string): PolicySection[] {
     ] },
   ];
   if (f.calendar) s.push({ id: 'bookings', title: f.bookings ? 'Reservaciones y registros' : 'Registros a eventos', text: [
-    `Cuando ${f.bookings ? 'reserva un horario o ' : ''}se registra a un evento, guardamos su nombre, su correo electrónico, el teléfono y las respuestas que nos dé, la fecha y hora, el número de lugares y el estado. Los usamos para gestionar su solicitud, evitar envíos duplicados y enviarle por correo confirmaciones, cambios y un recordatorio. El personal que administra el calendario puede verlos${f.bookings ? ', y las personas a las que avisa una sala o un servicio reciben las reservaciones nuevas por correo' : ''}.`,
+    `Cuando ${f.bookings ? 'reserva un horario o ' : ''}se registra a un evento, guardamos su nombre, su correo electrónico, el teléfono y las respuestas que nos dé, la fecha y hora, el número de lugares y el estado. Los usamos para gestionar su solicitud, evitar envíos duplicados y enviarle por correo confirmaciones, cambios y un recordatorio. El personal que administra el calendario puede verlos${f.bookings ? ', y las personas a las que avisa una sala o un servicio reciben las reservaciones nuevas por correo' : ''}. Cuando se registra a un evento o cancela su registro, los organizadores del evento (o nuestro personal) reciben un correo con los datos de su registro.`,
     'Cada reservación tiene un enlace privado para verla, cambiarla o cancelarla. Manténgalo en privado: cualquiera que lo tenga puede usarlo.',
   ] });
   s.push({ id: 'forms', title: 'Formularios', text: [

package/src/lib/mobile/bookings.ts

@@ -66,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

@@ -4,7 +4,7 @@ import { publicTags, tagFilter, type BookingLink, type CalEvent, type Calendar,
 import { ApiError } from '../api';
 import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl, publicEventFields } from '../calendar/config';
 import { calendarToJson, eventToJson } from '../calendar/api';
-import { eventIsListed, eventIsPublic, expandEvents } from '../calendar/events';
+import { eventIsListed, eventIsPublic, expandEvents, featuredOccurrence } from '../calendar/events';
 import { availabilityContext } from '../booking/service';
 import { addDaysYmd, describeLink, linkLengths, localMidnight, slotsForDay, ymd } from '../booking/availability';
 import { siteOrigin } from '../seo';
@@ -65,6 +65,28 @@ export async function listEvents(repo: ContentRepository, url: URL) {
     pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
   };
 }
+// one event by slug (or id), whatever its date: apps open it from a link, a
+// push or an announcement, often weeks ahead. `on` ('YYYY-MM-DD', like the
+// website's ?on=) picks that day's occurrence; otherwise the next one, or the
+// most recent when it's over.
+export const eventDetailQuery = z.object({ locale: localeQuery, on: isoDay.optional() }).strict();
+export async function getEventDetail(repo: ContentRepository, url: URL, ref: string) {
+  requireCalendar();
+  const q = eventDetailQuery.parse(queryParams(url));
+  const locale = mobileLocale(q.locale);
+  const [settings, calendars] = await Promise.all([repo.getSettings(), repo.listCalendars()]);
+  const found = ref && ref.length <= 200 ? await repo.getEventBySlug(ref) ?? await repo.getEvent(ref) : null;
+  const all = new Map(calendars.map(c => [c.id, c]));
+  if (!found || !eventIsPublic(found, all)) throw new ApiError(404, 'Event not found.');
+  const e = localizeDoc(found, locale ?? undefined);
+  const o = featuredOccurrence(e, settings, Date.now(), q.on);
+  const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public').map(c => [c.id, c]));
+  return {
+    locale,
+    occurrence: o ? { id: `${e.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay, cancelled: o.cancelled } : null,
+    event: publicEventDto(e, siteOrigin(settings, url), publicCalendars, settings, locale),
+  };
+}
 // e is already localized; publicCalendars limits which calendars are named
 export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, settings: Settings, locale: string | null) {
   const event = eventToJson(e, origin, publicCalendars, settings.timezone);

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

@@ -75,7 +75,7 @@ export const getManaged = async (c: PublicContext) => view(await managed(c));
 
 export async function cancelManaged(c: PublicContext) {
   const m = await managed(c);
-  return view(m, await guestCancel(c.repo, m.booking, flow(m, c)));
+  return view(m, await guestCancel(c.repo, m.booking, flow(m, c), 'app'));
 }
 
 export const manageAvailabilityQuery = z.object({

package/src/lib/mobile/openapi.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import type { ContentRepository } from '../repo/types';
 import { contentQuery, contentDetailQuery } from './content';
-import { eventsQuery, availabilityQuery } from './calendar';
+import { eventsQuery, eventDetailQuery, availabilityQuery } from './calendar';
 import { bookingInput } from './bookings';
 import { rsvpQuery } from './rsvp';
 import { pagesQuery } from './pages';
@@ -51,6 +51,7 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
     ['/content/{id}', 'Published content detail', contentDetailQuery, ref('Content')],
     ['/search', 'Ranked matches across posts, pages and events (top limit per group); requires search', searchQuery, ref('SearchResults')],
     ['/events', 'Public event occurrences; requires calendar', eventsQuery, ref('Events')],
+    ['/events/{slug}', 'One public event by slug or id, whatever its date, with its next occurrence (or the one on `on`, YYYY-MM-DD; the most recent once it is over); requires calendar', eventDetailQuery, ref('EventDetail')],
     ['/calendars', 'Public calendars; requires calendar', empty, ref('Calendars')],
     ['/events/{slug}/rsvp', 'RSVP status of one date (start = the occurrence start exactly): open or why not, live seats, the questions and their version; never cached; requires calendar', rsvpQuery, ref('RsvpStatus'), false],
     ['/resources', 'Public resources and booking links; requires bookings', z.object(pageQuery).strict(), ref('Resources')],
@@ -79,7 +80,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

@@ -30,7 +30,7 @@ export const Page = ContentSummary.extend({
 export const Event = CalEvent.pick({
   id: true, slug: true, title: true, excerpt: true, status: true, cancelled: true, featured: true, start: true, end: true,
   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,
+}).extend({ rsvp: CalEvent.shape.rsvp.removeDefault().omit({ notifyStaff: true }).default({}).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 }),
@@ -40,6 +40,7 @@ export const Events = z.object({ locale, timezone: str, from: date, to: date, pa
 });
 const Snippet = z.object({ text: str, highlights: z.array(z.object({ start: z.number().int(), end: z.number().int() })) });
 const ContentHit = ContentSummary.extend({ snippet: Snippet });
+export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool }).nullable(), event: Event });
 export const SearchResults = z.object({ locale, query: str,
   posts: z.array(ContentHit), pages: z.array(ContentHit),
   events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool }).nullable(), event: Event })),
@@ -72,8 +73,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 });
@@ -135,6 +138,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/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 };

package/src/lib/push/service.ts

@@ -15,7 +15,7 @@ import { ANNOUNCEMENTS } from '../announcements/config';
 import type { LiveSnapshot } from '../live/types';
 import { PUSH } from './config';
 import { expoOptions, fetchReceipts, isGone, sendMessages, type ExpoMessage, type ExpoOptions } from './expo';
-import { EventSnapshot, type PushAuto, type PushNotification, type PushSource, type PushTopic } from './types';
+import { EventSnapshot, type ChangeRule, type PushNotification, type PushSource, type PushTopic } from './types';
 
 const MINUTE = 60_000, HOUR = 60 * MINUTE, DAY = 24 * HOUR;
 /** automatic notices queued longer ago than this are skipped, never sent late */
@@ -57,9 +57,9 @@ export async function pushTopics(repo: ContentRepository, locale?: string | null
   const out: PushTopic[] = [{ id: 'news', label: w.news, kind: 'general' }];
   if (collections.length > 1) out.push(...collections.map(([key, c]): PushTopic => ({ id: `collection:${key}`, label: c.plural, kind: 'collection' })));
   if (CALENDAR.enabled) {
-    const changes = settings.push.auto.eventChanges;
-    // event-change notices go to `events` unless their rule names other topics
-    out.push({ id: 'events', label: changes.calendars.length && !changes.topics.length ? w.eventsChanges : w.events, kind: 'general' });
+    // event-change notices go to `events` from a rule that names no other topics
+    const toEvents = settings.push.auto.eventChanges.some((r) => r.calendars.length && !r.topics.length);
+    out.push({ id: 'events', label: toEvents ? w.eventsChanges : w.events, kind: 'general' });
     const calendars = (await repo.listCalendars()).filter((c) => c.visibility === 'public');
     if (calendars.length > 1) out.push(...calendars.map((c): PushTopic => ({ id: `calendar:${c.slug}`, label: c.name, kind: 'calendar' })));
   }
@@ -224,20 +224,24 @@ export async function sendNotification(repo: ContentRepository, input: SendInput
 
 const listedCalendars = (calendars: Calendar[]) => new Map(calendars.map((c) => [c.id, c]));
 const inRule = (rule: string[], e: CalEvent) => rule.includes('*') || e.calendarIds.some((id) => rule.includes(id));
-// the change rule: its calendars, and one of its tags when it lists some (any case)
-function inChangeRule(rule: PushAuto['eventChanges'], e: CalEvent) {
+// a change rule: its calendars, and one of its tags when it lists some (any case)
+function inChangeRule(rule: ChangeRule, e: CalEvent) {
   const tags = new Set(rule.tags.map((t) => t.toLowerCase()));
   return inRule(rule.calendars, e) && (!tags.size || e.tags.some((t) => tags.has(t.toLowerCase())));
 }
+// every rule that covers the event adds its topics, or the event's own when it
+// names none: in rule order, once each ([] = no rule covers it)
+function changeAudience(rules: ChangeRule[], e: CalEvent, calendars: Map<string, Calendar>) {
+  return [...new Set(rules.filter((r) => inChangeRule(r, e)).flatMap((r) => (r.topics.length ? r.topics : eventTopics(e, calendars))))];
+}
 /**
  * The topics this event's change notices go to (Admin → Mobile app → When an
- * event changes), or [] while that rule doesn't cover it. Apps show it to
- * promise "we'll let you know if it changes" only when it's true.
+ * event changes), or [] while no rule covers it. Apps show it to promise
+ * "we'll let you know if it changes" only when it's true.
  */
 export function changeTopics(e: CalEvent, settings: Settings, calendars: Map<string, Calendar>): string[] {
-  const rule = settings.push.auto.eventChanges;
-  if (!PUSH.enabled || !CALENDAR.enabled || !inChangeRule(rule, e)) return [];
-  return rule.topics.length ? [...rule.topics] : eventTopics(e, calendars);
+  if (!PUSH.enabled || !CALENDAR.enabled) return [];
+  return changeAudience(settings.push.auto.eventChanges, e, calendars);
 }
 function eventTopics(e: CalEvent, calendars: Map<string, Calendar>) {
   return ['events', ...e.calendarIds.map((id) => calendars.get(id)).filter((c): c is Calendar => c?.visibility === 'public').map((c) => `calendar:${c.slug}`)];
@@ -355,7 +359,7 @@ export async function queueEventChange(repo: ContentRepository, before: CalEvent
   const was = eventSnapshot(before);
   if (JSON.stringify(was) === JSON.stringify(eventSnapshot(after))) return false;
   const [settings, all] = await Promise.all([repo.getSettings(), repo.listCalendars()]);
-  if (!inChangeRule(settings.push.auto.eventChanges, after) || !eventIsListed(after, listedCalendars(all))) return false;
+  if (!settings.push.auto.eventChanges.some((r) => inChangeRule(r, after)) || !eventIsListed(after, listedCalendars(all))) return false;
   const key = `change:${after.id}`;
   // a change to a date that starts soon waits only a minute (judged from what people last knew)
   const row = await repo.push.queuedChange(key);
@@ -381,7 +385,7 @@ async function announcedLately(repo: ContentRepository, e: CalEvent, origin: str
   return (await repo.announcements.pushedSince(now - HOUR)).some((a) => a.link !== '' && sitePath(a.link, origin) === page);
 }
 
-/** `topics`: the rule's own audience; [] = the event's topics. */
+/** `topics`: the audience of the rules that cover it (changeTopics); [] = the event's topics. */
 export function eventChangeNotice(e: CalEvent, change: EventChange, settings: Settings, calendars: Map<string, Calendar>, topics: string[] = []): SendInput {
   const tz = eventTimeZone(e, settings);
   const siteTz = settings.timezone || 'UTC';
@@ -448,9 +452,10 @@ export async function processPushQueue(repo: ContentRepository, opts: PushRunOpt
         // compared at send time: edits that cancel out, or come too late, send nothing
         const e = await repo.getEvent(row.docId);
         const was = readSnapshot(row.payload);
-        const rule = auto.eventChanges;
-        const change = e && was && eventIsListed(e, calendars) && inChangeRule(rule, e) ? eventChange(was, e, settings, now) : null;
-        if (e && change && !(await announcedLately(repo, e, run.origin, now))) notice = eventChangeNotice(e, change, settings, calendars, rule.topics);
+        // one notice, to everyone the rules that cover it send to
+        const topics = e ? changeAudience(auto.eventChanges, e, calendars) : [];
+        const change = e && was && topics.length && eventIsListed(e, calendars) ? eventChange(was, e, settings, now) : null;
+        if (e && change && !(await announcedLately(repo, e, run.origin, now))) notice = eventChangeNotice(e, change, settings, calendars, topics);
       }
       if (!notice) { await repo.push.markQueue(row.key, 'skipped', null, now); continue; }
       const n = await sendNotification(repo, notice, run);