@acms-subir/core 0.3.47 → 0.3.49

package/src/lib/calendar/change-migration.ts

@@ -13,27 +13,45 @@
 // but never member pushes (its first publishes are recorded as skipped, like
 // restores). Posts keep their v37 triggers.
 //
-// Frozen with v65: a later events column joins by a new migration that
-// recreates these triggers (the test that sorts every column fails until then).
+// Each migration's column lists are frozen: a later events column joins by a
+// new migration that recreates these triggers through eventChangeTriggers()
+// (the test that sorts every column fails until then). v66 added moved_dates.
 const now = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
 
-/** the columns copied into each snapshot (what the webhook payload and push rules read) */
-export const EVENT_CHANGE_SNAPSHOT = ['id', 'slug', 'title', 'excerpt', 'cover', 'cover_alt', 'status', 'featured', 'tags',
+// v65's lists
+const V65_SNAPSHOT = ['id', 'slug', 'title', 'excerpt', 'cover', 'cover_alt', 'status', 'featured', 'tags',
   'starts', 'ends', 'all_day', 'timezone', 'rrule', 'exdates', 'cancelled', 'cancelled_dates', 'location', 'cta', 'calendar_ids',
   'fields', 'rsvp', 'room_hold', 'start_at', 'end_at', 'published_at', 'scheduled_at', 'created_at', 'updated_at'];
-/** the columns whose change counts (published_at and scheduled_at follow status; room_hold names the rooms public data shows) */
-export const EVENT_CHANGE_COLUMNS = ['slug', 'title', 'body_json', 'body_html', 'excerpt', 'cover', 'cover_alt', 'seo_title', 'seo_desc',
+const V65_COLUMNS = ['slug', 'title', 'body_json', 'body_html', 'excerpt', 'cover', 'cover_alt', 'seo_title', 'seo_desc',
   'status', 'featured', 'tags', 'template', 'starts', 'ends', 'all_day', 'timezone', 'rrule', 'exdates', 'cancelled', 'cancelled_dates',
   'location', 'cta', 'calendar_ids', 'fields', 'rsvp', 'translations', 'room_hold', 'start_at', 'end_at'];
+
+/** the columns copied into each snapshot (what the webhook payload and push rules read) */
+export const EVENT_CHANGE_SNAPSHOT = [...V65_SNAPSHOT, 'moved_dates'];
+/** the columns whose change counts (published_at and scheduled_at follow status; room_hold names the rooms public data shows) */
+export const EVENT_CHANGE_COLUMNS = [...V65_COLUMNS, 'moved_dates'];
 /** columns no change is recorded for */
 export const EVENT_CHANGE_IGNORED = ['id', 'draft', 'host_ids', 'request', 'source_uid', 'published_at', 'scheduled_at', 'created_at', 'updated_at'];
 
-const snapshot = (row: 'OLD' | 'NEW') => `json_object(${EVENT_CHANGE_SNAPSHOT.map((c) => `'${c}',${row}.${c}`).join(',')})`;
+const snapshotOf = (cols: string[], row: 'OLD' | 'NEW') => `json_object(${cols.map((c) => `'${c}',${row}.${c}`).join(',')})`;
 const live = '(SELECT suppressed FROM webhook_control WHERE id=1)=0';
 const quiet = 'COALESCE((SELECT quiet FROM push_control WHERE id=1),0)';
 const record = (id: string, before: string, after: string) => `INSERT INTO event_changes (event_id,old_row,new_row,quiet,created_at)
   VALUES (${id},${before},${after},${quiet},${now});`;
-const changed = EVENT_CHANGE_COLUMNS.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(' OR ');
+
+/** The three event_changes triggers, for one migration's frozen lists (drop the old ones first when recreating). */
+export function eventChangeTriggers(snapshotCols: string[], changedCols: string[]): string[] {
+  const changed = changedCols.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(' OR ');
+  return [
+    `CREATE TRIGGER event_changes_insert AFTER INSERT ON events WHEN NEW.status='published' AND ${live}
+    BEGIN ${record('NEW.id', 'NULL', snapshotOf(snapshotCols, 'NEW'))} END`,
+    `CREATE TRIGGER event_changes_update AFTER UPDATE ON events
+    WHEN (OLD.status='published' OR NEW.status='published') AND (${changed}) AND ${live}
+    BEGIN ${record('NEW.id', snapshotOf(snapshotCols, 'OLD'), snapshotOf(snapshotCols, 'NEW'))} END`,
+    `CREATE TRIGGER event_changes_delete AFTER DELETE ON events WHEN OLD.status='published' AND ${live}
+    BEGIN ${record('OLD.id', snapshotOf(snapshotCols, 'OLD'), 'NULL')} END`,
+  ];
+}
 
 // v37's first-publish ledger rows, now also skipped while push_control.quiet is set
 const skipped = `CASE WHEN (SELECT suppressed FROM webhook_control WHERE id=1)=1 OR ${quiet}=1 THEN 'skipped' ELSE 'pending' END`;
@@ -50,16 +68,23 @@ export const EVENT_CHANGES_MIGRATION = { version: 65, statements: [
   `CREATE INDEX event_changes_event ON event_changes (event_id, claimed_until)`,
   `CREATE TABLE push_control (id INTEGER PRIMARY KEY CHECK(id=1), quiet INTEGER NOT NULL DEFAULT 0)`,
   `INSERT INTO push_control (id,quiet) VALUES (1,0)`,
-  `CREATE TRIGGER event_changes_insert AFTER INSERT ON events WHEN NEW.status='published' AND ${live}
-    BEGIN ${record('NEW.id', 'NULL', snapshot('NEW'))} END`,
-  `CREATE TRIGGER event_changes_update AFTER UPDATE ON events
-    WHEN (OLD.status='published' OR NEW.status='published') AND (${changed}) AND ${live}
-    BEGIN ${record('NEW.id', snapshot('OLD'), snapshot('NEW'))} END`,
-  `CREATE TRIGGER event_changes_delete AFTER DELETE ON events WHEN OLD.status='published' AND ${live}
-    BEGIN ${record('OLD.id', snapshot('OLD'), 'NULL')} END`,
+  ...eventChangeTriggers(V65_SNAPSHOT, V65_COLUMNS),
   `DROP TRIGGER push_event_insert`,
   `DROP TRIGGER push_event_publish`,
   `CREATE TRIGGER push_event_insert AFTER INSERT ON events WHEN NEW.status='published' BEGIN ${ledger} END`,
   `CREATE TRIGGER push_event_publish AFTER UPDATE OF status ON events
       WHEN NEW.status='published' AND OLD.status IS NOT 'published' BEGIN ${ledger} END`,
 ] };
+
+// v66: single dates of a series moved to another time, room or place
+// (CalEvent.movedDates, keyed by the original occurrence key), a column on the
+// row: public, so it bumps the content version and its changes are recorded
+export const MOVED_DATES_MIGRATION = (contentVersionUpdate: string) => ({ version: 66, statements: [
+  `ALTER TABLE events ADD COLUMN moved_dates TEXT NOT NULL DEFAULT '{}'`,
+  `DROP TRIGGER content_version_events_update`,
+  contentVersionUpdate,
+  `DROP TRIGGER event_changes_insert`,
+  `DROP TRIGGER event_changes_update`,
+  `DROP TRIGGER event_changes_delete`,
+  ...eventChangeTriggers([...V65_SNAPSHOT, 'moved_dates'], [...V65_COLUMNS, 'moved_dates']),
+] });

package/src/lib/calendar/data.ts

@@ -4,7 +4,7 @@
 // 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';
@@ -23,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
@@ -89,7 +93,7 @@ export async function collectViewEvents(
     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) }));
@@ -104,7 +108,7 @@ export async function collectViewEvents(
     events.push({
       start: o.start, end: o.end, allDay: o.allDay, days: o.days,
       title: e.title || words.untitled,
-      location: [e.location.name, e.location.address].filter(Boolean).join(', '),
+      location: locationLine(o.moved?.location ?? e.location),
       description: e.excerpt,
       cal: cal ? idx.get(cal.id) ?? 0 : 0,
       ref: e.id,
@@ -116,6 +120,8 @@ export async function collectViewEvents(
       calendarName: cal?.name,
       event: e,
       rooms: rooms(o.roomIds),
+      key: o.key,
+      ...(o.moved ? { moved: o.moved } : {}),
     });
   }
 

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

@@ -18,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;
@@ -130,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',
@@ -162,6 +167,7 @@ const STRINGS: Record<string, EventStrings> = {
   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',
@@ -194,6 +200,7 @@ const STRINGS: Record<string, EventStrings> = {
   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é',
@@ -226,6 +233,7 @@ const STRINGS: Record<string, EventStrings> = {
   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',
@@ -258,6 +266,7 @@ const STRINGS: Record<string, EventStrings> = {
   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',

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/ics-write.ts

@@ -5,7 +5,8 @@
 // across DST — Google, Apple and Outlook all resolve IANA zone ids. All-day
 // events are VALUE=DATE with the RFC's exclusive DTEND. A single cancelled
 // date of a series is an override VEVENT (same UID, RECURRENCE-ID) with
-// STATUS:CANCELLED, so calendar apps strike that one date.
+// STATUS:CANCELLED, so calendar apps strike that one date; a moved date is an
+// override with its new DTSTART/DTEND (and its own place), so they show it there.
 import type { CalEvent, Calendar } from '../schema';
 import { addWallDays, eventInstants, eventTimeZone, findOccurrence, locationLine, parseWall, type Wall } from './events';
 import { zonedToUtc } from './ics';
@@ -103,10 +104,32 @@ export function eventToVevent(e: CalEvent, siteTz: string, opts: FeedOptions): s
   if (e.cancelled) lines.push('STATUS:CANCELLED');
   const stamps = [`LAST-MODIFIED:${utcStamp(e.updatedAt)}`, `SEQUENCE:${Math.max(0, Math.floor((e.updatedAt - e.createdAt) / 1000)) % 2147483647}`];
   lines.push(...stamps, 'END:VEVENT');
-  if (rule && !e.cancelled) lines.push(...cancelledOverrides(e, s, en, tz, siteTz, url, opts, stamps));
+  if (rule && !e.cancelled) lines.push(...cancelledOverrides(e, s, en, tz, siteTz, url, opts, stamps), ...movedOverrides(e, tz, siteTz, url, opts, stamps));
   return lines;
 }
 
+// one override per moved date that is still part of the series (and not
+// cancelled): the same date (RECURRENCE-ID) at its new time
+function movedOverrides(e: CalEvent, tz: string, siteTz: string, url: string, opts: FeedOptions, stamps: string[]): string[] {
+  const out: string[] = [];
+  const cancelled = new Set(e.cancelledDates ?? []);
+  for (const key of Object.keys(e.movedDates ?? {}).sort()) {
+    const m = e.movedDates[key];
+    const w = parseWall(key), ms = parseWall(m.start), me = parseWall(m.end) ?? ms;
+    if (cancelled.has(key) || !w || !ms || !me || !findOccurrence(e, key, { timezone: siteTz }, siteTz || 'UTC')) continue;
+    const when = e.allDay
+      ? [`RECURRENCE-ID;VALUE=DATE:${dateValue(w)}`, `DTSTART;VALUE=DATE:${dateValue(ms)}`, `DTEND;VALUE=DATE:${dateValue(addWallDays({ ...me, dateOnly: true }, 1))}`]
+      : [`RECURRENCE-ID;TZID=${tz}:${localValue(w)}`, `DTSTART;TZID=${tz}:${localValue(ms)}`, `DTEND;TZID=${tz}:${localValue(me)}`];
+    const place = m.location ?? e.location;
+    const loc = locationLine(place);
+    const desc = [m.note, e.excerpt, place.url && place.url !== loc ? place.url : '', url].filter(Boolean).join('\n\n');
+    out.push('BEGIN:VEVENT', `UID:${e.id}@${opts.host}`, `DTSTAMP:${utcStamp(opts.now ?? Date.now())}`, ...when,
+      `SUMMARY:${escapeText(e.title || 'Untitled event')}`, ...(loc ? [`LOCATION:${escapeText(loc)}`] : []),
+      `DESCRIPTION:${escapeText(desc)}`, `URL:${url}`, ...stamps, 'END:VEVENT');
+  }
+  return out;
+}
+
 // one override per cancelled date that is still part of the series (keys
 // left behind by a moved series are ignored)
 function cancelledOverrides(e: CalEvent, s: Wall, en: Wall, tz: string, siteTz: string, url: string, opts: FeedOptions, stamps: string[]): string[] {