@acms-subir/core 0.3.47 → 0.3.48

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[] {

package/src/lib/calendar/moves.ts

@@ -0,0 +1,291 @@
+// Moved dates (CalEvent.movedDates): one date of a repeating event at another
+// time, and maybe in other rooms or at another place, keeping what makes it
+// that date: its key, its RSVPs (they move with it, and people get the "new
+// time" email in their language with their cancel link), its hosts and its
+// page. Moving and moving back apply at once, even on a published event, and
+// leave staged edits alone, like cancelling a date. A date is moved or
+// cancelled, never both: cancelling a moved date drops the move.
+//
+// These check who is acting, so the admin, the built-in member pages and a
+// site's own code (@acms-subir/core/server) share the rules:
+// - staff ("Create and edit content") and GOOGLE_SYNC (a calendar sync acting
+//   with staff rights) may move any date. A room taken at the new time is
+//   returned as a warning, since the change may already have happened
+//   elsewhere;
+// - a host of the event may move its dates while the rooms are free; a taken
+//   room refuses the move (409), and staff are emailed about each host move.
+// `quiet` skips the app notice and the staff email (a sync catching up); the
+// RSVP emails always go, because those people's own booking changed.
+import type { ContentRepository } from '../repo/types';
+import { EventLocation, type CalEvent, type MovedDate } from '../schema';
+import { ApiError } from '../api';
+import { eventSideEffects, type SaveHooks } from '../content-service';
+import { addWallDays, addWallMinutes, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence } from './events';
+import { holdsFromEvents, roomBusy, type BusySlot } from '../booking/holds';
+import { kickEmail } from '../email/service';
+import { waitUntilFrom } from '../webhooks';
+import { MEMBERS } from './members-config';
+import { siteLocale } from '../dates';
+
+/** The actor for a calendar sync (e.g. Google): staff rights, room clashes only warn. */
+export const GOOGLE_SYNC = 'google-sync';
+/** Who is acting: a person (currentUser() from @acms-subir/core/server fits) or the sync. */
+export type MoveActor = { id: string; can(permission: string): boolean } | typeof GOOGLE_SYNC;
+
+export interface MoveInput {
+  /** the new start, wall-clock in the event's timezone: YYYY-MM-DDTHH:mm, or YYYY-MM-DD for an all-day event */
+  start: string;
+  /** the new end in the same form (all-day: the last day, inclusive); default: the date keeps its length */
+  end?: string;
+  /** the rooms that date holds instead (Resource ids); omit to keep its current rooms */
+  roomIds?: string[];
+  /** that date's place instead; null = the event's place again; omit to keep its current one */
+  location?: Partial<EventLocation> | null;
+  /** a public note shown with the date ("Moved for the youth retreat"); omit to keep the current one */
+  note?: string;
+}
+export interface MoveOptions {
+  /** no app notice and no staff email (a sync catching up); RSVP emails still go */
+  quiet?: boolean;
+  now?: number;
+}
+export interface MoveResult {
+  event: CalEvent;
+  /** what else takes the date's rooms at its new time (warnings for staff; hosts are refused instead) */
+  clashes: BusySlot[];
+  /** false: the date already was exactly so, and nothing was written, sent or emailed */
+  changed: boolean;
+}
+
+/**
+ * Why a move was refused (error.code, with error.status): one-off (not a
+ * repeating event), cancelled-event, not-a-date (the key isn't one of its
+ * dates), cancelled-date, started (the date has started or passed),
+ * original-passed (moving back to a time that has passed), past (the new time
+ * has passed), bad-time, room-taken (a host, 409).
+ */
+export type MoveRefusal = 'one-off' | 'cancelled-event' | 'not-a-date' | 'cancelled-date' | 'started' | 'original-passed' | 'past' | 'bad-time' | 'room-taken';
+const refuse = (status: number, code: MoveRefusal, message: string) => Object.assign(new ApiError(status, message), { code });
+
+const DAY = 86_400_000;
+const NOTE_MAX = 500;
+
+type Role = 'staff' | 'host';
+function roleOf(actor: MoveActor | null, e: CalEvent): Role {
+  if (actor === GOOGLE_SYNC) return 'staff';
+  if (!actor) throw new ApiError(401, 'Sign in to continue.');
+  if (actor.can('content.edit')) return 'staff';
+  if (e.hostIds.includes(actor.id)) return 'host';
+  throw new ApiError(404, 'Event not found.');
+}
+const actorId = (actor: MoveActor) => (actor === GOOGLE_SYNC ? GOOGLE_SYNC : actor.id);
+
+async function load(repo: ContentRepository, id: string) {
+  const e = await repo.getEvent(id);
+  if (!e || e.status === 'archived') throw new ApiError(404, 'Event not found.');
+  return e;
+}
+
+// the date as it is now (moved or not), checked for moving (`started` waits: an unchanged move is a no-op even then)
+function dateToChange(e: CalEvent, key: string, settings: { timezone: string }): Occurrence {
+  if (!e.rrule) throw refuse(400, 'one-off', 'Only a repeating event has single dates to move. Change the event’s time instead.');
+  if (e.cancelled) throw refuse(409, 'cancelled-event', 'This event is cancelled.');
+  if (typeof key !== 'string' || key.length > 20) throw refuse(400, 'not-a-date', 'That date isn’t part of this event.');
+  if (e.cancelledDates.includes(key)) throw refuse(409, 'cancelled-date', 'That date is cancelled. Restore it before moving it.');
+  const o = findOccurrence(e, key, settings);
+  if (!o) throw refuse(400, 'not-a-date', 'That date isn’t part of this event.');
+  return o;
+}
+const started = () => refuse(400, 'started', 'That date has already started or passed.');
+
+// The new wall times: `start` in the event's form, `end` defaulting to the
+// date's own length (all-day: the same number of days)
+function newTimes(e: CalEvent, input: MoveInput): { start: string; end: string } {
+  const s = parseWall(input.start);
+  if (!s) throw refuse(400, 'bad-time', e.allDay ? 'Pick a date (YYYY-MM-DD).' : 'Pick a date and time (YYYY-MM-DDTHH:mm).');
+  if (s.dateOnly !== e.allDay) throw refuse(400, 'bad-time', e.allDay ? 'This event lasts all day: give a date only (YYYY-MM-DD).' : 'Give a date and a time (YYYY-MM-DDTHH:mm).');
+  let end = input.end;
+  if (!end) {
+    const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
+    const length = es && ee ? wallMinutesBetween(es, ee) : 60;
+    end = formatWall(e.allDay ? addWallDays(s, Math.round(length / 1440)) : addWallMinutes(s, Math.max(1, length)));
+  }
+  try {
+    return normalizeEventTimes({ start: input.start, end, allDay: e.allDay });
+  } catch (err) {
+    throw refuse(400, 'bad-time', err instanceof Error ? err.message : 'Pick a valid time.');
+  }
+}
+
+// what else takes the rooms this date would hold at its new time (setup and
+// cleanup, or the whole day, as the event holds them)
+async function clashesFor(repo: ContentRepository, next: CalEvent, key: string, at: { start: number; end: number }, settings: { timezone: string }): Promise<BusySlot[]> {
+  const resources = new Map((await repo.listResources()).map((r) => [r.id, r]));
+  const holds = holdsFromEvents([next], resources, settings, at.start - 2 * DAY, at.end + 2 * DAY, { force: true }).filter((h) => h.key === key);
+  const seen = new Set<string>();
+  const out: BusySlot[] = [];
+  for (const h of holds) {
+    for (const b of await roomBusy(repo, settings, { resourceIds: [h.resourceId], from: h.start, to: h.end, ignore: { eventId: next.id, key } })) {
+      const id = `${b.resourceId}:${b.kind}:${b.bookingId ?? `${b.eventId}:${b.key}`}:${b.start}`;
+      if (!seen.has(id)) { seen.add(id); out.push(b); }
+    }
+  }
+  return out.sort((a, b) => a.start - b.start);
+}
+
+async function refuseForHost(repo: ContentRepository, clashes: BusySlot[]) {
+  const names = new Map((await repo.listResources()).map((r) => [r.id, r.name]));
+  const rooms = [...new Set(clashes.map((c) => names.get(c.resourceId) ?? 'The room'))];
+  const list = rooms.length > 1 ? `${rooms.slice(0, -1).join(', ')} and ${rooms[rooms.length - 1]}` : rooms[0];
+  throw refuse(409, 'room-taken', `${list} ${rooms.length > 1 ? 'are' : 'is'} taken at that time. Pick another time${rooms.length ? ' or room' : ''}, or ask the team.`);
+}
+
+const sameRooms = (a: string[] | undefined, b: string[]) => a !== undefined && a.length === b.length && a.every((x, i) => x === b[i]);
+// the same move, whoever made it and when
+const sameMove = (a: MovedDate, b: MovedDate) => a.start === b.start && a.end === b.end && a.note === b.note
+  && JSON.stringify(a.roomIds ?? null) === JSON.stringify(b.roomIds ?? null) && JSON.stringify(a.location ?? null) === JSON.stringify(b.location ?? null);
+
+/**
+ * Move one date of a repeating event to a new time (and maybe other rooms or
+ * another place). Moving an already moved date replaces its move; moving it
+ * back to exactly where it was is moveOccurrenceBack. Moving it to where it
+ * already is changes nothing (`changed: false`): retries never email twice.
+ */
+export async function moveOccurrence(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, input: MoveInput, hooks: SaveHooks, opts: MoveOptions = {}): Promise<MoveResult> {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  const role = roleOf(actor, e);
+  const settings = await repo.getSettings();
+  const current = dateToChange(e, key, settings);
+  const prior = e.movedDates[key];
+  const times = newTimes(e, input);
+
+  let roomIds = input.roomIds === undefined ? prior?.roomIds : [...new Set(input.roomIds)];
+  if (roomIds !== undefined) {
+    const known = new Set((await repo.listResources()).map((r) => r.id));
+    roomIds = roomIds.filter((r) => known.has(r));
+    // the event's own rooms aren't an override
+    if (sameRooms(roomIds, e.roomHold.resourceIds)) roomIds = undefined;
+  }
+  let location = input.location === undefined ? prior?.location : input.location === null ? undefined : EventLocation.parse({ ...e.location, ...input.location });
+  if (location && !location.name.trim() && !location.address.trim()) throw new ApiError(400, 'Give the place a name or an address.');
+  if (location && JSON.stringify(location) === JSON.stringify(e.location)) location = undefined;
+  const note = input.note === undefined ? prior?.note ?? '' : String(input.note).replace(/\s+/g, ' ').trim().slice(0, NOTE_MAX);
+
+  const entry: MovedDate = { start: times.start, end: times.end, ...(roomIds ? { roomIds } : {}), ...(location ? { location } : {}), note, by: actorId(actor!), at: now };
+  if (prior && sameMove(prior, entry)) return { event: e, clashes: [], changed: false };
+  const at = movedInstants(e, entry, settings);
+  if (!at) throw refuse(400, 'bad-time', 'Pick a valid time.');
+
+  // back where the series puts it, with nothing else different: that's moving it back
+  const series = findOccurrence({ ...e, movedDates: {} }, key, settings)!;
+  if (at.start === series.start && at.end === series.end && !roomIds && !location) return moveOccurrenceBack(repo, actor, id, key, hooks, opts);
+  if (current.start <= now) throw started();
+  if (at.start <= now) throw refuse(400, 'past', 'Pick a time that hasn’t passed yet.');
+
+  const next: CalEvent = { ...e, movedDates: { ...e.movedDates, [key]: entry } };
+  const clashes = await clashesFor(repo, next, key, at, settings);
+  if (clashes.length && role === 'host') await refuseForHost(repo, clashes);
+
+  await repo.setEventMovedDates(id, next.movedDates, undefined, { quiet: opts.quiet });
+  const after = (await repo.getEvent(id))!;
+  const moved = findOccurrence(after, key, settings)!;
+  await afterChange(repo, after, current, moved, { role, actor: actor!, note, hooks, opts, settings });
+  return { event: after, clashes, changed: true };
+}
+
+/** Put a moved date back where the series has it (idempotent: a date that isn't moved is `changed: false`). Hosts are refused if its rooms are taken there now. */
+export async function moveOccurrenceBack(repo: ContentRepository, actor: MoveActor | null, id: string, key: string, hooks: SaveHooks, opts: MoveOptions = {}): Promise<MoveResult> {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  const role = roleOf(actor, e);
+  if (!Object.hasOwn(e.movedDates, key)) return { event: e, clashes: [], changed: false };
+  const settings = await repo.getSettings();
+  const { [key]: _gone, ...rest } = e.movedDates;
+  const next: CalEvent = { ...e, movedDates: rest };
+  const current = findOccurrence(e, key, settings);
+  const back = findOccurrence(next, key, settings);
+  // a key the series no longer has (it was retimed): nothing to put back, just forget it
+  if (current && back) {
+    if (current.start <= now) throw started();
+    if (back.start <= now) throw refuse(400, 'original-passed', 'Its original time has already passed.');
+  }
+  const clashes = back ? await clashesFor(repo, next, key, back, settings) : [];
+  if (clashes.length && role === 'host') await refuseForHost(repo, clashes);
+  await repo.setEventMovedDates(id, rest, undefined, { quiet: opts.quiet });
+  const after = (await repo.getEvent(id))!;
+  if (current && back) await afterChange(repo, after, current, back, { role, actor: actor!, note: '', hooks, opts, settings });
+  else await eventSideEffects(repo, hooks, after);
+  return { event: after, clashes, changed: true };
+}
+
+// RSVPs follow the date (emailed when its time changed), then the usual side
+// effects (webhook; the app notice unless the write was quiet), then staff hear about a host's move
+async function afterChange(repo: ContentRepository, after: CalEvent, from: Occurrence, to: Occurrence,
+  c: { role: Role; actor: MoveActor; note: string; hooks: SaveHooks; opts: MoveOptions; settings: Awaited<ReturnType<ContentRepository['getSettings']>> }) {
+  if ((from.start !== to.start || from.end !== to.end) && await repo.moveOccurrenceRsvps(after.id, from.start, { start: to.start, end: to.end }, c.note)) {
+    await kickEmail(repo, c.hooks.locals, waitUntilFrom(c.hooks.locals));
+  }
+  await eventSideEffects(repo, c.hooks, after);
+  if (c.role === 'host' && !c.opts.quiet && c.actor !== GOOGLE_SYNC) await notifyStaffOfMove(repo, after, from, to, c.actor.id, c.note, c.settings, c.hooks);
+}
+
+// "Date moved" to members.notify (else the owners), like members' requests
+async function notifyStaffOfMove(repo: ContentRepository, e: CalEvent, from: Occurrence, to: Occurrence, by: string, note: string,
+  settings: Awaited<ReturnType<ContentRepository['getSettings']>>, hooks: SaveHooks) {
+  const recipients = MEMBERS.notify.length ? MEMBERS.notify : (await repo.listUsers()).filter((u) => u.role === 'owner' && u.email).map((u) => u.email);
+  if (!recipients.length) return;
+  const tz = e.allDay ? settings.timezone || 'UTC' : eventTimeZone(e, settings);
+  const fmt = (o: Occurrence) => {
+    try { return new Intl.DateTimeFormat(siteLocale(settings), e.allDay ? { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz } : { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZone: tz }).format(o.start); }
+    catch { return new Date(o.start).toISOString(); }
+  };
+  const version = (await repo.email.config().catch(() => null))?.version ?? 0;
+  const at = Date.now();
+  for (const recipient of recipients) {
+    await repo.email.enqueue({ dedupe: `event-move:${e.id}:${from.key}:${at}:${recipient}`, kind: 'event-request', recipient,
+      payload: JSON.stringify({ eventId: e.id, kind: 'staff-moved', at, reply: '', by, note, when: `${fmt(from)} → ${fmt(to)}` }), configVersion: version, expiresAt: at + 7 * DAY });
+  }
+  await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals)).catch(() => {});
+}
+
+/** One upcoming date for the editor's Dates panel: its key, wall times (for the move form), words, and state. */
+export interface DateRow {
+  key: string;
+  /** where it is now, wall-clock in the event's zone (a moved date: its new time) */
+  start: string;
+  end: string;
+  /** "Thu, Jan 10 · 6:00 – 7:00 PM" */
+  when: string;
+  cancelled: boolean;
+  /** moved: "Thu, Jan 10 · 6:00 PM" (where it was) and the note */
+  moved: { from: string; note: string } | null;
+  roomIds: string[];
+}
+
+/** The next `limit` dates of a series from `now`, moved and cancelled ones included. */
+export function upcomingDates(e: CalEvent, settings: Awaited<ReturnType<ContentRepository['getSettings']>>, limit: number, now = Date.now()): DateRow[] {
+  if (!e.rrule) return [];
+  const tz = e.allDay ? settings.timezone || 'UTC' : eventTimeZone(e, settings);
+  const locale = siteLocale(settings);
+  const day = new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz });
+  const time = new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', timeZone: tz });
+  const range = (a: number, b: number) => { try { return time.formatRange(a, b); } catch { return `${time.format(a)} – ${time.format(b)}`; } };
+  const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
+  const length = es && ee ? wallMinutesBetween(es, ee) : 60;
+  return expandEvents([e], settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: now, windowEndMs: now + 400 * DAY })
+    .slice(0, limit)
+    .map((o) => {
+      const m = o.moved ? e.movedDates[o.key] : undefined;
+      const k = parseWall(o.key)!;
+      return {
+        key: o.key,
+        start: m?.start ?? o.key,
+        end: m?.end ?? formatWall(e.allDay ? addWallDays(k, Math.round(length / 1440)) : addWallMinutes(k, length)),
+        when: e.allDay ? day.format(o.start) : `${day.format(o.start)} · ${range(o.start, o.end)}`,
+        cancelled: o.cancelled,
+        moved: o.moved ? { from: e.allDay ? day.format(o.moved.from.start) : `${day.format(o.moved.from.start)} · ${time.format(o.moved.from.start)}`, note: o.moved.note } : null,
+        roomIds: o.roomIds,
+      };
+    });
+}

package/src/lib/calendar/render.ts

@@ -12,6 +12,7 @@ import { getCalendarEvents, tzParts, zonedToUtc } from './ics';
 import { calendarPageUrl } from './src';
 import { collectViewEvents, type ViewEvent } from './data';
 import { eventStrings, type EventStrings } from './event-words';
+import { fill } from '../live/words';
 
 // Card sources are ICS feed URLs or native site calendars:
 //   'acms:all'         every public calendar (+ uncategorized events)
@@ -58,6 +59,7 @@ interface DisplayEvent {
   u?: string; // native events: the event page
   k?: string; // calendar color (#rrggbb), overrides the indexed dot color
   x?: 1; // cancelled
+  mv?: string; // a moved date: "Moved from Thu, Jan 10 · 6:00 PM."
 }
 
 function compactTime(s: string): string {
@@ -65,7 +67,8 @@ function compactTime(s: string): string {
 }
 
 function buildDisplay(events: ViewEvent[], tz: string, locale: string): DisplayEvent[] {
-  const allDay = eventStrings(locale).allDay;
+  const ew = eventStrings(locale);
+  const allDay = ew.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) => {
@@ -85,6 +88,7 @@ function buildDisplay(events: ViewEvent[], tz: string, locale: string): DisplayE
       ...(e.url ? { u: e.url } : {}),
       ...(e.color && /^#[0-9a-f]{6}$/i.test(e.color) ? { k: e.color } : {}),
       ...(e.cancelled ? { x: 1 as const } : {}),
+      ...(e.moved && !e.cancelled ? { mv: fill(ew.dateMoved, { from: e.allDay ? dayFmt.format(e.moved.from.start) : `${dayFmt.format(e.moved.from.start)} · ${timeFmt.format(e.moved.from.start)}` }) } : {}),
     };
   });
 }
@@ -105,7 +109,7 @@ function indexByDay(events: DisplayEvent[]): Map<number, number[]> {
 
 const dotStyle = (e: DisplayEvent) => (e.k ? ` style="--cal-dot:${e.k}"` : '');
 const chipHtml = (e: DisplayEvent, i: number) =>
-  `<button type="button" class="pc-cal-event${e.x ? ' is-cancelled' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="t">${esc(e.tm)}</span><b>${esc(e.t)}</b></button>`;
+  `<button type="button" class="pc-cal-event${e.x ? ' is-cancelled' : ''}${e.mv ? ' is-moved' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="t">${esc(e.tm)}</span><b>${esc(e.t)}</b></button>`;
 
 function monthGridHtml(y: number, m: number, todayN: number, byDay: Map<number, number[]>, events: DisplayEvent[], dows: string[], monthsShort: string[], ws: number): string {
   const first = dayNum(y, m, 1);
@@ -137,7 +141,7 @@ function upcomingHtml(events: DisplayEvent[], order: number[], limit: number, w:
   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) || esc(w.allDay)}</span></button></li>`;
+    return `<li><button type="button" class="pc-cal-row${e.x ? ' is-cancelled' : ''}${e.mv ? ' is-moved' : ''}" 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>`;
 }
@@ -154,7 +158,7 @@ function fday(n){var d=new Date(n*D);return[d.getUTCFullYear(),d.getUTCMonth()+1
 function dow(n){return((n+4-(P.ws||0))%7+7)%7}
 var byDay={};P.events.forEach(function(e,i){var n0=dnum(e.d);for(var k=0;k<Math.min(e.n,60);k++){(byDay[n0+k]=byDay[n0+k]||[]).push(i)}});
 function esc(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;')}
-function chip(i){var e=P.events[i];return '<button type="button" class="pc-cal-event'+(e.x?' is-cancelled':'')+'" data-ev="'+i+'" data-cal="'+e.c+'"'+(e.k?' style="--cal-dot:'+e.k+'"':'')+'><span class="t">'+esc(e.tm)+'</span><b>'+esc(e.t)+'</b></button>'}
+function chip(i){var e=P.events[i];return '<button type="button" class="pc-cal-event'+(e.x?' is-cancelled':'')+(e.mv?' is-moved':'')+'" data-ev="'+i+'" data-cal="'+e.c+'"'+(e.k?' style="--cal-dot:'+e.k+'"':'')+'><span class="t">'+esc(e.tm)+'</span><b>'+esc(e.t)+'</b></button>'}
 function chips(n){return(byDay[n]||[]).map(chip).join('')}
 var todayN=dnum(P.today),mY=P.month[0],mM=P.month[1],weekN=todayN-dow(todayN);
 function renderMonth(){
@@ -190,7 +194,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="'+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>':'');
+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>':'')+(e.mv?'<span class="pc-cal-pop-flag is-moved">'+esc(P.moved)+'</span>':'')+'<strong class="pc-cal-pop-title">'+esc(e.t)+'</strong><div class="pc-cal-pop-when">'+esc(e.rg)+'</div>'+(e.mv?'<div class="pc-cal-pop-moved">'+esc(e.mv)+'</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';
@@ -295,7 +299,7 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     max: [maxY, maxM],
     months, monthsShort, dows, events, ws,
     // the pop-up's words in the dates' language, like event cards
-    details: w.calendar.details, cancelled: w.cancelled, close: w.calendar.close,
+    details: w.calendar.details, cancelled: w.cancelled, close: w.calendar.close, moved: w.moved,
   };
   const json = JSON.stringify(payload).replace(/</g, '\\u003c');