@acms-subir/core 0.3.38 → 0.3.39

package/src/lib/calendar/events.ts

@@ -154,6 +154,17 @@ export function expandEvents(events: CalEvent[], settings: Pick<Settings, 'timez
   return out.sort((a, b) => a.start - b.start || a.event.title.localeCompare(b.event.title));
 }
 
+// When RSVPs to one date close (UTC ms), or null when they stay open until it
+// ends: the event's closesAt (wall time in its zone, one instant for every
+// date), else closeBefore minutes before this date's start. A deadline at or
+// after the end isn't one.
+export function rsvpDeadline(o: Pick<Occurrence, 'event' | 'start' | 'end'>, settings: Pick<Settings, 'timezone'>): number | null {
+  const { closesAt, closeBefore } = o.event.rsvp;
+  const w = parseWall(closesAt);
+  const at = w && !w.dateOnly ? wallToMs(w, eventTimeZone(o.event, settings)) : closeBefore > 0 ? o.start - closeBefore * 60_000 : null;
+  return at !== null && at < o.end ? at : null;
+}
+
 // The occurrence of a series with this key (null when the series has no
 // such date: never generated, skipped by exdates, or the series moved)
 export function findOccurrence(e: CalEvent, key: string, settings: Pick<Settings, 'timezone'>, displayTz = settings.timezone || 'UTC'): Occurrence | null {

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

@@ -1,8 +1,8 @@
 // Words of the built-in RSVP: the event page's RSVP block, the RSVP's own
 // page (book/manage) and the app's default button (GET /events/:slug/rsvp).
 // The same wording as the app's RSVP panel (packages/native strings.ts).
-// Plain strings with {count}, {email} and {title} slots (live/words.ts
-// `fill`); of a pair (`spotLeft`/`spotsLeft`), the first is for 1 and the
+// Plain strings with {count}, {email}, {title}, {date} and {time} slots
+// (live/words.ts `fill`); of a pair (`spotLeft`/`spotsLeft`), the first is for 1 and the
 // second for any other number. The event's own form title, questions and
 // button keep their words. Other languages fall back to English.
 export interface RsvpStrings {
@@ -21,6 +21,12 @@ export interface RsvpStrings {
   requestSeat: string;
   full: string;
   closed: string;
+  /** the event's RSVP deadline ({date} and {time}: deadlineParts): before, and once it passed (under `closed`) */
+  closesOn: string;
+  closedOn: string;
+  /** the address already has an RSVP for this date (nothing else about it is shown) */
+  duplicate: string;
+  duplicateNote: string;
   saveError: string;
   /** the RSVP's own page */
   booked: string;
@@ -53,6 +59,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} going', peopleGoing: '{count} going', spotLeft: '{count} spot left', spotsLeft: '{count} spots left',
     saveSeat: 'Save my seat', nameField: 'Your name', emailField: 'Email', seatsField: 'Seats', confirmSeat: 'Confirm my seat', requestSeat: 'Request a seat',
     full: 'This event is full.', closed: 'RSVPs are closed.', saveError: 'Couldn’t save your RSVP. Please try again.',
+    closesOn: 'RSVPs close {date} at {time}', closedOn: 'They closed on {date}. Questions? Contact us.',
+    duplicate: 'You already have an RSVP for this date.', duplicateNote: 'We sent you an email with a link to change it. Need more seats? Change it there.',
     booked: 'You’re booked', yours: 'Your booking', requestSent: 'Request sent', awaitingApproval: 'Waiting for approval', notAvailable: 'Not available', cancelledTitle: 'Booking cancelled',
     emailWhenApproved: 'We’ll email {email} once it’s approved.', confirmationOnItsWay: 'A confirmation is on its way to {email}.',
     declined: 'Sorry, the organiser couldn’t confirm it.', cancelledText: 'This booking is cancelled.',
@@ -65,6 +73,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} va', peopleGoing: '{count} van', spotLeft: '{count} lugar disponible', spotsLeft: '{count} lugares disponibles',
     saveSeat: 'Apartar mi lugar', nameField: 'Tu nombre', emailField: 'Correo electrónico', seatsField: 'Lugares', confirmSeat: 'Confirmar mi lugar', requestSeat: 'Solicitar un lugar',
     full: 'Este evento está lleno.', closed: 'Las confirmaciones están cerradas.', saveError: 'No se pudo guardar tu confirmación. Inténtalo de nuevo.',
+    closesOn: 'Las confirmaciones cierran el {date}, {time}', closedOn: 'Cerraron el {date}. ¿Preguntas? Contáctanos.',
+    duplicate: 'Ya tienes una confirmación para esta fecha.', duplicateNote: 'Te enviamos un correo con un enlace para cambiarla. ¿Necesitas más lugares? Cámbiala ahí.',
     booked: 'Ya tienes tu lugar', yours: 'Tu confirmación', requestSent: 'Solicitud enviada', awaitingApproval: 'En espera de aprobación', notAvailable: 'No se pudo confirmar', cancelledTitle: 'Confirmación cancelada',
     emailWhenApproved: 'Te escribiremos a {email} cuando se apruebe.', confirmationOnItsWay: 'Te enviamos la confirmación a {email}.',
     declined: 'Lo sentimos, el organizador no pudo confirmarla.', cancelledText: 'Esta confirmación se canceló.',
@@ -77,6 +87,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} participant', peopleGoing: '{count} participants', spotLeft: '{count} place restante', spotsLeft: '{count} places restantes',
     saveSeat: 'Réserver ma place', nameField: 'Votre nom', emailField: 'E-mail', seatsField: 'Places', confirmSeat: 'Confirmer ma place', requestSeat: 'Demander une place',
     full: 'Cet événement est complet.', closed: 'Les inscriptions sont closes.', saveError: 'Impossible d’enregistrer votre inscription. Veuillez réessayer.',
+    closesOn: 'Les inscriptions ferment le {date} à {time}', closedOn: 'Elles ont fermé le {date}. Des questions ? Contactez-nous.',
+    duplicate: 'Vous avez déjà une inscription pour cette date.', duplicateNote: 'Nous vous avons envoyé un e-mail avec un lien pour la modifier. Besoin de plus de places ? Modifiez-la depuis ce lien.',
     booked: 'Votre place est réservée', yours: 'Votre inscription', requestSent: 'Demande envoyée', awaitingApproval: 'En attente de validation', notAvailable: 'Non confirmée', cancelledTitle: 'Inscription annulée',
     emailWhenApproved: 'Nous écrirons à {email} dès qu’elle sera validée.', confirmationOnItsWay: 'Une confirmation est en route vers {email}.',
     declined: 'Désolés, l’organisateur n’a pas pu la confirmer.', cancelledText: 'Cette inscription est annulée.',
@@ -89,6 +101,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} Zusage', peopleGoing: '{count} Zusagen', spotLeft: '{count} Platz frei', spotsLeft: '{count} Plätze frei',
     saveSeat: 'Platz reservieren', nameField: 'Ihr Name', emailField: 'E-Mail', seatsField: 'Plätze', confirmSeat: 'Platz bestätigen', requestSeat: 'Platz anfragen',
     full: 'Diese Veranstaltung ist ausgebucht.', closed: 'Anmeldungen sind geschlossen.', saveError: 'Ihre Anmeldung konnte nicht gespeichert werden. Bitte versuchen Sie es erneut.',
+    closesOn: 'Anmeldung bis {date}, {time}', closedOn: 'Die Anmeldung endete am {date}. Fragen? Kontaktieren Sie uns.',
+    duplicate: 'Sie haben für diesen Termin schon eine Anmeldung.', duplicateNote: 'Wir haben Ihnen eine E-Mail mit einem Link zum Ändern geschickt. Mehr Plätze nötig? Ändern Sie sie dort.',
     booked: 'Ihr Platz ist reserviert', yours: 'Ihre Anmeldung', requestSent: 'Anfrage gesendet', awaitingApproval: 'Wartet auf Freigabe', notAvailable: 'Nicht bestätigt', cancelledTitle: 'Anmeldung storniert',
     emailWhenApproved: 'Wir schreiben an {email}, sobald sie freigegeben ist.', confirmationOnItsWay: 'Eine Bestätigung ist unterwegs an {email}.',
     declined: 'Leider konnte der Veranstalter sie nicht bestätigen.', cancelledText: 'Diese Anmeldung ist storniert.',
@@ -101,6 +115,8 @@ const STRINGS: Record<string, RsvpStrings> = {
     personGoing: '{count} confirmado', peopleGoing: '{count} confirmados', spotLeft: '{count} vaga disponível', spotsLeft: '{count} vagas disponíveis',
     saveSeat: 'Reservar minha vaga', nameField: 'Seu nome', emailField: 'E-mail', seatsField: 'Vagas', confirmSeat: 'Confirmar minha vaga', requestSeat: 'Solicitar uma vaga',
     full: 'Este evento está lotado.', closed: 'As inscrições estão encerradas.', saveError: 'Não foi possível salvar sua inscrição. Tente novamente.',
+    closesOn: 'As inscrições se encerram em {date}, {time}', closedOn: 'Elas se encerraram em {date}. Dúvidas? Fale com a gente.',
+    duplicate: 'Você já tem uma inscrição para esta data.', duplicateNote: 'Enviamos um e-mail com um link para alterá-la. Precisa de mais vagas? Altere por lá.',
     booked: 'Sua vaga está reservada', yours: 'Sua inscrição', requestSent: 'Solicitação enviada', awaitingApproval: 'Aguardando aprovação', notAvailable: 'Não confirmada', cancelledTitle: 'Inscrição cancelada',
     emailWhenApproved: 'Vamos escrever para {email} assim que for aprovada.', confirmationOnItsWay: 'Uma confirmação está a caminho de {email}.',
     declined: 'Desculpe, o organizador não pôde confirmá-la.', cancelledText: 'Esta inscrição foi cancelada.',
@@ -119,3 +135,16 @@ export function aroundCount(count: number, one: string, other: string): [string,
   const [before, after = ''] = (count === 1 ? one : other).split('{count}');
   return [before, after];
 }
+
+/** A deadline's date and time in the event's zone for closesOn/closedOn: { date: 'Fri, Oct 24', time: '9 PM' } (minutes only when it has some). */
+export function deadlineParts(at: number, tz: string, locale: string): { date: string; time: string } {
+  const f = (o: Intl.DateTimeFormatOptions) => {
+    try { return new Intl.DateTimeFormat(locale, { ...o, timeZone: tz }); }
+    catch { return new Intl.DateTimeFormat('en-US', { ...o, timeZone: 'UTC' }); }
+  };
+  const time = f({ hour: 'numeric', minute: '2-digit' });
+  const hour = f({ hour: 'numeric' }).format(at);
+  // "9 PM", "21 Uhr"; a bare "21" (Portuguese) keeps its minutes
+  const whole = time.formatToParts(at).find((p) => p.type === 'minute')?.value === '00' && /\D/.test(hour);
+  return { date: f({ weekday: 'short', month: 'short', day: 'numeric' }).format(at), time: whole ? hour : time.format(at) };
+}

package/src/lib/content-service.ts

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

package/src/lib/drafts.ts

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

package/src/lib/editor/documents.ts

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

package/src/lib/editor/schemas.ts

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

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 {
@@ -54,6 +54,7 @@ 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}',
@@ -77,6 +78,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,6 +88,7 @@ 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.',
@@ -108,6 +111,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,6 +121,7 @@ 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.',
@@ -139,6 +144,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,6 +154,7 @@ 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.',
@@ -170,6 +177,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,6 +187,7 @@ 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.',

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/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/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

@@ -72,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 });
@@ -135,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/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);

package/src/lib/push/types.ts

@@ -2,6 +2,22 @@ import { z } from 'zod';
 
 // '*' in a calendars list = every public event
 const keys = z.array(z.string().min(1).max(200)).max(100);
+/** One "when an event changes" rule: the events it covers and who hears. */
+export const ChangeRule = z.object({
+  calendars: keys.default([]),
+  /** only events with one of these tags (any case); [] = every event in the calendars */
+  tags: z.array(z.string().trim().min(1).max(100)).max(20).default([]),
+  /** sent to these topics instead of the event's own (`events` and its calendars) */
+  topics: z.array(z.string().min(1).max(200)).max(10).default([]),
+});
+export type ChangeRule = z.infer<typeof ChangeRule>;
+export const MAX_CHANGE_RULES = 10;
+// one rule, as saved before there could be several: a list of one, or none while it had no calendars
+const oneRule = (v: unknown) => {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return v;
+  const calendars = (v as { calendars?: unknown }).calendars;
+  return Array.isArray(calendars) && calendars.length ? [v] : [];
+};
 export const PushAuto = z.object({
   /** collection keys whose first publish sends a notification */
   newPost: z.object({ collections: keys.default([]) }).default({}),
@@ -11,14 +27,8 @@ export const PushAuto = z.object({
   startingSoon: z.object({ calendars: keys.default([]), minutes: z.number().int().min(5).max(1440).default(30) }).default({}),
   /** "We're live": once per broadcast that live video detects, to devices on the `live` topic */
   live: z.object({ enabled: z.boolean().default(false) }).default({}),
-  /** a published event's new date, time or place, or a cancellation, once its edits settle */
-  eventChanges: z.object({
-    calendars: keys.default([]),
-    /** only events with one of these tags (any case); [] = every event in the calendars */
-    tags: z.array(z.string().trim().min(1).max(100)).max(20).default([]),
-    /** sent to these topics instead of the event's own (`events` and its calendars) */
-    topics: z.array(z.string().min(1).max(200)).max(10).default([]),
-  }).default({}),
+  /** a published event's new date, time or place, or a cancellation, once its edits settle: one notice when any rule covers it */
+  eventChanges: z.preprocess(oneRule, z.array(ChangeRule).max(MAX_CHANGE_RULES)).default([]),
 });
 export type PushAuto = z.infer<typeof PushAuto>;
 export const PushSettings = z.object({ auto: PushAuto.default({}) });

package/src/lib/repo/sql.ts

@@ -1225,6 +1225,9 @@ export class SqlRepository implements ContentRepository {
       write = { sql: `INSERT INTO bookings ${cols} SELECT ${ins.args!.map(() => '?').join(', ')}
         WHERE (? = 0 OR (SELECT COALESCE(SUM(seats),0) FROM bookings WHERE kind='rsvp' AND event_id=? AND start_at=? AND status IN ('pending','confirmed')) + ? <= ?)`,
         args: [...ins.args!,cap,b.eventId,b.start,b.seats,cap] };
+      // same statement, so two at once from one address can't both get in
+      if (guard.oncePerEmail && holds && b.email) write = { sql: write.sql + ` AND NOT EXISTS (SELECT 1 FROM bookings WHERE kind='rsvp' AND event_id=? AND start_at=? AND email=? AND status IN ('pending','confirmed'))`,
+        args: [...write.args!,b.eventId,b.start,b.email] };
     } else if (holds && b.resourceId) {
       write = { sql: `INSERT INTO bookings ${cols} SELECT ${ins.args!.map(() => '?').join(', ')} WHERE NOT EXISTS (
         SELECT 1 FROM bookings WHERE resource_id=? AND kind IN ('booking','block') AND status IN ('pending','confirmed') AND hold_start < ? AND hold_end > ?)`,