@acms-subir/core 0.3.56 → 0.3.57

package/src/lib/calendar/segments.ts

@@ -0,0 +1,522 @@
+// "From this date on" (C4): a repeating event changed from one of its dates,
+// with new times, weekday, rule, rooms or place, while the dates before it
+// stay exactly as they were. It stays one event (same page, slug, hosts,
+// RSVPs): the change is a segment on the event row (CalEvent.segments, see
+// events.ts seriesParts), so every write path, trigger and feed sees it.
+//
+// What follows the change point. Each date of the old schedule from `fromKey`
+// on is matched to the new date nearest it, within half a week (3½ days),
+// each new date taking at most one old date (closest pairs first):
+// - its RSVPs move to that date, and each person gets the "new time" email
+//   (places in line move quietly); RSVPs on a date with no match are
+//   cancelled, with the "cancelled" email;
+// - a cancelled date stays cancelled on its match, a skipped one (exdates)
+//   stays skipped, and a moved date keeps its new time under its match's key;
+// - a cancelled, skipped or moved date with no match is dropped (`dropped`).
+// Changing from a date that a segment starts with replaces that segment; a
+// later change replaces every segment after it (Google's "this and
+// following"); a change that gives exactly what the earlier rule gives
+// removes the segment. A cancelled part (cancelFromDate) cancels every date
+// from a date on, and restoreFromDate puts them back.
+//
+// Who: staff ("Create and edit content") and GOOGLE_SYNC. Room clashes come
+// back as warnings. Hosts send it as a request (host-requests.ts), and staff
+// apply it here.
+import type { ContentRepository } from '../repo/types';
+import { EventLocation, type CalEvent, type SeriesSegment } from '../schema';
+import { ApiError, coded } from '../api';
+import { eventSideEffects, type SaveHooks } from '../content-service';
+import { addWallDays, addWallMinutes, cutsAt, eventTimeZone, expandEvents, findOccurrence, formatWall, normalizeEventTimes, parseWall, partOf, seriesParts, wallMinutesBetween, type Occurrence, type SeriesPart } from './events';
+import { cleanRrule, describeRepeat, rruleMap } from './rrule';
+import { siteLocale } from '../dates';
+import { shiftRrule } from './schedule';
+import { GOOGLE_SYNC, type MoveActor } from './moves';
+import { holdsFromEvents, roomBusy, type BusySlot } from '../booking/holds';
+import { kickEmail } from '../email/service';
+import { waitUntilFrom } from '../webhooks';
+
+export interface ChangeFromInput {
+  /** the new part's first date: wall-clock in the event's zone, like `start` (YYYY-MM-DDTHH:mm, or YYYY-MM-DD all day); may come before `fromKey` */
+  start: string;
+  /** its end in the same form (all-day: the last day, inclusive); default: the length the dates have now */
+  end?: string;
+  /** its rule (RRULE without the prefix; '' = just that date); default: the rule in effect, moved to the new start's weekday or day, its COUNT what's left */
+  rrule?: string;
+  /** its rooms (Resource ids); default: the rooms in effect at `fromKey` */
+  roomIds?: string[];
+  /** its place; null = the event's; default: the place in effect at `fromKey` */
+  location?: Partial<EventLocation> | null;
+  /** a public note ("We meet on Wednesdays from January") */
+  note?: string;
+}
+export interface SegmentOptions {
+  /** no member push for it (a sync catching up); RSVP emails still go */
+  quiet?: boolean;
+  now?: number;
+}
+export interface ChangeFromResult {
+  event: CalEvent;
+  /** what else takes the new dates' rooms over the next 180 days (warnings) */
+  clashes: BusySlot[];
+  /** false: it already was so; nothing was written, sent or emailed */
+  changed: boolean;
+  /** RSVPs moved to their new date, and cancelled for want of one */
+  rsvps: { moved: number; cancelled: number };
+  /** old cancelled, skipped or moved dates (keys) dropped for want of a new date */
+  dropped: string[];
+}
+
+/** Why a change was refused (error.code, with error.status): as for moves, plus previous-date (the new first date isn't after the date before the change), first-date (the change is from the series' first date: edit the event instead), bad-rule, host-request (a host: send it as a request), not-cancelled. */
+export type SegmentRefusal = 'one-off' | 'cancelled-event' | 'not-a-date' | 'started' | 'past' | 'bad-time' | 'previous-date' | 'first-date' | 'bad-rule' | 'host-request' | 'not-cancelled';
+const refuse = (status: number, code: SegmentRefusal, message: string) => coded(status, code, message);
+
+const DAY = 86_400_000;
+const NOTE_MAX = 500;
+/** how far a date's sign-ups, cancellation or move may travel to its new date */
+export const FOLLOW_WITHIN = 3.5 * DAY;
+// how far ahead old and new dates are matched, and clashes looked for
+const HORIZON = 2 * 366 * DAY;
+const CLASH_DAYS = 180;
+
+type Settings = Awaited<ReturnType<ContentRepository['getSettings']>>;
+
+function requireStaff(actor: MoveActor | null, e: CalEvent) {
+  if (actor === GOOGLE_SYNC) return;
+  if (!actor) throw coded(401, 'sign-in', 'Sign in to continue.');
+  if (actor.can('content.edit')) return;
+  if (e.hostIds.includes(actor.id)) throw refuse(403, 'host-request', 'Send this change to the team as a request. They apply changes from a date on.');
+  throw coded(404, 'not-found', '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 coded(404, 'not-found', 'Event not found.');
+  return e;
+}
+
+// every date of the series as the rules make them, moves, cancellations and skips aside
+const bare = (e: CalEvent): CalEvent => ({ ...e, movedDates: {}, cancelledDates: [], exdates: [] });
+const datesFrom = (e: CalEvent, settings: Settings, from: number, to = from + HORIZON) =>
+  expandEvents([bare(e)], settings, { displayTz: settings.timezone || 'UTC', now: from, windowStartMs: from, windowEndMs: to });
+
+// The date at `key` and the part of the series it's in, checked for
+// changing. A key a segment took over from (no longer a date itself: a retry,
+// or a change of that segment) means that segment, at the date the series
+// had there. `replaces`: the change takes that part's place rather than
+// starting inside it (it has no dates before `key`).
+function changePoint(e: CalEvent, key: string, settings: Settings, now: number) {
+  if (!e.rrule) throw refuse(400, 'one-off', 'Only a repeating event can change from a date on. Change the event’s time instead.');
+  if (e.cancelled) throw refuse(409, 'cancelled-event', 'This event is cancelled.');
+  const valid = typeof key === 'string' && key.length <= 20;
+  let at = valid ? findOccurrence(bare(e), key, settings) : null;
+  let part = at ? partOf(e, at) : null;
+  if (!at && valid && e.segments.some((g) => g.from === key)) {
+    at = findOccurrence(bare({ ...e, segments: e.segments.filter((g) => g.from < key) }), key, settings);
+    part = seriesParts(e).find((p) => p.from === key) ?? null;
+  }
+  if (!at || !part) throw refuse(400, 'not-a-date', 'That date isn’t part of this event.');
+  if (at.start <= now) throw refuse(400, 'started', 'That date has already started or passed. Pick a date still to come.');
+  // the dates before it, nearest last (the new first date must come after them)
+  const before = expandEvents([bare(e)], settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: at.start - 400 * DAY, windowEndMs: at.start + FOLLOW_WITHIN })
+    .filter((o) => o.key < key);
+  const mine = (o: Occurrence) => (o.segment ?? '') === part!.from;
+  const replaces = Boolean(part.from) && (key === part.from || !before.some(mine));
+  const previous = (replaces ? before.filter((o) => !mine(o)) : before).at(-1) ?? null;
+  // the part's date the change starts from, for its rule's default: a replaced segment's own first date
+  const anchor = (replaces && findOccurrence(bare(e), part.start, settings)) || at;
+  // a replaced segment whose first date (maybe before `key`) has started can't change any more
+  const started = replaces && anchor.start <= now;
+  return { at, part, previous, replaces, anchor, started };
+}
+
+// a part's dates as a rule of its own, anchored at the date `at` (a cancelled part, or the default rule for a change)
+function ruleFrom(e: CalEvent, part: SeriesPart, at: Occurrence, newStart: string, settings: Settings): string {
+  const rule = cleanRrule(part.rrule);
+  if (!rule) return '';
+  const p = rruleMap(rule);
+  const from = parseWall(at.key), to = parseWall(newStart);
+  const days = from && to ? Math.round(wallMinutesBetween({ ...from, hh: 0, mm: 0 }, { ...to, hh: 0, mm: 0 }) / 1440) : 0;
+  // the weekdays (or day of the month) follow the new start; the end date stays
+  let out = shiftRrule(rule, days, newStart);
+  if (p.UNTIL) out = out.replace(/UNTIL=[^;]*/, `UNTIL=${p.UNTIL}`);
+  if (p.COUNT) {
+    const solo: CalEvent = { ...bare(e), start: part.start, end: part.end, rrule: rule, segments: [] };
+    const left = expandEvents([solo], settings, { displayTz: settings.timezone || 'UTC', now: at.start, windowStartMs: at.start, windowEndMs: at.start + 10 * 366 * DAY }).length;
+    out = out.replace(/COUNT=\d+/, `COUNT=${Math.max(1, left)}`);
+  }
+  return out;
+}
+
+// the new first date's times in the event's form; `end` defaults to the length the dates have now
+function times(e: CalEvent, part: SeriesPart, input: Pick<ChangeFromInput, 'start' | 'end'>): { 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 ps = parseWall(part.start), pe = parseWall(part.end) ?? ps;
+    const length = ps && pe ? wallMinutesBetween(ps, pe) : 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.'); }
+}
+
+const sameRooms = (a: string[], b: string[]) => a.length === b.length && [...a].sort().every((x, i) => x === [...b].sort()[i]);
+const sameDates = (a: Occurrence[], b: Occurrence[]) => a.length === b.length && a.every((o, i) => o.key === b[i].key && o.start === b[i].start && o.end === b[i].end);
+
+// A segment that gives exactly what the part before it would (same dates over
+// the horizon, rooms, place, not cancelled) isn't a change: drop it. Each is
+// checked against the parts kept before it.
+function normalize(e: CalEvent, segments: SeriesSegment[], settings: Settings, now: number): SeriesSegment[] {
+  const kept: SeriesSegment[] = [];
+  const sorted = [...segments].sort((a, b) => (a.from < b.from ? -1 : a.from > b.from ? 1 : 0));
+  for (let i = 0; i < sorted.length; i++) {
+    const g = sorted[i];
+    const next = sorted[i + 1]?.from ?? '';
+    const withIt = { ...e, segments: [...kept, g, ...(next ? [sorted[i + 1]] : [])] };
+    const without = { ...e, segments: [...kept, ...(next ? [sorted[i + 1]] : [])] };
+    const prev = partOf(without, { segment: kept[kept.length - 1]?.from });
+    const mine = seriesParts(withIt).find((p) => p.from === g.from)!;
+    // quick no: cancelled, other rooms or place, or a first date the earlier rule doesn't have there
+    const firstThen = findOccurrence(bare(without), g.start, settings);
+    const firstNow = findOccurrence(bare(withIt), g.start, settings);
+    const maybe = !g.cancelled && !prev.cancelled && sameRooms(mine.roomIds, prev.roomIds) && JSON.stringify(mine.location ?? null) === JSON.stringify(prev.location ?? null)
+      && g.from === g.start && firstThen && firstNow && (firstThen.segment ?? '') === prev.from && firstThen.start === firstNow.start && firstThen.end === firstNow.end;
+    if (!maybe) { kept.push(g); continue; }
+    // then the dates themselves, over the next 400 days or to the later end date of the two rules
+    const span = Math.min(10 * 366 * DAY, Math.max(400 * DAY, untilMs(g.rrule) - firstNow.start, untilMs(prev.rrule) - firstNow.start) + 2 * DAY);
+    const a = datesFrom(withIt, settings, firstNow.start - DAY, firstNow.start + span).filter((o) => o.segment === g.from);
+    const b = datesFrom(without, settings, firstNow.start - DAY, firstNow.start + span).filter((o) => (o.segment ?? '') === prev.from && cutsAt(g.from, o.key));
+    if (!sameDates(a, b)) kept.push(g);
+  }
+  return kept;
+}
+
+// a date's series times as wall-clock "start|end" (to compare with a MovedDate)
+function formatWallAt(o: Occurrence, e: CalEvent, _settings: Settings): string {
+  const w = parseWall(o.key);
+  if (!w) return '';
+  const part = partOf(e, o);
+  const ps = parseWall(part.start), pe = parseWall(part.end) ?? ps;
+  const length = ps && pe ? wallMinutesBetween(ps, pe) : 0;
+  return `${o.key}|${formatWall(e.allDay ? addWallDays(w, Math.round(length / 1440)) : addWallMinutes(w, length))}`;
+}
+
+// a rule's UNTIL as a time (roughly: the day's end in UTC), 0 when it has none
+function untilMs(rrule: string): number {
+  const u = rruleMap(rrule).UNTIL;
+  return u ? Date.UTC(+u.slice(0, 4), +u.slice(4, 6) - 1, +u.slice(6, 8)) + DAY : 0;
+}
+
+// old dates (from the change point on) → new dates: nearest within FOLLOW_WITHIN, closest pairs first, one each
+function matchDates(old: Occurrence[], fresh: Occurrence[]): Map<string, Occurrence> {
+  const pairs: { o: Occurrence; n: Occurrence; d: number }[] = [];
+  for (const o of old) for (const n of fresh) {
+    const d = Math.abs(n.start - o.start);
+    if (d <= FOLLOW_WITHIN) pairs.push({ o, n, d });
+  }
+  pairs.sort((x, y) => x.d - y.d || x.o.start - y.o.start);
+  const out = new Map<string, Occurrence>();
+  const taken = new Set<string>();
+  for (const { o, n } of pairs) {
+    if (out.has(o.key) || taken.has(n.key)) continue;
+    out.set(o.key, n);
+    taken.add(n.key);
+  }
+  return out;
+}
+
+// what else takes the new part's rooms over the next CLASH_DAYS (each room checked once over the span)
+async function clashesFor(repo: ContentRepository, next: CalEvent, from: string, settings: Settings, start: number): Promise<BusySlot[]> {
+  const resources = new Map((await repo.listResources()).map((r) => [r.id, r]));
+  const to = start + CLASH_DAYS * DAY;
+  const mine = new Set(expandEvents([next], settings, { displayTz: settings.timezone || 'UTC', now: start, windowStartMs: start - DAY, windowEndMs: to + DAY })
+    .filter((o) => o.segment === from).map((o) => o.key));
+  const holds = holdsFromEvents([next], resources, settings, start, to, { force: true }).filter((h) => mine.has(h.key));
+  if (!holds.length) return [];
+  const out: BusySlot[] = [];
+  const seen = new Set<string>();
+  for (const room of [...new Set(holds.map((h) => h.resourceId))]) {
+    const busy = await roomBusy(repo, settings, { resourceIds: [room], from: start, to, ignore: { eventId: next.id } });
+    for (const b of busy) {
+      if (!holds.some((h) => h.resourceId === room && h.start < b.end && b.start < h.end)) continue;
+      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);
+}
+
+/**
+ * Rewrites the series from `fromKey` with `segments` (the earlier ones kept),
+ * carrying cancelled, skipped and moved dates and RSVPs over to their new
+ * dates (see the top of this file), in one write.
+ */
+async function apply(repo: ContentRepository, e: CalEvent, fromKey: string, at: Occurrence, segments: SeriesSegment[], note: string, hooks: SaveHooks, settings: Settings, opts: SegmentOptions, cancelling: boolean) {
+  const now = opts.now ?? Date.now();
+  const next: CalEvent = { ...e, segments: normalize(e, segments, settings, now) };
+  // how far to look: past the last date anything is attached to (an RSVP, a cancelled, moved or skipped date), at least five weeks
+  const bookings = await repo.listBookings({ eventId: e.id, kinds: ['rsvp'], from: Math.min(at.start, now) - 4 * DAY, statuses: ['pending', 'confirmed', 'offered', 'waitlisted'] });
+  const signedUp = new Set(bookings.map((b) => b.start));
+  const roughly = (key: string) => { const ms = Date.parse(`${key.length === 10 ? `${key}T00:00` : key}:00Z`); return Number.isFinite(ms) ? ms + 2 * DAY : 0; };
+  const last = Math.max(0, ...bookings.map((b) => b.end), ...[...e.cancelledDates, ...e.exdates, ...Object.keys(e.movedDates)].map(roughly),
+    ...Object.values(e.movedDates).map((m) => roughly(m.start)));
+  const startAt = Math.min(at.start, now) - 4 * DAY;
+  const endAt = Math.min(at.start + HORIZON, Math.max(at.start + 35 * DAY, last + 7 * DAY));
+  const span = (x: CalEvent) => datesFrom(x, settings, startAt, endAt);
+  // the old dates the change takes over (from `fromKey` on, and those of the segments it replaces), and the dates the new schedule makes there
+  const taken = (o: Occurrence) => cutsAt(fromKey, o.key) || (o.segment !== undefined && o.segment >= fromKey);
+  const all = span(e);
+  const old = all.filter(taken);
+  const oldKeys = new Set(old.map((o) => o.key));
+  const keepBefore = new Set(all.filter((o) => !taken(o)).map((o) => o.key));
+  const fresh = span(next).filter((o) => !keepBefore.has(o.key));
+  const match = matchDates(old, fresh);
+  const dropped: string[] = [];
+  const follow = (key: string) => (oldKeys.has(key) ? match.get(key)?.key ?? null : key);
+  // a cancelled, skipped or moved date carried over, or listed as dropped
+  const carry = (key: string) => { const k = follow(key); if (k === null) dropped.push(key); return k; };
+  const cancelledDates = [...new Set(e.cancelledDates.map(carry).filter((k): k is string => k !== null))].sort();
+  const exdates = [...new Set(e.exdates.map(carry).filter((k): k is string => k !== null))];
+  const movedDates: CalEvent['movedDates'] = {};
+  for (const [key, m] of Object.entries(e.movedDates)) {
+    // cancelling from a date on drops the moves there (a date is moved or cancelled, never both)
+    if (cancelling && oldKeys.has(key)) { dropped.push(key); continue; }
+    const k = carry(key);
+    if (k === null || cancelledDates.includes(k)) continue;
+    // a move to where its new date already is, in its rooms and place, isn't one any more
+    const there = findOccurrence({ ...next, movedDates: {}, cancelledDates: [], exdates: [] }, k, settings);
+    const plain = there && !m.roomIds && !m.location && formatWallAt(there, next, settings) === `${m.start}|${m.end}`;
+    if (!plain) movedDates[k] = m;
+  }
+  const written: CalEvent = { ...next, cancelledDates, exdates, movedDates };
+  const changed = JSON.stringify([written.segments, cancelledDates, exdates, movedDates]) !== JSON.stringify([e.segments, e.cancelledDates, e.exdates, e.movedDates]);
+  if (!changed) return { written: e, changed, dropped: [], plan: [] as { from: number; to: Occurrence | null }[] };
+
+  // RSVPs: each old date's (where it is now: a moved one keeps its time) to its match, else cancelled
+  const plan: { from: number; to: Occurrence | null }[] = [];
+  for (const o of old) {
+    const nowAt = findOccurrence(e, o.key, settings);
+    if (nowAt && !signedUp.has(nowAt.start)) continue;
+    if (!nowAt || nowAt.cancelled) continue;
+    const k = follow(o.key);
+    const to = k === null ? null : findOccurrence(written, k, settings);
+    if (to && !to.cancelled && to.start === nowAt.start && to.end === nowAt.end) continue;
+    plan.push({ from: nowAt.start, to: to && !to.cancelled ? to : null });
+  }
+  await repo.setEventDates(e.id, { segments: written.segments, cancelledDates, exdates, movedDates }, { quiet: opts.quiet });
+  return { written, changed, dropped: [...new Set(dropped)].sort(), plan };
+}
+
+async function afterApply(repo: ContentRepository, id: string, plan: { from: number; to: Occurrence | null }[], note: string, hooks: SaveHooks) {
+  let moved = 0, cancelled = 0;
+  for (const p of plan) {
+    if (p.to) moved += await repo.moveOccurrenceRsvps(id, p.from, { start: p.to.start, end: p.to.end }, note);
+    else cancelled += await repo.cancelOccurrenceRsvps(id, p.from);
+  }
+  if (moved || cancelled) await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals));
+  const after = (await repo.getEvent(id))!;
+  await eventSideEffects(repo, hooks, after);
+  return { after, rsvps: { moved, cancelled } };
+}
+
+/**
+ * Change a repeating event from one of its dates on: new times, weekday,
+ * rule, rooms or place, keeping every date before it as it was. See the top
+ * of this file for what follows the change. Staff and GOOGLE_SYNC only; room
+ * clashes come back as warnings. Idempotent (`changed: false`).
+ */
+export async function changeFromDate(repo: ContentRepository, actor: MoveActor | null, id: string, fromKey: string, input: ChangeFromInput, hooks: SaveHooks, opts: SegmentOptions = {}): Promise<ChangeFromResult> {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  requireStaff(actor, e);
+  const settings = await repo.getSettings();
+  const { from, at, segment, first, same } = await planChange(repo, e, settings, actor!, fromKey, input, now);
+  // a retry of what's there already (whoever made it, whenever) changes nothing
+  if (same && !e.segments.some((g) => g.from > from)) return { event: e, clashes: [], changed: false, rsvps: { moved: 0, cancelled: 0 }, dropped: [] };
+  const segments = [...e.segments.filter((g) => g.from < from), segment];
+  const r = await apply(repo, e, from, at, segments, segment.note, hooks, settings, opts, false);
+  if (!r.changed) return { event: e, clashes: [], changed: false, rsvps: { moved: 0, cancelled: 0 }, dropped: [] };
+  const done = await afterApply(repo, id, r.plan, segment.note, hooks);
+  const clashes = r.written.segments.some((g) => g.from === from) ? await clashesFor(repo, done.after, from, settings, Math.max(now, first.start - DAY)) : [];
+  return { event: done.after, clashes, changed: true, rsvps: done.rsvps, dropped: r.dropped };
+}
+
+/**
+ * What changeFromDate would write, checked but not written (a host's request
+ * is checked this way before it goes to staff): the same refusals, without
+ * the staff check. `segment` is the new part, normalized.
+ */
+export async function checkChangeFromDate(repo: ContentRepository, actor: MoveActor, id: string, fromKey: string, input: ChangeFromInput, opts: Pick<SegmentOptions, 'now'> = {}): Promise<{ segment: SeriesSegment; changed: boolean }> {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  const settings = await repo.getSettings();
+  const { from, segment, same } = await planChange(repo, e, settings, actor, fromKey, input, now);
+  if (same && !e.segments.some((g) => g.from > from)) return { segment, changed: false };
+  const next = normalize(e, [...e.segments.filter((g) => g.from < from), segment], settings, now);
+  return { segment, changed: JSON.stringify(next.map(withoutWho)) !== JSON.stringify(e.segments.map(withoutWho)) };
+}
+
+async function planChange(repo: ContentRepository, e: CalEvent, settings: Settings, actor: MoveActor, fromKey: string, input: ChangeFromInput, now: number) {
+  const { at, part, previous, replaces, anchor, started } = changePoint(e, fromKey, settings, now);
+  if (!previous) throw refuse(400, 'first-date', 'That’s the first date of the series. Change the event’s own time and repeat instead.');
+  const t = times(e, part, input);
+  const rrule = input.rrule === undefined ? ruleFrom(e, part, anchor, t.start, settings) : cleanRrule(String(input.rrule));
+  if (input.rrule !== undefined && String(input.rrule).trim() && !rrule) throw refuse(400, 'bad-rule', 'That repeat rule isn’t one the calendar understands.');
+
+  const resources = await repo.listResources();
+  let roomIds = input.roomIds === undefined ? undefined : [...new Set(input.roomIds)].filter((r) => resources.some((x) => x.id === r));
+  if (roomIds && sameRooms(roomIds, e.roomHold.resourceIds)) roomIds = undefined;
+  if (input.roomIds === undefined && part.from) roomIds = sameRooms(part.roomIds, e.roomHold.resourceIds) ? undefined : part.roomIds;
+  let location = input.location === undefined ? part.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 = String(input.note ?? '').replace(/\s+/g, ' ').trim().slice(0, NOTE_MAX);
+
+  // a change from the date a segment starts with replaces that segment (keeping where it took over)
+  const from = replaces ? part.from : fromKey;
+  const fresh: SeriesSegment = { from, start: t.start, end: t.end, rrule, ...(roomIds ? { roomIds } : {}), ...(location ? { location } : {}), cancelled: false, note, by: actorId(actor), at: now };
+  // the same change as the one there: keep that one (its by/at) as it is
+  const existing = e.segments.find((g) => g.from === from);
+  const same = Boolean(existing && JSON.stringify(withoutWho(existing)) === JSON.stringify(withoutWho(fresh)));
+  // the first date has to be one of the new rule's own dates (its DTSTART); a retry of what's there skips the time checks
+  const first = findOccurrence({ ...bare(e), start: t.start, end: t.end, rrule, segments: [] }, t.start, settings);
+  if (!first) throw refuse(400, 'bad-rule', 'The first date has to be one of the new pattern’s dates.');
+  if (!same) {
+    if (started) throw refuse(400, 'started', 'That change has already started. Change from a date still to come instead.');
+    if (first.start <= now) throw refuse(400, 'past', 'Pick a first date that hasn’t passed yet.');
+    if (first.start <= previous.start) throw refuse(400, 'previous-date', 'Pick a first date after the date before the change.');
+  }
+  return { from, at, segment: same ? existing! : fresh, first, same };
+}
+
+// a segment as what it does, not who made it when
+const withoutWho = ({ by: _by, at: _at, ...g }: SeriesSegment) => ({ ...g, roomIds: g.roomIds ?? null, location: g.location ?? null });
+
+/** Cancel every date of a repeating event from one on: they stay listed, struck through, hold no room, and their RSVPs are cancelled (emailed). Idempotent. */
+export async function cancelFromDate(repo: ContentRepository, actor: MoveActor | null, id: string, fromKey: string, hooks: SaveHooks, opts: SegmentOptions = {}): Promise<ChangeFromResult> {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  requireStaff(actor, e);
+  const settings = await repo.getSettings();
+  const { at, part, previous, replaces } = changePoint(e, fromKey, settings, now);
+  if (part.cancelled) return { event: e, clashes: [], changed: false, rsvps: { moved: 0, cancelled: 0 }, dropped: [] };
+  if (!previous) throw refuse(400, 'first-date', 'That’s the first date of the series. Cancel the whole event instead.');
+  const from = replaces ? part.from : fromKey;
+  const startWall = at.key;
+  const t = times(e, part, { start: startWall });
+  const own = e.segments.find((g) => g.from === from);
+  const segment: SeriesSegment = own && from === part.from
+    ? { ...own, cancelled: true, by: actorId(actor!), at: now }
+    : { from, start: t.start, end: t.end, rrule: ruleFrom(e, part, at, t.start, settings), ...(part.from && !sameRooms(part.roomIds, e.roomHold.resourceIds) ? { roomIds: part.roomIds } : {}),
+      ...(part.location ? { location: part.location } : {}), cancelled: true, note: '', by: actorId(actor!), at: now };
+  // every date from there on: later segments go too, and the rule in effect carries on, struck through
+  const r = await apply(repo, e, from, at, [...e.segments.filter((g) => g.from < from), segment], '', hooks, settings, opts, true);
+  if (!r.changed) return { event: e, clashes: [], changed: false, rsvps: { moved: 0, cancelled: 0 }, dropped: [] };
+  const done = await afterApply(repo, id, r.plan, '', hooks);
+  return { event: done.after, clashes: [], changed: true, rsvps: done.rsvps, dropped: r.dropped };
+}
+
+/** Undo cancelFromDate (at the date it took effect, or any date it covers): the dates are back on; their RSVPs stay cancelled, so people sign up again. Idempotent. */
+export async function restoreFromDate(repo: ContentRepository, actor: MoveActor | null, id: string, fromKey: string, hooks: SaveHooks, opts: SegmentOptions = {}): Promise<ChangeFromResult> {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  requireStaff(actor, e);
+  const settings = await repo.getSettings();
+  // a date the cancelled part has, or the key it took over from
+  const o = findOccurrence(bare(e), fromKey, settings);
+  const part = o ? partOf(e, o) : seriesParts(e).find((p) => p.from === fromKey) ?? null;
+  if (!part?.cancelled) return { event: e, clashes: [], changed: false, rsvps: { moved: 0, cancelled: 0 }, dropped: [] };
+  const first = findOccurrence(bare(e), part.start, settings);
+  if (!first || first.start <= now) throw refuse(400, 'started', 'Those dates have already started. Change from a date still to come instead.');
+  const segments = e.segments.map((g) => (g.from === part.from ? { ...g, cancelled: false, by: actorId(actor!), at: now } : g));
+  const at = findOccurrence(bare({ ...e, segments: e.segments.filter((g) => g.from < part.from) }), part.from, settings) ?? first;
+  const r = await apply(repo, e, part.from, at, segments, '', hooks, settings, opts, false);
+  if (!r.changed) return { event: e, clashes: [], changed: false, rsvps: { moved: 0, cancelled: 0 }, dropped: [] };
+  // nothing to move: the dates come back where they were
+  const done = await afterApply(repo, id, [], '', hooks);
+  return { event: done.after, clashes: [], changed: true, rsvps: done.rsvps, dropped: r.dropped };
+}
+
+/**
+ * Undo a change from a date on: the segment taking over at `from` goes, and
+ * the rule before it carries on (to the next segment). Its dates' RSVPs,
+ * cancelled and moved dates follow back the same way. Idempotent.
+ */
+export async function revertFromDate(repo: ContentRepository, actor: MoveActor | null, id: string, from: string, hooks: SaveHooks, opts: SegmentOptions = {}): Promise<ChangeFromResult> {
+  return setSegments(repo, actor, id, from, (segments) => segments.filter((g) => g.from !== from), hooks, opts);
+}
+
+/** Put an event's segments back to `previous` (a Schedule undo), carrying dates over from `from` on. */
+export async function restoreSegments(repo: ContentRepository, actor: MoveActor | null, id: string, from: string, previous: SeriesSegment[], hooks: SaveHooks, opts: SegmentOptions = {}): Promise<ChangeFromResult> {
+  return setSegments(repo, actor, id, from, () => previous.map((g) => SeriesSegmentParse(g)), hooks, opts);
+}
+const SeriesSegmentParse = (g: SeriesSegment): SeriesSegment => ({ ...g, note: g.note ?? '', by: g.by ?? '', at: g.at ?? 0, cancelled: Boolean(g.cancelled) });
+
+async function setSegments(repo: ContentRepository, actor: MoveActor | null, id: string, from: string, change: (segments: SeriesSegment[]) => SeriesSegment[], hooks: SaveHooks, opts: SegmentOptions) {
+  const now = opts.now ?? Date.now();
+  const e = await load(repo, id);
+  requireStaff(actor, e);
+  const settings = await repo.getSettings();
+  const segments = change(e.segments);
+  if (JSON.stringify(segments) === JSON.stringify(e.segments)) return { event: e, clashes: [], changed: false, rsvps: { moved: 0, cancelled: 0 }, dropped: [] };
+  // the date the change point stands for: the series' date there without the segments from it on
+  const at = findOccurrence(bare({ ...e, segments: e.segments.filter((g) => g.from < from) }), from, settings);
+  if (!at) throw refuse(400, 'not-a-date', 'That date isn’t part of this event.');
+  if (at.start <= now) throw refuse(400, 'started', 'That date has already started or passed.');
+  // nor may a change that goes or changes have started (its first date can come before `from`)
+  const gone = e.segments.filter((g) => g.from >= from && !segments.some((x) => JSON.stringify(x) === JSON.stringify(g)));
+  if (gone.some((g) => (findOccurrence(bare(e), g.start, settings)?.start ?? Infinity) <= now)) throw refuse(400, 'started', 'That change has already started. Change from a date still to come instead.');
+  const r = await apply(repo, e, from, at, segments, '', hooks, settings, opts, false);
+  if (!r.changed) return { event: e, clashes: [], changed: false, rsvps: { moved: 0, cancelled: 0 }, dropped: [] };
+  const done = await afterApply(repo, id, r.plan, '', hooks);
+  return { event: done.after, clashes: [], changed: true, rsvps: done.rsvps, dropped: r.dropped };
+}
+
+/** The default rule and times a change from `fromKey` would start with (for forms): the date's own times and the rule in effect there. */
+export async function changeFromDefaults(repo: ContentRepository, id: string, fromKey: string): Promise<{ start: string; end: string; rrule: string; roomIds: string[]; location: EventLocation | null } | null> {
+  const e = await repo.getEvent(id);
+  if (!e?.rrule) return null;
+  const settings = await repo.getSettings();
+  const at = findOccurrence(bare(e), fromKey, settings);
+  if (!at) return null;
+  const part = partOf(e, at);
+  const t = times(e, part, { start: at.key });
+  return { start: t.start, end: t.end, rrule: ruleFrom(e, part, at, t.start, settings), roomIds: part.roomIds, location: part.location ?? null };
+}
+
+/** A change from a date on, for the editor's Single dates panel: when it took over, the rule in words with its times, rooms and state. */
+export interface SegmentRow {
+  from: string;
+  /** its first date: "Wed, Jan 16" */
+  when: string;
+  /** "Weekly on Wednesday · 5:00 – 6:00 PM" */
+  repeats: string;
+  rooms: string[];
+  cancelled: boolean;
+  note: string;
+  /** it has taken over already */
+  current: boolean;
+}
+
+/** The changes from a date on that still have dates to come, in order. */
+export function upcomingSegments(e: CalEvent, settings: Settings, roomNames: Map<string, string>, now = Date.now()): SegmentRow[] {
+  const parts = seriesParts(e).slice(1);
+  if (!parts.length) return [];
+  const tz = e.allDay ? settings.timezone || 'UTC' : eventTimeZone(e, settings);
+  const fmt = (o: Intl.DateTimeFormatOptions) => { try { return new Intl.DateTimeFormat(siteLocale(settings), { ...o, timeZone: tz }); } catch { return new Intl.DateTimeFormat('en-US', { ...o, timeZone: 'UTC' }); } };
+  const day = fmt({ weekday: 'short', month: 'short', day: 'numeric' }), time = fmt({ hour: 'numeric', minute: '2-digit' });
+  const dates = expandEvents([bare(e)], settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: now - 400 * DAY, windowEndMs: now + 400 * DAY });
+  return parts.flatMap((p) => {
+    const mine = dates.filter((o) => o.segment === p.from);
+    if (!mine.length || mine[mine.length - 1].end <= now) return [];
+    const first = mine[0];
+    const range = (() => { try { return time.formatRange(first.start, first.end); } catch { return `${time.format(first.start)} – ${time.format(first.end)}`; } })();
+    return [{
+      from: p.from, when: day.format(first.start), repeats: [describeRepeat(p.rrule, p.start), e.allDay ? '' : range].filter(Boolean).join(' · '),
+      rooms: p.roomIds.map((id) => roomNames.get(id)).filter((n): n is string => Boolean(n)), cancelled: p.cancelled, note: p.note, current: first.start <= now,
+    }];
+  });
+}

package/src/lib/editor/schedule.ts

@@ -5,7 +5,7 @@ import { ApiError } from '../api';
 import { ApprovalMode, ApprovalRules, BookingMode, DateOverride, QUESTION_TYPES, TimeRange, WeeklyHours, slugify } from '../schema';
 import { CALENDAR, bookingsEnabled } from '../calendar/config';
 import { collectViewEvents } from '../calendar/data';
-import { isValidTimeZone, safeColor } from '../calendar/events';
+import { isValidTimeZone, partOf, safeColor } from '../calendar/events';
 import { describeRepeat } from '../calendar/rrule';
 import { zonedToUtc } from '../calendar/ics';
 import { normalizeCalendarSrc } from '../calendar/src';
@@ -59,7 +59,7 @@ export async function schedule(c: EditorContext, q: z.infer<typeof ScheduleQuery
         kind: e ? 'event' as const : 'feed' as const, id: e?.id ?? '', title: v.title,
         start: iso(v.start), end: iso(v.end), allDay: v.allDay, status: e ? e.status : 'feed',
         calendarId: cal?.id ?? '', color: v.color ?? (cal ? safeColor(cal.color) : '#8a8378'),
-        location: v.location, cancelled: Boolean(v.cancelled), repeat: e?.rrule ? describeRepeat(e.rrule, e.start) : '',
+        location: v.location, cancelled: Boolean(v.cancelled), repeat: e?.rrule ? ((p) => describeRepeat(p.rrule, p.start))(partOf(e, { segment: v.segment })) : '',
         resourceIds: e?.roomHold.resourceIds ?? [],
       };
     }),

package/src/lib/mobile/calendar.ts

@@ -113,6 +113,7 @@ export function occurrenceDto(o: Occurrence, resources: Map<string, Resource>) {
   return { id: `${o.event.id}:${o.start}`, start: iso(o.start), end: iso(o.end), allDay: o.allDay, cancelled: o.cancelled,
     moved: o.moved ? { from: { start: iso(o.moved.from.start), end: iso(o.moved.from.end) }, note: o.moved.note,
       location: o.moved.location ? { name: o.moved.location.name, address: o.moved.location.address, url: o.moved.location.url } : null } : null,
+    location: o.location ? { name: o.location.name, address: o.location.address, url: o.location.url } : null,
     rooms: roomsToJson(o.roomIds, resources) };
 }
 // e is already localized; publicCalendars limits which calendars are named

package/src/lib/mobile/schemas.ts

@@ -32,6 +32,11 @@ export const Page = ContentSummary.extend({
 export const EventRoom = z.object({ slug: str, name: str, color: str.nullable() });
 // one date moved here from `from` (null when it wasn't); location: its own place, null = the event's
 export const OccurrenceMoved = z.object({ from: z.object({ start: date, end: date }), note: str, location: z.object({ name: str, address: str, url: str }).nullable() }).nullable();
+// a date's own place (a moved date's, or from its event's change from a date on); null = the event's
+export const OccurrencePlace = z.object({ name: str, address: str, url: str }).nullable();
+// the series from one date on (CalEvent.segments): `from` is the occurrence key where it took over; location null = the event's
+export const EventSegment = z.object({ from: str, start: str, end: str, rrule: str, repeats: str, cancelled: bool, note: str,
+  location: z.object({ name: str, address: str, url: str }).nullable(), rooms: z.array(EventRoom) });
 export const Event = CalEvent.pick({
   id: true, slug: true, title: true, excerpt: true, status: true, cancelled: true, featured: true, start: true, end: true,
   allDay: true, timezone: true, rrule: true, exdates: true, cancelledDates: true, location: true, cta: true, tags: true, fields: true,
@@ -40,18 +45,20 @@ export const Event = CalEvent.pick({
   rooms: z.array(EventRoom),
   // single dates at another time, by original occurrence key (wall-clock, like start/end)
   movedDates: z.record(z.object({ start: str, end: str, note: str })),
+  // changed from a date on, in order ([] = never); `repeats` above is the part in effect now
+  segments: z.array(EventSegment),
   // push topics told about date, time or place changes (Admin → Mobile app → When an event changes); [] = none
   notify: z.object({ changes: strings }),
 });
 export const Events = z.object({ locale, timezone: str, from: date, to: date, pagination: Pagination,
-  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom), event: Event })),
+  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, location: OccurrencePlace, rooms: z.array(EventRoom), event: Event })),
 });
 const Snippet = z.object({ text: str, highlights: z.array(z.object({ start: z.number().int(), end: z.number().int() })) });
 const ContentHit = ContentSummary.extend({ snippet: Snippet });
-export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom) }).nullable(), event: Event });
+export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, location: OccurrencePlace, rooms: z.array(EventRoom) }).nullable(), event: Event });
 export const SearchResults = z.object({ locale, query: str,
   posts: z.array(ContentHit), pages: z.array(ContentHit),
-  events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom) }).nullable(), event: Event })),
+  events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, location: OccurrencePlace, rooms: z.array(EventRoom) }).nullable(), event: Event })),
   more: z.object({ posts: bool, pages: bool, events: bool }),
 });
 const Icon = z.object({ type: z.enum(['svg', 'image', 'emoji']), value: str }).nullable();