@acms-subir/core 0.3.56 → 0.3.57

package/src/lib/calendar/ics-write.ts

@@ -7,8 +7,12 @@
 // date of a series is an override VEVENT (same UID, RECURRENCE-ID) with
 // 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.
+// A series changed from a date on (CalEvent.segments) is one VEVENT per part,
+// the way Google writes "this and following": the event's own rule keeps its
+// UID and stops with an UNTIL just before the change, and each segment is a
+// recurring event of its own (UID `<id>-<from>`), with its own overrides.
 import type { CalEvent, Calendar } from '../schema';
-import { addWallDays, eventInstants, eventTimeZone, findOccurrence, locationLine, parseWall, type Wall } from './events';
+import { addWallDays, cutsAt, eventInstants, eventTimeZone, expandEvents, findOccurrence, locationLine, parseWall, seriesParts, type SeriesPart, type Wall } from './events';
 import { zonedToUtc } from './ics';
 import { cleanRrule, rruleMap } from './rrule';
 
@@ -72,18 +76,64 @@ export interface FeedOptions {
 }
 
 export function eventToVevent(e: CalEvent, siteTz: string, opts: FeedOptions): string[] {
-  const s = parseWall(e.start);
+  const parts = seriesParts(e);
+  if (parts.length === 1) return partVevent(e, e, '', siteTz, opts);
+  return parts.flatMap((p) => {
+    const rule = ruleUntil(e, p, siteTz);
+    // a part whose dates all went to the next one has nothing to say
+    if (rule === null) return [];
+    // its own dates' overrides only: the dates the series puts in this part
+    const mine = (key: string) => (findOccurrence(e, key, { timezone: siteTz }, siteTz || 'UTC')?.segment ?? '') === p.from;
+    const part: CalEvent = { ...e, start: p.start, end: p.end, rrule: rule, cancelled: e.cancelled || p.cancelled, location: p.location ?? e.location, segments: [],
+      cancelledDates: e.cancelledDates.filter(mine), movedDates: Object.fromEntries(Object.entries(e.movedDates).filter(([k]) => mine(k))) };
+    return partVevent(e, part, p.from ? `-${p.from.replace(/[-:]/g, '')}` : '', siteTz, opts);
+  });
+}
+
+// A part's rule for the feed: stopped just before the next part's `from`
+// (RFC 5545 UNTIL is inclusive: the instant before it for timed events, the
+// day before for all-day ones). COUNT becomes that UNTIL when the rule would
+// still have dates there; null when the part has none left before it.
+function ruleUntil(e: CalEvent, p: SeriesPart, siteTz: string): string | null {
+  const clean = cleanRrule(p.rrule);
+  if (!p.until || !clean) return clean;
+  const cut = parseWall(p.until);
+  if (!cut) return clean;
+  const tz = eventTimeZone(e, { timezone: siteTz });
+  const settings = { timezone: siteTz };
+  const solo: CalEvent = { ...e, start: p.start, end: p.end, rrule: clean, segments: [], movedDates: {}, cancelledDates: [] };
+  // parts stop at the day of the next one's `from` (events.ts cutsAt)
+  const cutMs = zonedToUtc(cut.y, cut.m, cut.d, 0, 0, 0, e.allDay ? siteTz || 'UTC' : tz);
+  const first = parseWall(p.start);
+  const startMs = first ? (e.allDay ? zonedToUtc(first.y, first.m, first.d, 0, 0, 0, siteTz || 'UTC') : zonedToUtc(first.y, first.m, first.d, first.hh, first.mm, 0, tz)) : cutMs;
+  if (startMs >= cutMs) return null;
+  // the rule would carry on past the cut (within the next two years): stop it there
+  const later = expandEvents([solo], settings, { displayTz: siteTz || 'UTC', now: cutMs, windowStartMs: cutMs, windowEndMs: cutMs + 800 * 86_400_000 }).some((o) => cutsAt(p.until, o.key));
+  if (!later) return clean;
+  const parts = rruleMap(clean);
+  delete parts.COUNT;
+  if (e.allDay) {
+    const before = addWallDays({ ...cut, dateOnly: true }, -1);
+    parts.UNTIL = `${before.y}${pad(before.m)}${pad(before.d)}`;
+  } else parts.UNTIL = utcStamp(cutMs - 1000);
+  return Object.entries(parts).map(([k, v]) => `${k}=${v}`).join(';');
+}
+
+// one VEVENT (and its date overrides) for an event, or for one part of it
+// (`e` the event as stored, `part` the part as an event of its own)
+function partVevent(e: CalEvent, part: CalEvent, uidSuffix: string, siteTz: string, opts: FeedOptions): string[] {
+  const s = parseWall(part.start);
   if (!s) return [];
-  const en = parseWall(e.end) ?? s;
+  const en = parseWall(part.end) ?? s;
   const tz = eventTimeZone(e, { timezone: siteTz });
-  const rule = feedRrule(e.rrule, e.allDay, tz);
-  const lines: string[] = ['BEGIN:VEVENT', `UID:${e.id}@${opts.host}`, `DTSTAMP:${utcStamp(opts.now ?? Date.now())}`];
+  const rule = feedRrule(part.rrule, e.allDay, tz);
+  const lines: string[] = ['BEGIN:VEVENT', `UID:${e.id}${uidSuffix}@${opts.host}`, `DTSTAMP:${utcStamp(opts.now ?? Date.now())}`];
   if (e.allDay) {
     lines.push(`DTSTART;VALUE=DATE:${dateValue(s)}`, `DTEND;VALUE=DATE:${dateValue(addWallDays({ ...en, dateOnly: true }, 1))}`);
   } else if (rule) {
     lines.push(`DTSTART;TZID=${tz}:${localValue(s)}`, `DTEND;TZID=${tz}:${localValue(en)}`);
   } else {
-    const { startAt, endAt } = eventInstants(e, tz);
+    const { startAt, endAt } = eventInstants(part, tz);
     lines.push(`DTSTART:${utcStamp(startAt)}`, `DTEND:${utcStamp(endAt)}`);
   }
   if (rule) lines.push(`RRULE:${rule}`);
@@ -93,24 +143,24 @@ export function eventToVevent(e: CalEvent, siteTz: string, opts: FeedOptions): s
   }
   const url = opts.origin + opts.eventUrl(e);
   lines.push(`SUMMARY:${escapeText(e.title || 'Untitled event')}`);
-  const loc = locationLine(e.location);
+  const loc = locationLine(part.location);
   if (loc) lines.push(`LOCATION:${escapeText(loc)}`);
   // RFC 5545 GEO: latitude;longitude
-  if (typeof e.location.lat === 'number' && typeof e.location.lng === 'number') lines.push(`GEO:${e.location.lat.toFixed(6)};${e.location.lng.toFixed(6)}`);
-  const desc = [e.excerpt, e.location.url && e.location.url !== loc ? e.location.url : '', url].filter(Boolean).join('\n\n');
+  if (typeof part.location.lat === 'number' && typeof part.location.lng === 'number') lines.push(`GEO:${part.location.lat.toFixed(6)};${part.location.lng.toFixed(6)}`);
+  const desc = [e.excerpt, part.location.url && part.location.url !== loc ? part.location.url : '', url].filter(Boolean).join('\n\n');
   lines.push(`DESCRIPTION:${escapeText(desc)}`, `URL:${url}`);
   const cats = e.calendarIds.map((id) => opts.calendars?.get(id)?.name).filter((n): n is string => Boolean(n));
   if (cats.length) lines.push(`CATEGORIES:${cats.map(escapeText).join(',')}`);
-  if (e.cancelled) lines.push('STATUS:CANCELLED');
+  if (part.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), ...movedOverrides(e, tz, siteTz, url, opts, stamps));
+  if (rule && !part.cancelled) lines.push(...cancelledOverrides(part, s, en, tz, siteTz, url, uidSuffix, opts, stamps), ...movedOverrides(part, tz, siteTz, url, uidSuffix, 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[] {
+function movedOverrides(e: CalEvent, tz: string, siteTz: string, url: string, uidSuffix: string, opts: FeedOptions, stamps: string[]): string[] {
   const out: string[] = [];
   const cancelled = new Set(e.cancelledDates ?? []);
   for (const key of Object.keys(e.movedDates ?? {}).sort()) {
@@ -123,7 +173,7 @@ function movedOverrides(e: CalEvent, tz: string, siteTz: string, url: string, op
     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,
+    out.push('BEGIN:VEVENT', `UID:${e.id}${uidSuffix}@${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');
   }
@@ -132,7 +182,7 @@ function movedOverrides(e: CalEvent, tz: string, siteTz: string, url: string, op
 
 // 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[] {
+function cancelledOverrides(e: CalEvent, s: Wall, en: Wall, tz: string, siteTz: string, url: string, uidSuffix: string, opts: FeedOptions, stamps: string[]): string[] {
   const out: string[] = [];
   const toMin = (w: Wall) => Date.UTC(w.y, w.m - 1, w.d, w.hh, w.mm) / 60_000;
   const lenMin = e.allDay ? (toMin({ ...en, hh: 0, mm: 0 }) - toMin({ ...s, hh: 0, mm: 0 })) + 1440 : Math.max(0, toMin(en) - toMin(s));
@@ -144,7 +194,7 @@ function cancelledOverrides(e: CalEvent, s: Wall, en: Wall, tz: string, siteTz:
     const when = e.allDay
       ? [`RECURRENCE-ID;VALUE=DATE:${dateValue(w)}`, `DTSTART;VALUE=DATE:${dateValue(w)}`, `DTEND;VALUE=DATE:${dateValue(end)}`]
       : [`RECURRENCE-ID;TZID=${tz}:${localValue(w)}`, `DTSTART;TZID=${tz}:${localValue(w)}`, `DTEND;TZID=${tz}:${localValue(end)}`];
-    out.push('BEGIN:VEVENT', `UID:${e.id}@${opts.host}`, `DTSTAMP:${utcStamp(opts.now ?? Date.now())}`, ...when,
+    out.push('BEGIN:VEVENT', `UID:${e.id}${uidSuffix}@${opts.host}`, `DTSTAMP:${utcStamp(opts.now ?? Date.now())}`, ...when,
       `SUMMARY:${escapeText(e.title || 'Untitled event')}`, `URL:${url}`, 'STATUS:CANCELLED', ...stamps, 'END:VEVENT');
   }
   return out;

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

@@ -16,7 +16,7 @@ export interface MemberStrings {
   /** after an action (?sent=1 …) */
   flash: {
     sent: string; updated: string; changes: string; withdrawn: string; cancelled: string; restored: string;
-    moved: string; movedBack: string; moveSent: string; fromDateSent: string; dismissed: string;
+    moved: string; movedBack: string; moveSent: string; fromDateSent: string; fromDateDone: string; dismissed: string;
   };
   requests: string;
   upcoming: string;
@@ -88,6 +88,9 @@ export interface MemberStrings {
   changeFromRequested: string;
   weekday: string;
   everyWeek: string;
+  firstDate: string;
+  sameRepeat: string;
+  justThisDate: string;
   /** the request form */
   form: {
     title: string; when: string; date: string; starts: string; ends: string; optional: string; allDay: string; allDayHint: string;
@@ -129,6 +132,7 @@ const EN: MemberStrings = {
     movedBack: 'That date is back at its usual time. People who signed up were emailed.',
     moveSent: 'Your move is with the team. The date stays as it is until they approve it.',
     fromDateSent: 'Your schedule change is with the team. Nothing changes until they apply it.',
+    fromDateDone: 'Changed from that date on. People who signed up were emailed their new dates.',
     dismissed: 'Cleared.',
   },
   requests: 'Requests', upcoming: 'Upcoming', pastEvents: 'Past events ({count})', showingRecent: 'Showing the {count} most recent.',
@@ -151,6 +155,7 @@ const EN: MemberStrings = {
   changeFrom: 'Change from this date on…', changeFromLabel: 'Change {title} from {when} on',
   changeFromHint: 'For a lasting change, like a new day or time. Dates before this one stay as they are. The team applies it, and people who signed up hear about their new dates.',
   changeFromRequested: 'Change from {when} on waiting for approval', weekday: 'Day', everyWeek: 'Every week',
+  firstDate: 'First date', sameRepeat: 'Same as now, from the new day', justThisDate: 'Just that date',
   form: {
     title: 'Title', when: 'When', date: 'Date', starts: 'Starts', ends: 'Ends', optional: '(optional)', allDay: 'All day', allDayHint: 'No start or end time',
     multiDay: 'This event runs over {days} days. Changing the date moves all of them.', repeats: 'Repeats', where: 'Where',
@@ -197,6 +202,7 @@ const ES: MemberStrings = {
     movedBack: 'La fecha volvió a su horario de siempre. Avisamos por correo a quienes se inscribieron.',
     moveSent: 'Tu cambio de fecha ya lo tiene el equipo. La fecha sigue igual hasta que lo aprueben.',
     fromDateSent: 'Tu cambio de horario ya lo tiene el equipo. Nada cambia hasta que lo apliquen.',
+    fromDateDone: 'Se cambió desde esa fecha. Avisamos por correo a quienes se inscribieron.',
     dismissed: 'Listo.',
   },
   requests: 'Solicitudes', upcoming: 'Próximos', pastEvents: 'Eventos pasados ({count})', showingRecent: 'Se muestran los {count} más recientes.',
@@ -219,6 +225,7 @@ const ES: MemberStrings = {
   changeFrom: 'Cambiar desde esta fecha…', changeFromLabel: 'Cambiar {title} desde el {when}',
   changeFromHint: 'Para un cambio duradero, como un nuevo día u horario. Las fechas anteriores quedan igual. El equipo lo aplica, y a quienes se inscribieron les avisamos sus nuevas fechas.',
   changeFromRequested: 'Cambio desde el {when} en espera de aprobación', weekday: 'Día', everyWeek: 'Cada semana',
+  firstDate: 'Primera fecha', sameRepeat: 'Igual que ahora, desde el nuevo día', justThisDate: 'Solo esa fecha',
   form: {
     title: 'Título', when: 'Cuándo', date: 'Fecha', starts: 'Empieza', ends: 'Termina', optional: '(opcional)', allDay: 'Todo el día', allDayHint: 'Sin hora de inicio ni de fin',
     multiDay: 'Este evento dura {days} días. Si cambias la fecha, se mueven todos.', repeats: 'Se repite', where: 'Dónde',
@@ -265,6 +272,7 @@ const FR: MemberStrings = {
     movedBack: 'La date revient à son horaire habituel. Les inscrits ont été prévenus par e-mail.',
     moveSent: 'L’équipe a reçu votre déplacement. La date reste telle quelle jusqu’à son approbation.',
     fromDateSent: 'L’équipe a reçu votre changement d’horaire. Rien ne change avant qu’elle l’applique.',
+    fromDateDone: 'Changé à partir de cette date. Les inscrits ont été prévenus par e-mail.',
     dismissed: 'C’est effacé.',
   },
   requests: 'Demandes', upcoming: 'À venir', pastEvents: 'Événements passés ({count})', showingRecent: 'Les {count} plus récents sont affichés.',
@@ -287,6 +295,7 @@ const FR: MemberStrings = {
   changeFrom: 'Changer à partir de cette date…', changeFromLabel: 'Changer {title} à partir du {when}',
   changeFromHint: 'Pour un changement durable, comme un nouveau jour ou horaire. Les dates précédentes restent telles quelles. L’équipe l’applique, et les inscrits sont prévenus de leurs nouvelles dates.',
   changeFromRequested: 'Changement à partir du {when} en attente d’approbation', weekday: 'Jour', everyWeek: 'Chaque semaine',
+  firstDate: 'Première date', sameRepeat: 'Comme maintenant, à partir du nouveau jour', justThisDate: 'Seulement cette date',
   form: {
     title: 'Titre', when: 'Quand', date: 'Date', starts: 'Début', ends: 'Fin', optional: '(facultatif)', allDay: 'Toute la journée', allDayHint: 'Sans heure de début ni de fin',
     multiDay: 'Cet événement dure {days} jours. Changer la date les déplace tous.', repeats: 'Répétition', where: 'Lieu',
@@ -333,6 +342,7 @@ const DE: MemberStrings = {
     movedBack: 'Der Termin ist wieder zur gewohnten Zeit. Wer angemeldet ist, hat eine E-Mail bekommen.',
     moveSent: 'Das Team hat deine Verlegung. Der Termin bleibt, wie er ist, bis sie freigegeben ist.',
     fromDateSent: 'Das Team hat deine Planänderung. Es ändert sich nichts, bis sie übernommen ist.',
+    fromDateDone: 'Ab diesem Termin geändert. Angemeldete haben ihre neuen Termine per E-Mail bekommen.',
     dismissed: 'Erledigt.',
   },
   requests: 'Anfragen', upcoming: 'Demnächst', pastEvents: 'Vergangene Termine ({count})', showingRecent: 'Die {count} neuesten werden gezeigt.',
@@ -355,6 +365,7 @@ const DE: MemberStrings = {
   changeFrom: 'Ab diesem Termin ändern…', changeFromLabel: '{title} ab {when} ändern',
   changeFromHint: 'Für eine dauerhafte Änderung, etwa ein neuer Tag oder eine neue Zeit. Frühere Termine bleiben, wie sie sind. Das Team übernimmt sie, und Angemeldete erfahren ihre neuen Termine.',
   changeFromRequested: 'Änderung ab {when} wartet auf Freigabe', weekday: 'Tag', everyWeek: 'Jede Woche',
+  firstDate: 'Erster Termin', sameRepeat: 'Wie bisher, ab dem neuen Tag', justThisDate: 'Nur dieser Termin',
   form: {
     title: 'Titel', when: 'Wann', date: 'Datum', starts: 'Beginn', ends: 'Ende', optional: '(optional)', allDay: 'Ganztägig', allDayHint: 'Ohne Beginn- und Endzeit',
     multiDay: 'Dieser Termin dauert {days} Tage. Ein neues Datum verschiebt alle.', repeats: 'Wiederholung', where: 'Wo',
@@ -401,6 +412,7 @@ const PT: MemberStrings = {
     movedBack: 'A data voltou ao horário de sempre. Quem se inscreveu foi avisado por e-mail.',
     moveSent: 'A equipe recebeu sua mudança de data. A data continua como está até ser aprovada.',
     fromDateSent: 'A equipe recebeu sua mudança de horário. Nada muda até que ela seja aplicada.',
+    fromDateDone: 'Mudou a partir dessa data. Quem se inscreveu foi avisado por e-mail.',
     dismissed: 'Pronto.',
   },
   requests: 'Pedidos', upcoming: 'Próximos', pastEvents: 'Eventos passados ({count})', showingRecent: 'Mostrando os {count} mais recentes.',
@@ -423,6 +435,7 @@ const PT: MemberStrings = {
   changeFrom: 'Mudar a partir desta data…', changeFromLabel: 'Mudar {title} a partir de {when}',
   changeFromHint: 'Para uma mudança duradoura, como um novo dia ou horário. As datas anteriores continuam como estão. A equipe aplica, e quem se inscreveu é avisado das novas datas.',
   changeFromRequested: 'Mudança a partir de {when} aguardando aprovação', weekday: 'Dia', everyWeek: 'Toda semana',
+  firstDate: 'Primeira data', sameRepeat: 'Como agora, a partir do novo dia', justThisDate: 'Só essa data',
   form: {
     title: 'Título', when: 'Quando', date: 'Data', starts: 'Começa', ends: 'Termina', optional: '(opcional)', allDay: 'Dia inteiro', allDayHint: 'Sem hora de início ou fim',
     multiDay: 'Este evento dura {days} dias. Mudar a data move todos eles.', repeats: 'Repete', where: 'Onde',

package/src/lib/calendar/moves.ts

@@ -20,7 +20,7 @@ import type { ContentRepository } from '../repo/types';
 import { EventLocation, type CalEvent, type MovedDate } from '../schema';
 import { ApiError, coded } from '../api';
 import { eventSideEffects, type SaveHooks } from '../content-service';
-import { addWallDays, addWallMinutes, eventRoomIds, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence } from './events';
+import { addWallDays, addWallMinutes, eventRoomIds, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence, partOf, partMinutes, type SeriesPart } from './events';
 import { holdsFromEvents, roomBusy, type BusySlot } from '../booking/holds';
 import { kickEmail } from '../email/service';
 import { waitUntilFrom } from '../webhooks';
@@ -103,14 +103,14 @@ const started = () => refuse(400, 'started', 'That date has already started or p
 
 // 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 } {
+function newTimes(e: CalEvent, input: MoveInput, part: SeriesPart): { 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;
+    // the length of its part's dates (a change from a date on may have its own)
+    const length = partMinutes(part);
     end = formatWall(e.allDay ? addWallDays(s, Math.round(length / 1440)) : addWallMinutes(s, Math.max(1, length)));
   }
   try {
@@ -162,7 +162,9 @@ async function planMove(repo: ContentRepository, actor: MoveActor | null, id: st
   const settings = await repo.getSettings();
   const current = dateToChange(e, key, settings);
   const prior = e.movedDates[key];
-  const times = newTimes(e, input);
+  // its part of the series (CalEvent.segments): the length, rooms and place it has without a move
+  const part = partOf(e, current);
+  const times = newTimes(e, input, part);
 
   let roomIds = input.roomIds === undefined ? prior?.roomIds : [...new Set(input.roomIds)];
   if (roomIds !== undefined) {
@@ -175,11 +177,11 @@ async function planMove(repo: ContentRepository, actor: MoveActor | null, id: st
       if (roomIds.some((r) => !allowed.has(r))) throw refuse(403, 'room-not-allowed', 'Pick from the rooms this event uses, or ask the team for another room.');
     }
     // the event's own rooms aren't an override
-    if (sameRooms(roomIds, e.roomHold.resourceIds)) roomIds = undefined;
+    if (sameRooms(roomIds, part.roomIds)) 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;
+  if (location && JSON.stringify(location) === JSON.stringify(part.location ?? 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: by || actorId(actor!), at: now };
@@ -306,6 +308,8 @@ export interface DateRow {
   /** "Thu, Jan 10 · 6:00 – 7:00 PM" */
   when: string;
   cancelled: boolean;
+  /** cancelled because every date from some date on is (a cancelled part, CalEvent.segments) */
+  partCancelled: boolean;
   /** moved: "Thu, Jan 10 · 6:00 PM" (where it was) and the note */
   moved: { from: string; note: string } | null;
   roomIds: string[];
@@ -319,19 +323,21 @@ export function upcomingDates(e: CalEvent, settings: Awaited<ReturnType<ContentR
   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)!;
+      const part = partOf(e, o);
+      const length = partMinutes(part);
       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,
+        // cancelled with the rest of its part (cancelFromDate): restored from the change, not one by one
+        partCancelled: part.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/request-admin.ts

@@ -110,7 +110,8 @@ export async function requestRows(repo: ContentRepository, settings: Settings, t
           ? { taken: true, text: `${found[0].room} on ${f.slot(found[0].start, found[0].end)}${found[0].title ? ` (${found[0].title})` : ''}${found.length > 1 ? ` and ${found.length - 1} more` : ''}` }
           : { taken: false, text: `${names} ${d.roomIds.length > 1 ? 'are' : 'is'} free then` };
       }
-    } else if (q.kind === 'move') {
+    } else if (q.kind === 'move' || q.kind === 'from-date') {
+      // a host's date move, or change from a date on ("Thu, Jan 17, 6:00 PM → Wed, Jan 16, 5:00 PM · Weekly on Wednesday")
       title = e?.title ?? 'A deleted event';
       line = await dateRequestWhen(repo, q);
       if (tab === 'pending' && e) {

package/src/lib/calendar/request-service.ts

@@ -429,11 +429,11 @@ export async function approveRequest(repo: ContentRepository, who: Actor | null,
     if (!event) throw new ApiError(409, 'That event was deleted. Decline the request, or reply to the person.');
     done = await decide(repo, q, answer);
     next = `/admin/calendar/events/${event.id}${q.key ? `?move=${encodeURIComponent(q.key)}` : ''}`;
-  } else if (q.kind === 'move') {
-    // a host's date move (lib/calendar/host-requests.ts): it runs, and the host hears about it there
+  } else if (q.kind === 'move' || q.kind === 'from-date') {
+    // a host's date move or change from a date on (lib/calendar/host-requests.ts): it runs, and the host hears about it there
     const { approveDateRequest } = await import('./host-requests');
-    const { request, moved } = await approveDateRequest(repo, who, id, hooks, seen);
-    return { request, event: moved.event, next: `/admin/calendar/events/${request.eventId}` };
+    const { request, moved, changed } = await approveDateRequest(repo, who, id, hooks, seen);
+    return { request, event: (moved ?? changed)!.event, next: `/admin/calendar/events/${request.eventId}` };
   } else {
     throw new ApiError(400, 'Open the event to answer this request.');
   }
@@ -464,7 +464,7 @@ async function draftFrom(repo: ContentRepository, q: RequestRecord, hooks: SaveH
 export async function declineRequest(repo: ContentRepository, who: Actor | null, id: string, reply: string, hooks: SaveHooks, seen?: number, opts: { email?: boolean } = {}): Promise<RequestRecord> {
   requireAnswerer(who);
   const q = await pendingRequest(repo, id, seen);
-  if (q.kind === 'move') return (await import('./host-requests')).declineDateRequest(repo, who, id, reply, hooks, seen);
+  if (q.kind === 'move' || q.kind === 'from-date') return (await import('./host-requests')).declineDateRequest(repo, who, id, reply, hooks, seen);
   if (q.kind !== 'new' && q.kind !== 'change') throw new ApiError(400, 'Open the event to answer this request.');
   const reason = text(reply, REQUEST_LIMITS.message);
   const done = await decide(repo, q, { state: 'declined', reviewedBy: who.id, reviewedAt: Date.now(), reply: reason });

package/src/lib/calendar/schedule.ts

@@ -6,12 +6,12 @@
 // Cancelling one date of a series applies at once too, without touching any
 // staged edits.
 import type { ContentRepository } from '../repo/types';
-import type { CalEvent, MovedDate } from '../schema';
+import type { CalEvent, MovedDate, SeriesSegment } from '../schema';
 import { EventLocation, slugify } from '../schema';
 import { defaultPlaceLocation } from '../maps/places';
 import { ApiError } from '../api';
 import { applyEventUpdate, eventSideEffects, flushEventHooks, saveEvent, type SaveHooks } from '../content-service';
-import { addWallDays, addWallMinutes, findOccurrence, formatWall, parseWall, wallMinutesBetween } from './events';
+import { addWallDays, addWallMinutes, findOccurrence, formatWall, parseWall, wallMinutesBetween, partOf, partMinutes } from './events';
 import { moveOccurrence, moveOccurrenceBack, type MoveActor } from './moves';
 import type { BusySlot } from '../booking/holds';
 import { rruleMap, WEEKDAY_CODES, weekdayOf } from './rrule';
@@ -105,6 +105,8 @@ const dayOf = (wall: string) => {
 
 export type MoveUndo =
   | { kind: 'series'; id: string; days: number; minutes?: number }
+  // this and following dates (lib/calendar/segments.ts): the segments as they were, and where the change took over
+  | { kind: 'following'; id: string; from: string; previous: SeriesSegment[] }
   // one date moved (previous: where it was moved before, null = not moved)
   | { kind: 'date'; id: string; key: string; previous: Pick<MovedDate, 'start' | 'end' | 'roomIds' | 'location' | 'note'> | null }
   // undo tokens from before moved dates: the date was split off into a copy
@@ -126,10 +128,16 @@ export async function moveSeries(repo: ContentRepository, id: string, days: numb
     ...(e.rrule ? { rrule: shiftRrule(e.rrule, dayShift, start), exdates: e.exdates.map((x) => shiftBy(x, total)) } : {}),
   }, hooks);
   // cancelled dates move with the series, like skipped ones; a moved date
-  // keeps its new time and follows under its new key
-  if (e.rrule && (e.cancelledDates.length || Object.keys(e.movedDates).length)) {
+  // keeps its new time and follows under its new key; a change from a date on
+  // (segments) moves as a whole: its change point, first date and rule
+  if (e.rrule && (e.cancelledDates.length || Object.keys(e.movedDates).length || e.segments.length)) {
     const moved = Object.fromEntries(Object.entries(e.movedDates).map(([k, m]) => [shiftBy(k, total), m]));
-    await repo.setEventMovedDates(id, moved, e.cancelledDates.map((x) => shiftBy(x, total)));
+    const segments = e.segments.map((g) => {
+      const gs = shiftBy(g.start, total);
+      const shift = ((a, b) => (a && b ? Math.round(wallMinutesBetween(a, b) / 1440) : days))(dayOf(g.start), dayOf(gs));
+      return { ...g, from: shiftBy(g.from, total), start: gs, end: shiftBy(g.end, total), rrule: shiftRrule(g.rrule, shift, gs) };
+    });
+    await repo.setEventDates(id, { movedDates: moved, cancelledDates: e.cancelledDates.map((x) => shiftBy(x, total)), segments });
     await flushEventHooks(repo, hooks);
     event = (await repo.getEvent(id))!;
   }
@@ -149,21 +157,47 @@ export async function moveDateBy(repo: ContentRepository, actor: MoveActor, id:
   }
   if (!Number.isInteger(minutes) || Math.abs(minutes) > 1440 * 3660) throw new ApiError(400, 'Pick a day to move it to.');
   const prior = e.movedDates[key];
-  const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
   const k = parseWall(key);
-  if (!k || !es || !ee) throw new ApiError(400, 'That date isn’t part of this event.');
+  const at = k && findOccurrence({ ...e, movedDates: {} }, key, await repo.getSettings());
+  if (!k || !at) throw new ApiError(400, 'That date isn’t part of this event.');
+  // its length is its part's (a change from a date on may have its own)
   const startWall = prior?.start ?? key;
-  const endWall = prior?.end ?? formatWall(addWallMinutes(k, wallMinutesBetween(es, ee)));
+  const endWall = prior?.end ?? formatWall(addWallMinutes(k, partMinutes(partOf(e, at))));
   const r = await moveOccurrence(repo, actor, id, key, { start: shiftBy(startWall, minutes), end: shiftBy(endWall, minutes) }, hooks);
   const previous = prior ? { start: prior.start, end: prior.end, roomIds: prior.roomIds, location: prior.location, note: prior.note } : null;
   return { event: r.event, clashes: r.clashes, undo: { kind: 'date', id, key, previous } };
 }
 
+// Move one date of a repeating event and every date after it by `minutes`
+// (a drag on the Schedule, "This and following dates"): a change from that
+// date on (lib/calendar/segments.ts) whose rule follows the new weekday or
+// day, keeping each date's length. The dates before it stay where they are.
+export async function moveFollowingBy(repo: ContentRepository, actor: MoveActor, id: string, key: string, minutes: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo; clashes: BusySlot[] }> {
+  const e = await repo.getEvent(id);
+  if (!e) throw new ApiError(404, 'Event not found.');
+  if (!Number.isInteger(minutes) || Math.abs(minutes) > 1440 * 3660) throw new ApiError(400, 'Pick a day to move it to.');
+  const { changeFromDate, changeFromDefaults } = await import('./segments');
+  const from = await changeFromDefaults(repo, id, key);
+  if (!from) throw new ApiError(400, 'That date isn’t part of this event.');
+  // a moved date was dragged from where it is now
+  const moved = e.movedDates[key];
+  const r = await changeFromDate(repo, actor, id, key, { start: shiftBy(moved?.start ?? from.start, minutes), end: shiftBy(moved?.end ?? from.end, minutes) }, hooks);
+  // undo puts the segments back, from the earliest one that changed
+  const same = (a: SeriesSegment, list: SeriesSegment[]) => list.some((x) => JSON.stringify(x) === JSON.stringify(a));
+  const changed = [...r.event.segments.filter((g) => !same(g, e.segments)), ...e.segments.filter((g) => !same(g, r.event.segments))].map((g) => g.from).sort();
+  return { event: r.event, clashes: r.clashes, undo: { kind: 'following', id, from: changed[0] ?? key, previous: e.segments } };
+}
+
 export async function undoMove(repo: ContentRepository, actor: MoveActor, undo: MoveUndo, hooks: SaveHooks): Promise<void> {
   if (undo.kind === 'series') {
     await moveSeries(repo, undo.id, undo.days, hooks, undo.minutes ?? 0);
     return;
   }
+  if (undo.kind === 'following') {
+    const { restoreSegments } = await import('./segments');
+    await restoreSegments(repo, actor, undo.id, undo.from, undo.previous, hooks);
+    return;
+  }
   if (undo.kind === 'date') {
     if (undo.previous) await moveOccurrence(repo, actor, undo.id, undo.key, { ...undo.previous, roomIds: undo.previous.roomIds ?? [], location: undo.previous.location ?? null }, hooks);
     else await moveOccurrenceBack(repo, actor, undo.id, undo.key, hooks);