@acms-subir/core 0.3.46 → 0.3.48

package/src/lib/calendar/data.ts

@@ -4,9 +4,13 @@
 // live through the cached ICS loader. Visibility rules live in events.ts.
 import type { ContentRepository } from '../repo/types';
 import { roomColor, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
-import { eventIsListed, eventIsPublic, expandEvents, safeColor } from './events';
+import { eventIsListed, eventIsPublic, eventRoomIds, expandEvents, locationLine, safeColor, type OccurrenceMove } from './events';
 import { expandVEvents, loadFeed, tzParts, type CalendarEvent, type CalendarWindow } from './ics';
 import { CALENDAR, eventUrl, resourceUrl, withoutPrivateFields } from './config';
+import { occurrenceMatches, tagsMatch, untaggedMatches, type ResolvedEventFilter } from './filter';
+import { eventStrings } from './event-words';
+import { localePath } from '../i18n';
+import { localizeDoc } from '../translations';
 
 export interface ViewEvent extends CalendarEvent {
   url?: string;
@@ -19,6 +23,10 @@ export interface ViewEvent extends CalendarEvent {
   // native events: the rooms this date holds; public views name only rooms
   // set to show on public events (Resource.showOnEvents)
   rooms?: ViewRoom[];
+  // native events: the date's occurrence key (a moved date keeps its original one)
+  key?: string;
+  // this date was moved here: where it was (UTC ms) and the public note
+  moved?: OccurrenceMove;
 }
 
 // color: '#rrggbb', or '' when the room has none
@@ -34,6 +42,12 @@ export interface ViewScope {
   includeFeeds?: boolean;
   // "Reserved" blocks from resources set to show on the calendar
   includeBookings?: boolean;
+  // the address's cal/tag/notag/room (filter.ts); its calendars narrow
+  // calendarIds when both are given
+  filter?: ResolvedEventFilter;
+  // the request's language (requestLocale): translated titles, event links
+  // under its /<locale> prefix, and "Reserved" in its words
+  locale?: string;
 }
 
 const pad = (n: number) => String(n).padStart(2, '0');
@@ -46,7 +60,9 @@ export async function collectViewEvents(
 ): Promise<{ events: ViewEvent[]; calendars: Calendar[]; errors: string[] }> {
   const all = await repo.listCalendars();
   const byId = new Map(all.map((c) => [c.id, c]));
-  const requested = scope.calendarIds ? new Set(scope.calendarIds) : null;
+  const f = scope.filter;
+  const ids = scope.calendarIds && f?.calendarIds ? scope.calendarIds.filter((id) => f.calendarIds!.includes(id)) : scope.calendarIds ?? f?.calendarIds;
+  const requested = ids ? new Set(ids) : null;
   const visible = all.filter((c) => {
     if (scope.audience === 'admin') return true;
     // a directly requested calendar may be unlisted; private never is
@@ -60,6 +76,7 @@ export async function collectViewEvents(
   const source = scope.audience === 'admin' ? (await repo.listEvents()).filter((e) => e.status !== 'archived') : await repo.listPublishedEvents();
   const natives = source.filter((e) => {
     if (scope.audience === 'public' && !eventIsPublic(e, byId)) return false;
+    if (f && !tagsMatch(f, e.tags, { internal: f.internal })) return false;
     if (!e.calendarIds.length) {
       if (requested) return false;
       return scope.includeUncategorized ?? true;
@@ -73,39 +90,44 @@ export async function collectViewEvents(
   const shown = new Map<string, CalEvent>();
   const view = (e: CalEvent) => {
     if (scope.audience === 'admin') return e;
-    if (!shown.has(e.id)) shown.set(e.id, withoutPrivateFields(e));
+    if (!shown.has(e.id)) shown.set(e.id, withoutPrivateFields(localizeDoc(e, scope.locale)));
     return shown.get(e.id)!;
   };
-  const resources = natives.some((e) => e.roomHold.resourceIds.length) ? new Map((await repo.listResources()).map((r) => [r.id, r])) : new Map<string, Resource>();
+  const resources = natives.some((e) => eventRoomIds(e).length) ? new Map((await repo.listResources()).map((r) => [r.id, r])) : new Map<string, Resource>();
   const rooms = (ids: string[]) => ids.map((id) => resources.get(id))
     .filter((r): r is Resource => Boolean(r) && (scope.audience === 'admin' || r!.showOnEvents))
     .map((r) => ({ id: r.id, slug: r.slug, name: r.name, color: roomColor(r) }));
+  const words = eventStrings(scope.locale).calendar;
   for (const o of expandEvents(natives, settings, win)) {
-    const e = o.event;
+    // rooms are per date (a moved date can change them)
+    if (f?.roomIds && !occurrenceMatches(f, o)) continue;
+    const e = view(o.event);
     const cal = e.calendarIds.map((id) => byId.get(id)).find((c) => c && scoped.has(c.id));
     const p = tzParts(o.start, tz);
     const on = e.rrule ? `?on=${p.y}-${pad(p.m)}-${pad(p.d)}` : '';
     events.push({
       start: o.start, end: o.end, allDay: o.allDay, days: o.days,
-      title: e.title || 'Untitled event',
-      location: [e.location.name, e.location.address].filter(Boolean).join(', '),
+      title: e.title || words.untitled,
+      location: locationLine(o.moved?.location ?? e.location),
       description: e.excerpt,
       cal: cal ? idx.get(cal.id) ?? 0 : 0,
       ref: e.id,
-      url: eventUrl(e.slug) + on,
+      url: localePath(eventUrl(e.slug), scope.locale ?? '') + on,
       color: cal ? safeColor(cal.color) : undefined,
       cancelled: o.cancelled,
       image: e.cover || undefined,
       imageAlt: e.coverAlt || undefined,
       calendarName: cal?.name,
-      event: view(e),
+      event: e,
       rooms: rooms(o.roomIds),
+      key: o.key,
+      ...(o.moved ? { moved: o.moved } : {}),
     });
   }
 
   const errors: string[] = [];
   if (scope.includeFeeds ?? true) {
-    const feeds = inScope.filter((c) => c.kind === 'feed' && c.feedUrl);
+    const feeds = inScope.filter((c) => c.kind === 'feed' && c.feedUrl && (!f || untaggedMatches(f, { calendarId: c.id })));
     const results = await Promise.all(
       feeds.map(async (c) => {
         try {
@@ -125,7 +147,7 @@ export async function collectViewEvents(
   // resources marked "show on calendar": confirmed bookings appear as
   // Reserved blocks (no guest names on public views) — only on unscoped views
   if (!requested && (scope.includeBookings ?? true) && CALENDAR.bookings) {
-    const resources = (await repo.listResources()).filter((r) => r.showOnCalendar);
+    const resources = (await repo.listResources()).filter((r) => r.showOnCalendar && (!f || untaggedMatches(f, { roomId: r.id })));
     if (resources.length) {
       const booked = await repo.listBookings({ from: win.windowStartMs, to: win.windowEndMs, statuses: ['confirmed'], kinds: ['booking'] });
       const byId = new Map(resources.map((r) => [r.id, r]));
@@ -135,7 +157,7 @@ export async function collectViewEvents(
         const allDay = b.end - b.start >= 86_400_000 - 3_600_000;
         events.push({
           start: b.start, end: b.end, allDay, days: allDay ? Math.max(1, Math.round((b.end - b.start) / 86_400_000)) : 1,
-          title: scope.audience === 'admin' ? `${r.name} · ${b.name}` : `Reserved · ${r.name}`,
+          title: scope.audience === 'admin' ? `${r.name} · ${b.name}` : `${words.reserved} · ${r.name}`,
           location: r.name, description: '', cal: inScope.length, color: '#8e919a', calendarName: r.name,
           url: scope.audience === 'public' ? resourceUrl(r.slug) : undefined,
         });

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.
@@ -16,6 +18,10 @@ export interface EventStrings {
   /** one date of a repeating event */
   dateCancelled: string;
   dateCancelledNote: string;
+  /** one date moved to another time: the flag, then "Moved from {from}." and the note (staff's own note replaces it) */
+  moved: string;
+  dateMoved: string;
+  dateMovedNote: string;
   /** the side column's landmark label */
   details: string;
   joinOnline: string;
@@ -35,6 +41,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). */
@@ -76,6 +134,7 @@ const STRINGS: Record<string, EventStrings> = {
   en: {
     cancelled: 'Cancelled', eventCancelled: 'This event is cancelled.', eventCancelledNote: 'It stays listed so nobody is left wondering.',
     dateCancelled: 'Cancelled on {date}.', dateCancelledNote: 'Other dates go ahead as usual.',
+    moved: 'Moved', dateMoved: 'Moved from {from}.', dateMovedNote: 'Other dates stay as usual.',
     details: 'Event details', joinOnline: 'Join online', map: 'Map', directionsTo: 'Directions to {place}', mapOf: 'Map of {place}',
     directionsHere: 'Directions to the location', mapHere: 'Map of the location', showing: 'Showing {date}',
     addToCalendar: 'Add to calendar', downloadIcs: 'Download .ics', share: 'Share', linkCopied: 'Link copied',
@@ -90,10 +149,25 @@ 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.',
     dateCancelled: 'Cancelado el {date}.', dateCancelledNote: 'Las demás fechas siguen como siempre.',
+    moved: 'Cambio de horario', dateMoved: 'Cambió de horario: antes era el {from}.', dateMovedNote: 'Las demás fechas siguen como siempre.',
     details: 'Detalles del evento', joinOnline: 'Unirse en línea', map: 'Mapa', directionsTo: 'Cómo llegar a {place}', mapOf: 'Mapa de {place}',
     directionsHere: 'Cómo llegar al lugar', mapHere: 'Mapa del lugar', showing: 'Mostrando el {date}',
     addToCalendar: 'Agregar al calendario', downloadIcs: 'Descargar .ics', share: 'Compartir', linkCopied: 'Enlace copiado',
@@ -108,10 +182,25 @@ 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.',
     dateCancelled: 'Annulé le {date}.', dateCancelledNote: 'Les autres dates sont maintenues.',
+    moved: 'Déplacé', dateMoved: 'Déplacé : prévu initialement le {from}.', dateMovedNote: 'Les autres dates sont maintenues.',
     details: 'Détails de l’événement', joinOnline: 'Rejoindre en ligne', map: 'Carte', directionsTo: 'Itinéraire vers {place}', mapOf: 'Carte de {place}',
     directionsHere: 'Itinéraire vers le lieu', mapHere: 'Carte du lieu', showing: 'Date affichée : {date}',
     addToCalendar: 'Ajouter au calendrier', downloadIcs: 'Télécharger le .ics', share: 'Partager', linkCopied: 'Lien copié',
@@ -126,10 +215,25 @@ 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.',
     dateCancelled: 'Abgesagt am {date}.', dateCancelledNote: 'Die anderen Termine finden wie gewohnt statt.',
+    moved: 'Verschoben', dateMoved: 'Verschoben: ursprünglich am {from}.', dateMovedNote: 'Die anderen Termine finden wie gewohnt statt.',
     details: 'Veranstaltungsdetails', joinOnline: 'Online teilnehmen', map: 'Karte', directionsTo: 'Route zu {place}', mapOf: 'Karte von {place}',
     directionsHere: 'Route zum Ort', mapHere: 'Karte des Ortes', showing: 'Angezeigt: {date}',
     addToCalendar: 'Zum Kalender hinzufügen', downloadIcs: '.ics herunterladen', share: 'Teilen', linkCopied: 'Link kopiert',
@@ -144,10 +248,25 @@ 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.',
     dateCancelled: 'Cancelado em {date}.', dateCancelledNote: 'As outras datas continuam normalmente.',
+    moved: 'Remarcado', dateMoved: 'Remarcado: antes era em {from}.', dateMovedNote: 'As outras datas continuam normalmente.',
     details: 'Detalhes do evento', joinOnline: 'Participar on-line', map: 'Mapa', directionsTo: 'Como chegar a {place}', mapOf: 'Mapa de {place}',
     directionsHere: 'Como chegar ao local', mapHere: 'Mapa do local', showing: 'Exibindo {date}',
     addToCalendar: 'Adicionar ao calendário', downloadIcs: 'Baixar .ics', share: 'Compartilhar', linkCopied: 'Link copiado',
@@ -164,6 +283,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/events.ts

@@ -1,7 +1,7 @@
 // Native events: wall-clock time math, recurrence expansion (reusing the ICS
 // expander, so feed events and native events follow identical rules),
 // visibility, and "add to calendar" links. Pure — no repo, no fetch.
-import type { CalEvent, Calendar, EventLocation, Settings } from '../schema';
+import type { CalEvent, Calendar, EventLocation, MovedDate, Settings } from '../schema';
 import { expandVEvents, tzParts, zonedToUtc, type CalendarWindow, type IcsTime, type VEvent } from './ics';
 import { cleanRrule } from './rrule';
 import { eventStrings } from './event-words';
@@ -35,6 +35,9 @@ function fromMinutes(min: number, dateOnly: boolean): Wall {
   return { y: dt.getUTCFullYear(), m: dt.getUTCMonth() + 1, d: dt.getUTCDate(), hh: dateOnly ? 0 : dt.getUTCHours(), mm: dateOnly ? 0 : dt.getUTCMinutes(), dateOnly };
 }
 export const addWallDays = (w: Wall, n: number) => fromMinutes(wallMinutes(w) + n * 1440, w.dateOnly);
+export const addWallMinutes = (w: Wall, n: number) => fromMinutes(wallMinutes(w) + n, w.dateOnly);
+/** whole minutes from a to b (wall-clock, no zone) */
+export const wallMinutesBetween = (a: Wall, b: Wall) => wallMinutes(b) - wallMinutes(a);
 
 export function isValidTimeZone(tz: string): boolean {
   if (!tz) return false;
@@ -122,8 +125,27 @@ export interface Occurrence {
   key: string;
   // the whole event is cancelled, or just this date
   cancelled: boolean;
-  // the rooms this date holds (Resource ids; the event's roomHold.resourceIds)
+  // the rooms this date holds (Resource ids: the event's roomHold.resourceIds,
+  // or a moved date's own)
   roomIds: string[];
+  // this date was moved here (CalEvent.movedDates): where it was, and why
+  moved?: OccurrenceMove;
+}
+
+export interface OccurrenceMove {
+  /** the date's original start and end (UTC ms) */
+  from: { start: number; end: number };
+  /** staff's public note ('' for none) */
+  note: string;
+  /** the date's own place, when it moved somewhere else */
+  location?: EventLocation;
+}
+
+/** Every room an event may hold: its own and any a moved date holds instead. */
+export function eventRoomIds(e: Pick<CalEvent, 'roomHold' | 'movedDates'>): string[] {
+  const ids = new Set(e.roomHold?.resourceIds ?? []);
+  for (const m of Object.values(e.movedDates ?? {})) for (const id of m.roomIds ?? []) ids.add(id);
+  return [...ids];
 }
 
 /**
@@ -148,14 +170,73 @@ export function expandEvents(events: CalEvent[], settings: Pick<Settings, 'timez
     if (!v) continue;
     // ?? []: editor previews pass unsaved events that may lack the field
     const cancelledDates = new Set(e.cancelledDates ?? []);
+    const moved = movedEntries(e);
     for (const o of expandVEvents([v], tz, win, 0)) {
       const key = occurrenceKey(e, o.start, settings, win.displayTz);
+      // a moved date comes out at its new time below
+      if (moved.has(key)) continue;
       out.push({ event: e, start: o.start, end: o.end, allDay: o.allDay, days: o.days, key, cancelled: e.cancelled || cancelledDates.has(key), roomIds: e.roomHold?.resourceIds ?? [] });
     }
+    for (const [key, m] of moved) {
+      const at = movedInstants(e, m, settings, win.displayTz);
+      if (!at || at.end <= win.windowStartMs || at.start >= win.windowEndMs) continue;
+      const o = movedOccurrence(e, key, m, settings, win.displayTz);
+      if (o) out.push(o);
+    }
   }
   return out.sort((a, b) => a.start - b.start || a.event.title.localeCompare(b.event.title));
 }
 
+// ---- moved dates ---------------------------------------------------------
+// A moved date (CalEvent.movedDates) keeps its original key; it comes out at
+// its new time, in its own rooms (and place) when it has them, with `moved`
+// saying where it was. Keys that no longer match a date of the series (it
+// was retimed or its rule changed) are ignored, like stale cancelled keys,
+// and a key that is also cancelled stays cancelled at its original time.
+
+// the moves that count: not on a cancelled date
+function movedEntries(e: Pick<CalEvent, 'movedDates' | 'cancelledDates'>): Map<string, MovedDate> {
+  const out = new Map<string, MovedDate>();
+  const cancelled = new Set(e.cancelledDates ?? []);
+  for (const [key, m] of Object.entries(e.movedDates ?? {})) if (!cancelled.has(key)) out.set(key, m);
+  return out;
+}
+
+/** A moved date's new instants (all-day: midnight in the display zone, as the expander places them), or null when unusable. */
+export function movedInstants(e: Pick<CalEvent, 'allDay' | 'timezone'>, m: Pick<MovedDate, 'start' | 'end'>, settings: Pick<Settings, 'timezone'>, displayTz = settings.timezone || 'UTC'): { start: number; end: number; days: number } | null {
+  const s = parseWall(m.start);
+  if (!s || s.dateOnly !== e.allDay) return null;
+  const en = parseWall(m.end) ?? s;
+  if (e.allDay) {
+    const days = Math.max(1, Math.round((wallMinutes({ ...en, hh: 0, mm: 0 }) - wallMinutes(s)) / 1440) + 1);
+    const start = zonedToUtc(s.y, s.m, s.d, 0, 0, 0, displayTz || 'UTC');
+    return { start, end: start + days * DAY, days };
+  }
+  const tz = eventTimeZone(e, settings);
+  const start = wallToMs(s, tz), end = wallToMs(en, tz);
+  return end > start ? { start, end, days: 1 } : null;
+}
+
+// the date as the series alone makes it (no move), or null when it isn't one
+function seriesOccurrence(e: CalEvent, key: string, settings: Pick<Settings, 'timezone'>, displayTz: string): Occurrence | null {
+  const w = parseWall(key);
+  if (!w || w.dateOnly !== e.allDay) return null;
+  const at = e.allDay ? zonedToUtc(w.y, w.m, w.d, 0, 0, 0, displayTz || 'UTC') : wallToMs(w, eventTimeZone(e, settings));
+  return expandEvents([{ ...e, movedDates: {} }], settings, { displayTz, now: at, windowStartMs: at - DAY, windowEndMs: at + DAY })
+    .find((o) => o.key === key && o.start === at) ?? null;
+}
+
+function movedOccurrence(e: CalEvent, key: string, m: MovedDate, settings: Pick<Settings, 'timezone'>, displayTz: string): Occurrence | null {
+  const at = movedInstants(e, m, settings, displayTz);
+  const was = at && seriesOccurrence(e, key, settings, displayTz);
+  if (!at || !was) return null;
+  return {
+    event: e, start: at.start, end: at.end, allDay: e.allDay, days: at.days, key, cancelled: e.cancelled,
+    roomIds: m.roomIds ?? e.roomHold?.resourceIds ?? [],
+    moved: { from: { start: was.start, end: was.end }, note: m.note ?? '', ...(m.location ? { location: m.location } : {}) },
+  };
+}
+
 // 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
@@ -168,18 +249,17 @@ export function rsvpDeadline(o: Pick<Occurrence, 'event' | 'start' | 'end'>, set
 }
 
 // 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)
+// such date: never generated, skipped by exdates, or the series moved). A
+// moved date comes back at its new time.
 export function findOccurrence(e: CalEvent, key: string, settings: Pick<Settings, 'timezone'>, displayTz = settings.timezone || 'UTC'): Occurrence | null {
-  const w = parseWall(key);
-  if (!w || w.dateOnly !== e.allDay) return null;
-  const at = e.allDay ? zonedToUtc(w.y, w.m, w.d, 0, 0, 0, displayTz || 'UTC') : wallToMs(w, eventTimeZone(e, settings));
-  return expandEvents([e], settings, { displayTz, now: at, windowStartMs: at - DAY, windowEndMs: at + DAY })
-    .find((o) => o.key === key && o.start === at) ?? null;
+  const m = movedEntries(e).get(key);
+  return m ? movedOccurrence(e, key, m, settings, displayTz) : seriesOccurrence(e, key, settings, displayTz);
 }
 
 // The occurrence to feature for an event: the next one that hasn't ended,
 // else the most recent. `on` ('YYYY-MM-DD') picks a specific day's instance
-// (links from the calendar grid carry it).
+// (links from the calendar grid carry it); a moved date answers both its new
+// day and the day it was moved from.
 export function featuredOccurrence(e: CalEvent, settings: Pick<Settings, 'timezone'>, now: number, on?: string): Occurrence | null {
   const tz = eventTimeZone(e, settings);
   const displayTz = settings.timezone || 'UTC';
@@ -190,6 +270,11 @@ export function featuredOccurrence(e: CalEvent, settings: Pick<Settings, 'timezo
       const hit = expandEvents([e], settings, { displayTz, now, windowStartMs: from, windowEndMs: from + DAY })
         .find((o) => o.start >= from - DAY);
       if (hit) return hit;
+      for (const [key, m] of movedEntries(e)) {
+        if (key.slice(0, 10) !== on) continue;
+        const o = movedOccurrence(e, key, m, settings, displayTz);
+        if (o) return o;
+      }
     }
   }
   if (!e.rrule) {

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, {