@acms-subir/core 0.3.45 → 0.3.47

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

@@ -4,6 +4,8 @@
 // describeRepeat). Plain strings with {date} and {place} slots (live/words.ts
 // `fill`); the repeat line is built by functions, since word order differs
 // per language. No server imports: the event editor shares the repeat line.
+// `calendar` holds the words of the /calendar page, embeds and the calendar
+// card (render.ts).
 // The event's own words (title, button, fields) stay as written. Spanish
 // matches the push notices ("Cancelado el …"). Other languages fall back to
 // English.
@@ -35,6 +37,58 @@ export interface EventStrings {
   fullCalendar: string;
   allDay: string;
   repeat: RepeatWords;
+  calendar: CalendarWords;
+}
+
+/** The calendar page, its filters, embeds and the calendar card. */
+export interface CalendarWords {
+  title: string;
+  /** under the title; {site} is the site's name */
+  lede: string;
+  /** landmark labels */
+  calendars: string;
+  filters: string;
+  views: string;
+  nextTwoWeeks: string;
+  agenda: string;
+  /** the chip for every calendar */
+  all: string;
+  month: string;
+  week: string;
+  list: string;
+  /** a filter chip: "Without Class", "Room: Chapel" (a tag chip is the tag alone) */
+  without: string;
+  room: string;
+  /** the × on a chip, for screen readers */
+  remove: string;
+  clear: string;
+  subscribe: string;
+  subscribeAll: string;
+  subscribeNamed: string;
+  subscribeFiltered: string;
+  copyLink: string;
+  comingUp: string;
+  /** the footer: {zone} is "Eastern Daylight Time" in the page's language */
+  timesIn: string;
+  feedErrors: string;
+  empty: string;
+  emptySoon: string;
+  noMatch: string;
+  /** a confirmed booking on the public calendar: "Reserved · {room}" */
+  reserved: string;
+  untitled: string;
+  /** the grid's toolbar and pop-up */
+  today: string;
+  previous: string;
+  next: string;
+  upcoming: string;
+  noUpcoming: string;
+  details: string;
+  close: string;
+  /** the calendar card's own messages */
+  noSource: string;
+  unavailable: string;
+  openGoogle: string;
 }
 
 /** Weekdays are 0 = Sunday; `n` is the interval (every n days/weeks/months/years). */
@@ -90,6 +144,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, until ${d}`,
       other: 'Repeats',
     },
+    calendar: {
+      title: 'Calendar', lede: 'What’s happening at {site}. Subscribe to keep it in your own calendar.',
+      calendars: 'Calendars', filters: 'Filters', views: 'View', nextTwoWeeks: 'Next two weeks', agenda: 'Agenda',
+      all: 'All', month: 'Month', week: 'Week', list: 'List',
+      without: 'Without {tag}', room: 'Room: {room}', remove: 'Remove {filter}', clear: 'Clear filters',
+      subscribe: 'Subscribe', subscribeAll: 'Add this calendar to your calendar app. New events show up on their own.',
+      subscribeNamed: 'Add “{name}” to your calendar app. New events show up on their own.',
+      subscribeFiltered: 'Add these events to your calendar app. New ones show up on their own.',
+      copyLink: 'Copy link', comingUp: 'Coming up', timesIn: 'Times in {zone}', feedErrors: 'Some linked calendars couldn’t be loaded right now.',
+      empty: 'Nothing on the calendar yet.', emptySoon: 'Nothing in the next two months.', noMatch: 'Nothing matches these filters.',
+      reserved: 'Reserved', untitled: 'Untitled event',
+      today: 'Today', previous: 'Previous', next: 'Next', upcoming: 'Upcoming', noUpcoming: 'No upcoming events.', details: 'Details', close: 'Close',
+      noSource: 'No calendar connected.', unavailable: 'Calendar unavailable right now.', openGoogle: 'Open in Google Calendar ↗',
+    },
   },
   es: {
     cancelled: 'Cancelado', eventCancelled: 'Este evento está cancelado.', eventCancelledNote: 'Lo dejamos en la lista para que nadie se quede con la duda.',
@@ -108,6 +176,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, hasta el ${d}`,
       other: 'Se repite',
     },
+    calendar: {
+      title: 'Calendario', lede: 'Lo que pasa en {site}. Suscríbete para tenerlo en tu propio calendario.',
+      calendars: 'Calendarios', filters: 'Filtros', views: 'Vista', nextTwoWeeks: 'Próximas dos semanas', agenda: 'Agenda',
+      all: 'Todos', month: 'Mes', week: 'Semana', list: 'Lista',
+      without: 'Sin {tag}', room: 'Sala: {room}', remove: 'Quitar {filter}', clear: 'Quitar filtros',
+      subscribe: 'Suscribirse', subscribeAll: 'Agrega este calendario a tu app de calendario. Los eventos nuevos aparecen solos.',
+      subscribeNamed: 'Agrega “{name}” a tu app de calendario. Los eventos nuevos aparecen solos.',
+      subscribeFiltered: 'Agrega estos eventos a tu app de calendario. Los nuevos aparecen solos.',
+      copyLink: 'Copiar enlace', comingUp: 'Próximamente', timesIn: 'Horario de {zone}', feedErrors: 'Algunos calendarios vinculados no se pudieron cargar en este momento.',
+      empty: 'Todavía no hay nada en el calendario.', emptySoon: 'Nada en los próximos dos meses.', noMatch: 'Nada coincide con estos filtros.',
+      reserved: 'Reservado', untitled: 'Evento sin título',
+      today: 'Hoy', previous: 'Anterior', next: 'Siguiente', upcoming: 'Próximos', noUpcoming: 'No hay eventos próximos.', details: 'Detalles', close: 'Cerrar',
+      noSource: 'No hay ningún calendario conectado.', unavailable: 'El calendario no está disponible en este momento.', openGoogle: 'Abrir en Google Calendar ↗',
+    },
   },
   fr: {
     cancelled: 'Annulé', eventCancelled: 'Cet événement est annulé.', eventCancelledNote: 'Il reste affiché pour que personne ne se pose de questions.',
@@ -126,6 +208,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, jusqu’au ${d}`,
       other: 'Récurrent',
     },
+    calendar: {
+      title: 'Calendrier', lede: 'Ce qui se passe à {site}. Abonnez-vous pour le retrouver dans votre propre calendrier.',
+      calendars: 'Calendriers', filters: 'Filtres', views: 'Affichage', nextTwoWeeks: 'Les deux prochaines semaines', agenda: 'Agenda',
+      all: 'Tous', month: 'Mois', week: 'Semaine', list: 'Liste',
+      without: 'Sans {tag}', room: 'Salle : {room}', remove: 'Retirer {filter}', clear: 'Effacer les filtres',
+      subscribe: 'S’abonner', subscribeAll: 'Ajoutez ce calendrier à votre application de calendrier. Les nouveaux événements s’y ajoutent d’eux-mêmes.',
+      subscribeNamed: 'Ajoutez « {name} » à votre application de calendrier. Les nouveaux événements s’y ajoutent d’eux-mêmes.',
+      subscribeFiltered: 'Ajoutez ces événements à votre application de calendrier. Les nouveaux s’y ajoutent d’eux-mêmes.',
+      copyLink: 'Copier le lien', comingUp: 'À venir', timesIn: 'Heures : {zone}', feedErrors: 'Certains calendriers liés n’ont pas pu être chargés pour le moment.',
+      empty: 'Rien au calendrier pour l’instant.', emptySoon: 'Rien dans les deux prochains mois.', noMatch: 'Rien ne correspond à ces filtres.',
+      reserved: 'Réservé', untitled: 'Événement sans titre',
+      today: 'Aujourd’hui', previous: 'Précédent', next: 'Suivant', upcoming: 'À venir', noUpcoming: 'Aucun événement à venir.', details: 'Détails', close: 'Fermer',
+      noSource: 'Aucun calendrier connecté.', unavailable: 'Calendrier indisponible pour le moment.', openGoogle: 'Ouvrir dans Google Agenda ↗',
+    },
   },
   de: {
     cancelled: 'Abgesagt', eventCancelled: 'Diese Veranstaltung ist abgesagt.', eventCancelledNote: 'Sie bleibt sichtbar, damit sich niemand wundert.',
@@ -144,6 +240,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, bis zum ${d}`,
       other: 'Wiederkehrend',
     },
+    calendar: {
+      title: 'Kalender', lede: 'Was bei {site} los ist. Abonnieren Sie den Kalender, um alles in Ihrem eigenen Kalender zu haben.',
+      calendars: 'Kalender', filters: 'Filter', views: 'Ansicht', nextTwoWeeks: 'Die nächsten zwei Wochen', agenda: 'Terminliste',
+      all: 'Alle', month: 'Monat', week: 'Woche', list: 'Liste',
+      without: 'Ohne {tag}', room: 'Raum: {room}', remove: '{filter} entfernen', clear: 'Filter löschen',
+      subscribe: 'Abonnieren', subscribeAll: 'Fügen Sie diesen Kalender Ihrer Kalender-App hinzu. Neue Veranstaltungen erscheinen automatisch.',
+      subscribeNamed: 'Fügen Sie „{name}“ Ihrer Kalender-App hinzu. Neue Veranstaltungen erscheinen automatisch.',
+      subscribeFiltered: 'Fügen Sie diese Veranstaltungen Ihrer Kalender-App hinzu. Neue erscheinen automatisch.',
+      copyLink: 'Link kopieren', comingUp: 'Demnächst', timesIn: 'Zeiten in {zone}', feedErrors: 'Einige verknüpfte Kalender konnten gerade nicht geladen werden.',
+      empty: 'Noch nichts im Kalender.', emptySoon: 'In den nächsten zwei Monaten steht nichts an.', noMatch: 'Nichts passt zu diesen Filtern.',
+      reserved: 'Reserviert', untitled: 'Unbenannte Veranstaltung',
+      today: 'Heute', previous: 'Zurück', next: 'Weiter', upcoming: 'Demnächst', noUpcoming: 'Keine anstehenden Veranstaltungen.', details: 'Details', close: 'Schließen',
+      noSource: 'Kein Kalender verbunden.', unavailable: 'Kalender gerade nicht verfügbar.', openGoogle: 'In Google Kalender öffnen ↗',
+    },
   },
   pt: {
     cancelled: 'Cancelado', eventCancelled: 'Este evento foi cancelado.', eventCancelledNote: 'Ele continua na lista para que ninguém fique na dúvida.',
@@ -164,6 +274,20 @@ const STRINGS: Record<string, EventStrings> = {
       until: (d) => `, até ${d}`,
       other: 'Repete',
     },
+    calendar: {
+      title: 'Calendário', lede: 'O que acontece em {site}. Assine para ter tudo no seu próprio calendário.',
+      calendars: 'Calendários', filters: 'Filtros', views: 'Visualização', nextTwoWeeks: 'Próximas duas semanas', agenda: 'Agenda',
+      all: 'Todos', month: 'Mês', week: 'Semana', list: 'Lista',
+      without: 'Sem {tag}', room: 'Sala: {room}', remove: 'Remover {filter}', clear: 'Limpar filtros',
+      subscribe: 'Assinar', subscribeAll: 'Adicione este calendário ao seu app de calendário. Os novos eventos aparecem sozinhos.',
+      subscribeNamed: 'Adicione “{name}” ao seu app de calendário. Os novos eventos aparecem sozinhos.',
+      subscribeFiltered: 'Adicione estes eventos ao seu app de calendário. Os novos aparecem sozinhos.',
+      copyLink: 'Copiar link', comingUp: 'Em breve', timesIn: 'Horário de {zone}', feedErrors: 'Alguns calendários vinculados não puderam ser carregados agora.',
+      empty: 'Ainda não há nada no calendário.', emptySoon: 'Nada nos próximos dois meses.', noMatch: 'Nada corresponde a estes filtros.',
+      reserved: 'Reservado', untitled: 'Evento sem título',
+      today: 'Hoje', previous: 'Anterior', next: 'Próximo', upcoming: 'Próximos', noUpcoming: 'Nenhum evento programado.', details: 'Detalhes', close: 'Fechar',
+      noSource: 'Nenhum calendário conectado.', unavailable: 'Calendário indisponível no momento.', openGoogle: 'Abrir no Google Agenda ↗',
+    },
   },
 };
 

package/src/lib/calendar/feeds.ts

@@ -5,6 +5,7 @@ import type { CalEvent, Calendar, Settings } from '../schema';
 import { buildFeed } from './ics-write';
 import { eventIsListed, eventIsPublic } from './events';
 import { eventUrl } from './config';
+import { eventMatches, type ResolvedEventFilter } from './filter';
 
 export function icsResponse(body: string, filename: string, cacheSeconds = 300): Response {
   return new Response(body, {
@@ -21,15 +22,22 @@ export async function feedFor(
   repo: ContentRepository,
   settings: Settings,
   origin: string,
-  scope: { calendar?: Calendar; allowPrivate?: boolean }
+  // filter: the address's cal/tag/notag/room (filter.ts); its calendars
+  // stand in for `calendar` on the site-wide feed
+  scope: { calendar?: Calendar; allowPrivate?: boolean; filter?: ResolvedEventFilter }
 ): Promise<{ events: CalEvent[]; body: string }> {
   const [published, calendars] = await Promise.all([repo.listPublishedEvents(), repo.listCalendars()]);
   const map = new Map(calendars.map((c) => [c.id, c]));
   const c = scope.calendar;
+  const f = scope.filter;
   const events = published.filter((e) =>
-    c
+    (c
       ? e.calendarIds.includes(c.id) && (scope.allowPrivate || eventIsPublic(e, map) || c.visibility !== 'private')
-      : eventIsListed(e, map)
+      : f?.calendarIds
+        ? eventIsPublic(e, map)
+        : eventIsListed(e, map))
+    // a feed lists series, so rooms are the series' own
+    && (!f || eventMatches(f, e))
   );
   const host = new URL(origin).host;
   const body = buildFeed(events, settings.timezone, {

package/src/lib/calendar/filter.ts

@@ -0,0 +1,140 @@
+// Which events a calendar view shows, read from its address. The /calendar
+// page, embeds, /api/v1/events, /api/calendar/events, the subscribe feeds
+// and the TV display all take the same parameters and apply the same rules:
+//   cal=youth,events   only these calendars (slugs); `calendar` is an alias
+//   tag=Class          only events with one of these tags
+//   notag=Class        never events with any of these; `excludeTag` is an alias
+//   room=chapel        only events held in one of these rooms (resource slugs)
+// Each can repeat (tag=a&tag=b) or be comma-separated (tag=a,b). A list
+// matches any of its values; different parameters must all match. Tags keep
+// the hasTag rules (a name in any case, or its slug); internal "#" tags only
+// match with allowPrivate. Publicly, private calendars and rooms not shown on
+// public events resolve exactly like slugs that don't exist, so a link can't
+// probe for them.
+import { hasTag, publicTags, type CalEvent, type Calendar, type Resource } from '../schema';
+
+export interface EventFilter {
+  cal: string[];
+  tag: string[];
+  notag: string[];
+  room: string[];
+}
+
+export const NO_FILTER: EventFilter = Object.freeze({ cal: [], tag: [], notag: [], room: [] }) as EventFilter;
+
+const NAMES: Record<keyof EventFilter, string[]> = {
+  cal: ['cal', 'calendar'],
+  tag: ['tag'],
+  notag: ['notag', 'excludeTag'],
+  room: ['room'],
+};
+const MAX_VALUES = 20;
+const MAX_LENGTH = 100;
+
+/** the filter in an address's query (`Astro.url.searchParams`, `url.searchParams`) */
+export function readEventFilter(params: URLSearchParams): EventFilter {
+  const read = (names: string[]) => {
+    const out: string[] = [];
+    for (const name of names) for (const raw of params.getAll(name)) for (const part of raw.split(',')) {
+      const v = part.trim().slice(0, MAX_LENGTH);
+      if (v && out.length < MAX_VALUES && !out.some((o) => o.toLowerCase() === v.toLowerCase())) out.push(v);
+    }
+    return out;
+  };
+  return { cal: read(NAMES.cal), tag: read(NAMES.tag), notag: read(NAMES.notag), room: read(NAMES.room) };
+}
+
+export const hasEventFilter = (f: EventFilter) => f.cal.length + f.tag.length + f.notag.length + f.room.length > 0;
+
+/**
+ * The filter as a query string without the "?" ('' when empty), in the
+ * canonical names with comma-separated values: "cal=events&notag=Class".
+ * For links, subscribe feeds and API calls that should show the same events.
+ */
+export function eventFilterQuery(f: EventFilter): string {
+  return (Object.keys(NAMES) as (keyof EventFilter)[])
+    .filter((k) => f[k].length)
+    .map((k) => `${k}=${f[k].map(encodeURIComponent).join(',')}`)
+    .join('&');
+}
+
+export interface ResolvedEventFilter {
+  /** null: no calendar filter; [] when `cal` was given but none resolved (the view is then empty) */
+  calendarIds: string[] | null;
+  /** null: no room filter; [] when `room` was given but none resolved */
+  roomIds: string[] | null;
+  /** the calendars and rooms that resolved, in the order the address gave them */
+  calendars: Calendar[];
+  rooms: Resource[];
+  tag: string[];
+  notag: string[];
+  /** internal "#" tags match (allowPrivate) */
+  internal: boolean;
+  /** some `cal` or `room` value didn't resolve (unknown, private or hidden) */
+  unknown: boolean;
+}
+
+
+/**
+ * Turns slugs into ids. Publicly, unlisted calendars resolve (as a direct
+ * `?cal=` link always has) but private ones don't, and only rooms shown on
+ * public events resolve. allowPrivate (API keys with events:read, saved
+ * screens) resolves every calendar and room and lets "#" tags match.
+ */
+export function resolveEventFilter(
+  f: EventFilter,
+  ctx: { calendars: Calendar[]; resources?: Resource[]; allowPrivate?: boolean }
+): ResolvedEventFilter {
+  const allowPrivate = ctx.allowPrivate ?? false;
+  const pick = <T extends { id: string; slug: string }>(slugs: string[], items: T[], visible: (item: T) => boolean) => {
+    const found: T[] = [];
+    for (const s of slugs) {
+      const item = items.find((i) => i.slug === s.toLowerCase() && visible(i));
+      if (item && !found.includes(item)) found.push(item);
+    }
+    return found;
+  };
+  const calendars = pick(f.cal, ctx.calendars, (c) => allowPrivate || c.visibility !== 'private');
+  const rooms = pick(f.room, ctx.resources ?? [], (r) => allowPrivate || r.showOnEvents);
+  return {
+    calendarIds: f.cal.length ? calendars.map((c) => c.id) : null,
+    roomIds: f.room.length ? rooms.map((r) => r.id) : null,
+    calendars, rooms,
+    tag: f.tag, notag: f.notag,
+    internal: allowPrivate,
+    unknown: calendars.length < f.cal.length || rooms.length < f.room.length,
+  };
+}
+
+/** `tag` (any of them, when given) and no `notag`; "#" tags only count when internal */
+export function tagsMatch(f: Pick<EventFilter, 'tag' | 'notag'>, names: string[], opts: { internal?: boolean } = {}): boolean {
+  const shown = opts.internal ? names : publicTags(names);
+  return (!f.tag.length || f.tag.some((t) => hasTag(shown, t))) && !f.notag.some((t) => hasTag(shown, t));
+}
+
+const overlaps = (wanted: string[] | null, have: string[]) => wanted === null || have.some((id) => wanted.includes(id));
+
+/**
+ * Does one event pass? `roomIds` are the rooms the date holds: the event's
+ * room hold unless a moved date changed them. Visibility (drafts, private
+ * calendars) is the caller's job; this only applies the filter.
+ */
+export function eventMatches(r: ResolvedEventFilter, e: Pick<CalEvent, 'calendarIds' | 'tags' | 'roomHold'>, roomIds: string[] = e.roomHold.resourceIds): boolean {
+  return overlaps(r.calendarIds, e.calendarIds) && overlaps(r.roomIds, roomIds) && tagsMatch(r, e.tags, { internal: r.internal });
+}
+
+/** eventMatches for one occurrence, using the rooms that date holds */
+export function occurrenceMatches(r: ResolvedEventFilter, o: { event: Pick<CalEvent, 'calendarIds' | 'tags' | 'roomHold'>; roomIds?: string[] }): boolean {
+  return eventMatches(r, o.event, o.roomIds ?? o.event.roomHold.resourceIds);
+}
+
+/**
+ * Entries without an event (feed calendars, Reserved blocks) have no tags:
+ * `tag` leaves them out and `notag` keeps them. A Reserved block passes a
+ * room filter for its own room; feed entries never do.
+ */
+export function untaggedMatches(r: ResolvedEventFilter, opts: { calendarId?: string; roomId?: string } = {}): boolean {
+  if (r.tag.length) return false;
+  if (r.roomIds !== null && !(opts.roomId && r.roomIds.includes(opts.roomId))) return false;
+  return r.calendarIds === null || Boolean(opts.calendarId && r.calendarIds.includes(opts.calendarId));
+}

package/src/lib/calendar/hooks.ts

@@ -1,42 +1,87 @@
-// Side effects when an event changes live: a 301 when a published event's
-// slug moves, a queued "event changed" app notice when its schedule or place
-// moves, and the matching webhook (event.published / event.updated /
-// event.unpublished). Shared by the editor actions, the list's bulk actions
-// and the agent tools so every path behaves the same.
-import type { ContentRepository } from '../repo/types';
-import type { CalEvent } from '../schema';
+// Side effects when a published event changes: a 301 when its slug moves, a
+// queued "event changed" app notice when its schedule or place moves, and the
+// matching webhook (event.published / event.updated / event.unpublished /
+// event.deleted). Every write path records its changes in event_changes
+// (triggers, ./change-migration.ts) in the same transaction, so this is the
+// one place they become side effects, whoever made them. Editor paths flush
+// at once (the redirect works on the very next request); the flush after
+// every mutating request and the scheduler catch the rest, raw SQL included
+// (scheduled publishing, environment sync, place refreshes).
+import type { ContentRepository, EventChange } from '../repo/types';
+import type { Calendar, Resource, Settings } from '../schema';
 import { emitWebhook } from '../webhooks';
-import { queueEventChange } from '../push/service';
+import { queueEventChange, siteOriginOf } from '../push/service';
 import { eventToJson } from './api';
 import { eventUrl } from './config';
 
-export async function eventChanged(
-  repo: ContentRepository,
-  before: CalEvent,
-  after: CalEvent,
-  opts: { origin: string; waitUntil?: (p: Promise<unknown>) => void; applied?: boolean; onRedirect?: () => void }
-): Promise<void> {
-  if (before.status === 'published' && after.status === 'published' && before.slug !== after.slug) {
+export interface FlushOptions {
+  /** this request's origin, for webhook links while the site URL isn't set */
+  origin?: string;
+  waitUntil?: (p: Promise<unknown>) => void;
+  /** called when a slug redirect was added (the middleware drops its cached rules) */
+  onRedirect?: () => void;
+  now?: number;
+}
+
+const BATCH = 50;
+const ROUNDS = 20;
+/** how long a claim holds its changes; one that failed is retried after it */
+const LEASE = 5 * 60_000;
+/** a change that failed this many times is dropped */
+const MAX_ATTEMPTS = 3;
+
+interface Site { origin: string; settings: Settings; calendars: Map<string, Calendar>; resources: Map<string, Resource> }
+
+// One write, as webhooks for posts report them: several writes in one save
+// send one webhook each. The push queue keeps what people last knew, so
+// several changes close together still send one notice.
+async function apply(repo: ContentRepository, change: EventChange, now: number, site: () => Promise<Site>, opts: FlushOptions) {
+  const { before, after } = change;
+  const was = before?.status === 'published';
+  if (was && after?.status === 'published' && before.slug !== after.slug) {
     await repo.createRedirect({ fromPath: eventUrl(before.slug), toPath: eventUrl(after.slug) }).catch(() => {});
     opts.onRedirect?.();
   }
-  // the scheduler sends it once the edits settle, if the rule still applies
-  await queueEventChange(repo, before, after).catch((e) => console.error('acms push: event change not queued', e));
-  let type: 'event.published' | 'event.updated' | 'event.unpublished' | null = null;
-  if (before.status !== 'published' && after.status === 'published') type = 'event.published';
-  else if (before.status === 'published' && after.status !== 'published') type = 'event.unpublished';
-  else if (after.status === 'published' && (opts.applied || before.updatedAt !== after.updatedAt)) type = 'event.updated';
+  // the scheduler sends it once the edits settle, if the rule still applies;
+  // a bulk copy (quiet) sends webhooks and redirects, never pushes
+  if (before && after && !change.quiet) await queueEventChange(repo, before, after, now).catch((e) => console.error('acms push: event change not queued', e));
+  if (!after) {
+    if (was) await emitWebhook(repo, 'event.deleted', { event: { id: before.id, slug: before.slug, title: before.title } }, { waitUntil: opts.waitUntil }).catch(() => {});
+    return;
+  }
+  const type = was ? (after.status === 'published' ? 'event.updated' : 'event.unpublished') : after.status === 'published' ? 'event.published' : null;
   if (!type) return;
-  const [settings, calendars, rooms] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listResources()]);
-  const data = eventToJson(after, opts.origin, new Map(calendars.map((c) => [c.id, c])), settings.timezone, { resources: new Map(rooms.map((r) => [r.id, r])) });
-  await emitWebhook(repo, type, { event: data }, { waitUntil: opts.waitUntil }).catch(() => {});
+  const { origin, settings, calendars, resources } = await site();
+  await emitWebhook(repo, type, { event: eventToJson(after, origin, calendars, settings.timezone, { resources }) }, { waitUntil: opts.waitUntil }).catch(() => {});
 }
 
-export async function eventDeleted(
-  repo: ContentRepository,
-  before: CalEvent | null,
-  opts: { waitUntil?: (p: Promise<unknown>) => void }
-): Promise<void> {
-  if (before?.status !== 'published') return;
-  await emitWebhook(repo, 'event.deleted', { event: { id: before.id, slug: before.slug, title: before.title } }, opts).catch(() => {});
+/** Runs the side effects of every recorded change to a published event, oldest first. Returns how many changes it handled. */
+export async function flushEventChanges(repo: ContentRepository, opts: FlushOptions = {}): Promise<number> {
+  let site: Promise<Site> | null = null;
+  const load = () => (site ??= Promise.all([repo.getSettings(), repo.listCalendars(), repo.listResources()]).then(([settings, calendars, rooms]) => ({
+    origin: siteOriginOf(settings, opts.origin), settings, calendars: new Map(calendars.map((c) => [c.id, c])), resources: new Map(rooms.map((r) => [r.id, r])) })));
+  let handled = 0;
+  for (let round = 0; round < ROUNDS; round++) {
+    const now = opts.now ?? Date.now();
+    const claimed = await repo.claimEventChanges(now, BATCH, LEASE);
+    if (!claimed.length) break;
+    const done: number[] = [];
+    const failed = new Set<string>();
+    for (const change of claimed) {
+      // a later change to an event whose earlier one failed waits with it, in order
+      if (failed.has(change.eventId)) continue;
+      try {
+        // a snapshot that no longer parses has nothing to report
+        if (change.before || change.after) await apply(repo, change, now, load, opts);
+      } catch (e) {
+        console.error('acms calendar: event change side effects failed', e);
+        if (change.attempts < MAX_ATTEMPTS) { failed.add(change.eventId); continue; }
+      }
+      done.push(change.seq);
+    }
+    await repo.finishEventChanges(done);
+    handled += done.length;
+    if (claimed.length < BATCH) break;
+  }
+  return handled;
 }

package/src/lib/calendar/render.ts

@@ -11,7 +11,7 @@ import { siteLocale } from '../dates';
 import { getCalendarEvents, tzParts, zonedToUtc } from './ics';
 import { calendarPageUrl } from './src';
 import { collectViewEvents, type ViewEvent } from './data';
-import { eventStrings } from './event-words';
+import { eventStrings, type EventStrings } from './event-words';
 
 // Card sources are ICS feed URLs or native site calendars:
 //   'acms:all'         every public calendar (+ uncategorized events)
@@ -65,6 +65,7 @@ function compactTime(s: string): string {
 }
 
 function buildDisplay(events: ViewEvent[], tz: string, locale: string): DisplayEvent[] {
+  const allDay = eventStrings(locale).allDay;
   const timeFmt = new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', timeZone: tz });
   const dayFmt = new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz });
   return events.map((e) => {
@@ -73,7 +74,7 @@ function buildDisplay(events: ViewEvent[], tz: string, locale: string): DisplayE
     let tm = '';
     let rg: string;
     if (e.allDay) {
-      rg = e.days > 1 ? `${when} – ${dayFmt.format(e.end - DAY)}` : `${when} · All day`;
+      rg = e.days > 1 ? `${when} – ${dayFmt.format(e.end - DAY)}` : `${when} · ${allDay}`;
     } else {
       tm = compactTime(timeFmt.format(e.start));
       rg = `${when} · ${timeFmt.format(e.start)} – ${timeFmt.format(e.end)}`;
@@ -132,11 +133,11 @@ function weekHtml(weekStart: number, todayN: number, byDay: Map<number, number[]
   return `<div class="pc-cal-week">${h}</div>`;
 }
 
-function upcomingHtml(events: DisplayEvent[], order: number[], limit: number): string {
-  if (!order.length) return `<p class="pc-cal-empty">No upcoming events.</p>`;
+function upcomingHtml(events: DisplayEvent[], order: number[], limit: number, w: EventStrings): string {
+  if (!order.length) return `<p class="pc-cal-empty">${esc(w.calendar.noUpcoming)}</p>`;
   const items = order.slice(0, limit).map((i) => {
     const e = events[i];
-    return `<li><button type="button" class="pc-cal-row${e.x ? ' is-cancelled' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="d">${esc(e.rg.split(' · ')[0])}</span><span class="ti">${esc(e.t)}</span><span class="t">${esc(e.tm) || 'All day'}</span></button></li>`;
+    return `<li><button type="button" class="pc-cal-row${e.x ? ' is-cancelled' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="d">${esc(e.rg.split(' · ')[0])}</span><span class="ti">${esc(e.t)}</span><span class="t">${esc(e.tm) || esc(w.allDay)}</span></button></li>`;
   });
   return `<ul class="pc-cal-agenda">${items.join('')}</ul>`;
 }
@@ -189,7 +190,7 @@ if(!hit||!root.contains(hit)){if(!t.closest('.pc-cal-pop'))closePop();return}
 var e=P.events[Number(hit.getAttribute('data-ev'))];if(!e)return;
 closePop();
 pop=document.createElement('div');pop.className='pc-cal-pop';
-pop.innerHTML='<button type="button" class="pc-cal-pop-x" aria-label="Close">&times;</button>'+(e.x?'<span class="pc-cal-pop-flag">'+esc(P.cancelled)+'</span>':'')+'<strong class="pc-cal-pop-title">'+esc(e.t)+'</strong><div class="pc-cal-pop-when">'+esc(e.rg)+'</div>'+(e.l?'<div class="pc-cal-pop-loc">'+esc(e.l)+'</div>':'')+(e.ds?'<p class="pc-cal-pop-desc">'+esc(e.ds)+'</p>':'')+(e.u?'<a class="pc-cal-pop-link" href="'+esc(e.u)+'">'+esc(P.details)+' &rarr;</a>':'');
+pop.innerHTML='<button type="button" class="pc-cal-pop-x" aria-label="'+esc(P.close)+'">&times;</button>'+(e.x?'<span class="pc-cal-pop-flag">'+esc(P.cancelled)+'</span>':'')+'<strong class="pc-cal-pop-title">'+esc(e.t)+'</strong><div class="pc-cal-pop-when">'+esc(e.rg)+'</div>'+(e.l?'<div class="pc-cal-pop-loc">'+esc(e.l)+'</div>':'')+(e.ds?'<p class="pc-cal-pop-desc">'+esc(e.ds)+'</p>':'')+(e.u?'<a class="pc-cal-pop-link" href="'+esc(e.u)+'">'+esc(P.details)+' &rarr;</a>':'');
 frame.appendChild(pop);
 var fr=frame.getBoundingClientRect(),cr=hit.getBoundingClientRect();
 pop.style.left=Math.max(8,Math.min(cr.left-fr.left,fr.width-pop.offsetWidth-8))+'px';
@@ -234,7 +235,9 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     (opts.title ? `<h3 class="pc-cal-heading">${esc(opts.title)}</h3>` : '') +
     (opts.subtitle ? `<p class="pc-cal-sub">${esc(opts.subtitle)}</p>` : '');
   const tz = settings.timezone || 'UTC';
+  // a page in another language passes its settings with that locale
   const locale = siteLocale(settings);
+  const w = eventStrings(locale);
   const today = tzParts(now, tz);
   const [minY, minM] = addMonths(today.y, today.m, -6);
   const [maxY, maxM] = addMonths(today.y, today.m, 6);
@@ -263,10 +266,10 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     titleText = `${monthsShort[wa.m - 1]} ${wa.d} – ${wa.m === wb.m ? '' : `${monthsShort[wb.m - 1]} `}${wb.d}, ${wb.y}`;
     bodyHtml = weekHtml(weekStart, todayN, byDay, events, dows);
   } else if (opts.view === 'upcoming') {
-    titleText = 'Upcoming';
+    titleText = w.calendar.upcoming;
     const startOfToday = zonedToUtc(today.y, today.m, today.d, 0, 0, 0, tz);
     const order = raw.map((e, i) => ({ e, i })).filter(({ e }) => e.end > startOfToday).map(({ i }) => i);
-    bodyHtml = upcomingHtml(events, order, Math.min(50, Math.max(1, opts.limit || 6)));
+    bodyHtml = upcomingHtml(events, order, Math.min(50, Math.max(1, opts.limit || 6)), w);
     if (!order.length && opts.emptyText) bodyHtml = `<p class="pc-cal-empty">${esc(opts.emptyText)}</p>`;
   } else {
     titleText = `${months[fm - 1]} ${fy}`;
@@ -276,9 +279,9 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
   const navButtons =
     opts.view === 'upcoming'
       ? ''
-      : `<button type="button" class="pc-cal-btn" data-nav="today">Today</button>` +
-        `<button type="button" class="pc-cal-btn" data-nav="prev" aria-label="Previous">‹</button>` +
-        `<button type="button" class="pc-cal-btn" data-nav="next" aria-label="Next">›</button>`;
+      : `<button type="button" class="pc-cal-btn" data-nav="today">${esc(w.calendar.today)}</button>` +
+        `<button type="button" class="pc-cal-btn" data-nav="prev" aria-label="${esc(w.calendar.previous)}">‹</button>` +
+        `<button type="button" class="pc-cal-btn" data-nav="next" aria-label="${esc(w.calendar.next)}">›</button>`;
 
   const footer = opts.footer
     ? `<div class="pc-cal-foot"><a class="pc-cal-open" href="${esc(opts.footer.href)}" target="_blank" rel="noopener">${esc(opts.footer.label)}</a></div>`
@@ -291,8 +294,8 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     min: [minY, minM],
     max: [maxY, maxM],
     months, monthsShort, dows, events, ws,
-    // the pop-up's flag in the dates' language, like event cards
-    details: 'Details', cancelled: eventStrings(locale).cancelled,
+    // the pop-up's words in the dates' language, like event cards
+    details: w.calendar.details, cancelled: w.cancelled, close: w.calendar.close,
   };
   const json = JSON.stringify(payload).replace(/</g, '\\u003c');
 
@@ -319,11 +322,12 @@ export async function renderCalendarBlock(
   const heading =
     (a.title ? `<h3 class="pc-cal-heading">${esc(a.title)}</h3>` : '') +
     (a.subtitle ? `<p class="pc-cal-sub">${esc(a.subtitle)}</p>` : '');
+  const w = eventStrings(siteLocale(settings)).calendar;
 
   const feeds = a.sources.filter((s) => s.startsWith('http'));
   const natives = repo ? a.sources.filter(isNativeSource) : [];
   if (!feeds.length && !natives.length) {
-    return `<section class="pc-calendar is-empty">${heading}<div class="pc-cal-frame"><p class="pc-cal-empty">No calendar connected.</p></div></section>`;
+    return `<section class="pc-calendar is-empty">${heading}<div class="pc-cal-frame"><p class="pc-cal-empty">${esc(w.noSource)}</p></div></section>`;
   }
 
   const win = calendarWindow(settings, now);
@@ -346,7 +350,7 @@ export async function renderCalendarBlock(
   const raw: ViewEvent[] = [...feedEvents, ...native].sort((x, y) => x.start - y.start || x.title.localeCompare(y.title));
 
   if (!raw.length && feeds.length && errors.length === feeds.length && !natives.length) {
-    return `<section class="pc-calendar is-empty">${heading}<div class="pc-cal-frame"><p class="pc-cal-empty">Calendar unavailable right now.</p></div></section>`;
+    return `<section class="pc-calendar is-empty">${heading}<div class="pc-cal-frame"><p class="pc-cal-empty">${esc(w.unavailable)}</p></div></section>`;
   }
 
   const pageUrl = a.showOpenLink ? feeds.map(calendarPageUrl).find(Boolean) ?? '' : '';
@@ -355,7 +359,7 @@ export async function renderCalendarBlock(
     title: a.title,
     subtitle: a.subtitle,
     limit: a.limit,
-    footer: pageUrl ? { href: pageUrl, label: 'Open in Google Calendar ↗' } : undefined,
+    footer: pageUrl ? { href: pageUrl, label: w.openGoogle } : undefined,
     // dots only mean something with 2+ calendars
     multi: feeds.length + nativeCalendars > 1,
   });

package/src/lib/calendar/requests.ts

@@ -2,10 +2,9 @@ import type { ContentRepository } from '../repo/types';
 import type { CalEvent, EventRequest } from '../schema';
 import { EventLocation } from '../schema';
 import { ApiError } from '../api';
-import { applyEventUpdate, saveEvent, type SaveHooks } from '../content-service';
+import { applyEventUpdate, flushEventHooks, saveEvent, type SaveHooks } from '../content-service';
 import { CALENDAR } from './config';
 import { cancelOccurrence, restoreOccurrence, uniqueSlug } from './schedule';
-import { eventDeleted } from './hooks';
 import { waitUntilFrom } from '../webhooks';
 import { kickEmail } from '../email/service';
 
@@ -191,7 +190,7 @@ export async function withdrawEventRequest(repo: ContentRepository, who: Actor |
   // only an event the member's own request made is deleted; a draft staff wrote stays
   if (e.request.kind === 'new' && e.request.created && !live(e) && !e.publishedAt) {
     await repo.deleteEvent(id);
-    await eventDeleted(repo, e, { waitUntil: waitUntilFrom(hooks.locals) });
+    await flushEventHooks(repo, hooks);
     return { deleted: true };
   }
   if (e.request.kind === 'changes') await repo.discardEventDraft(id);