@acms-subir/core 0.3.55 → 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/email/service.ts

@@ -39,6 +39,11 @@ async function render(repo: ContentRepository, job: EmailJob, locals?: unknown,
     return { ...mail, to: job.recipient };
   }
   if (job.kind === 'form-alert') return formAlertMail(repo, job.recipient, JSON.parse(job.payload) as AlertPayload, origin);
+  // event requests without an account (lib/calendar/request-service.ts)
+  if (job.kind === 'calendar-request') {
+    const { requestMail } = await import('../calendar/request-mail');
+    return requestMail(repo, job.recipient, JSON.parse(job.payload), origin);
+  }
   if (job.kind === 'auth') {
     const payload = JSON.parse(job.payload);
     const token = await repo.email.token(payload.tokenId);
@@ -109,7 +114,7 @@ export async function dispatchEmail(repo: ContentRepository, locals?: unknown, l
       }
       await repo.email.pin(j,resolved.provider,resolved.fingerprint,config?.version || 0);
       if (await repo.email.suppressed(j.recipient)) { await repo.email.finish(j,{state:'suppressed',error:'Recipient is suppressed after a bounce or complaint.'}); continue; }
-      if (j.kind === 'booking' || j.kind === 'event-request') {
+      if (j.kind === 'booking' || j.kind === 'event-request' || j.kind === 'calendar-request') {
         const payload = JSON.parse(j.payload);
         if ((payload.kind === 'reminder' && !current.config.reminders) || (String(payload.kind).startsWith('staff-') && !current.config.staffNotifications)) {
           await repo.email.finish(j,{state:'cancelled',error:'Optional notification disabled.'}); continue;

package/src/lib/legal/app-privacy.ts

@@ -11,7 +11,7 @@ export interface AppPrivacyAnswers { rows: StoreRow[]; tracking: string; notes:
 export function appPrivacyAnswers(f: LegalFacts, privacyUrl: string): AppPrivacyAnswers {
   const rows: StoreRow[] = [];
   // apps can RSVP (or join a full date's waitlist) wherever the calendar is on; room bookings need bookings too
-  const contact = [...(f.bookings ? ['bookings'] : []), ...(f.calendar ? ['RSVPs (including waitlist requests)'] : []), ...(f.appForms ? ['forms'] : [])];
+  const contact = [...(f.bookings ? ['bookings'] : []), ...(f.calendar ? ['RSVPs (including waitlist requests)'] : []), ...(f.appForms ? ['forms'] : []), ...(f.requests.enabled ? ['event requests'] : [])];
   const sends = contact.length > 1 ? `${contact.slice(0, -1).join(', ')} or ${contact.at(-1)}` : contact[0];
   if (contact.length) {
     rows.push({
@@ -20,7 +20,7 @@ export function appPrivacyAnswers(f: LegalFacts, privacyUrl: string): AppPrivacy
       google: 'Personal info → Name, Email address, Phone number. Collected, not shared. Purpose: App functionality. Optional (people choose to send it).',
     });
     rows.push({
-      data: 'Answers typed into a form or booking question', when: `When someone sends ${sends} from the app`,
+      data: f.requests.enabled ? 'Answers typed into a form or booking question, and the message of an event request' : 'Answers typed into a form or booking question', when: `When someone sends ${sends} from the app`,
       apple: 'User Content → Other User Content. Purpose: App Functionality. Linked to the user. Not used for tracking.',
       google: 'App activity → Other user-generated content. Collected, not shared. Purpose: App functionality. Optional.',
     });

package/src/lib/legal/facts.ts

@@ -4,6 +4,7 @@ import type { Settings } from '../schema';
 import { CALENDAR, bookingsEnabled } from '../calendar/config';
 import { PUSH } from '../push/config';
 import { ANNOUNCEMENTS } from '../announcements/config';
+import { REQUESTS } from '../calendar/request-config';
 import { AUTH } from '../auth/config';
 import { EDITOR } from '../editor/config';
 import { SITE_ROLES } from '../roles';
@@ -44,6 +45,8 @@ export interface LegalFacts {
   googleCalendar: boolean;
   /** acms({ announcements }): urgent ones reach every device; read and closed state stays in the app */
   announcements: boolean;
+  /** acms({ requests }): event requests without an account, kept keepDays after the answer */
+  requests: { enabled: boolean; keepDays: number };
   analytics: { umami: boolean; replay: boolean; meta: boolean; tiktok: boolean };
   ai: boolean;
   offsiteBackups: boolean;
@@ -86,6 +89,7 @@ export async function legalFacts(repo: ContentRepository, settings: Settings, lo
     live: settings.live.mode !== 'off',
     googleCalendar: CALENDAR.enabled && await repo.gcal.account().then((a) => !!a && a.status !== 'setup').catch(() => false),
     announcements: ANNOUNCEMENTS.enabled,
+    requests: { enabled: REQUESTS.enabled, keepDays: settings.calendar.requests.keepDays },
     analytics: {
       umami: a.umami.enabled && !!a.umami.websiteId,
       replay: a.umami.enabled && !!a.umami.websiteId && a.umami.replay.enabled,

package/src/lib/legal/text-en.ts

@@ -49,6 +49,9 @@ export function privacyEn(f: LegalFacts, country: string): PolicySection[] {
   s.push({ id: 'forms', title: 'Forms', text: [
     `When you send a form, we store your answers as you entered them (for example your name, email address or phone number, if the form asks for them) and when you sent it. Staff with access to form responses can read and export them. We don’t store your IP address with a response.${f.email ? ' Responses, or a notice that one arrived, may be emailed to the staff who handle that form.' : ''}`,
   ] });
+  if (f.requests.enabled) s.push({ id: 'requests', title: 'Event requests', text: [
+    `When you ask us for an event, or a change to one, on this site${app ? ' or in our app' : ''}, we store your name, email address, any phone number, the language you used, the details you give (what, when, which rooms, how many people) and your message. We use them only to answer your request: staff who manage the calendar read it, and we email you that it arrived and our answer. Your contact details never appear on a published event. We delete a request ${days(f.requests.keepDays)} after we answer it, or ${days(f.requests.keepDays)} after it arrives if we never do; site backups may keep a copy for a while longer.`,
+  ] });
   if (f.guestSignIn) s.push({ id: 'guest', title: 'Signing in to see your bookings', text: [
     'To see your bookings in our app, you can sign in with your email address. We email you a six-digit code that expires after 10 minutes. We keep your email address and that sign-in on your device until you sign out or don’t use it for 90 days.',
   ] });

package/src/lib/legal/text-es.ts

@@ -50,6 +50,9 @@ export function privacyEs(f: LegalFacts, country: string): PolicySection[] {
   s.push({ id: 'forms', title: 'Formularios', text: [
     `Cuando envía un formulario, guardamos sus respuestas tal como las escribió (por ejemplo su nombre, correo o teléfono, si el formulario los pide) y la fecha en que lo envió. El personal con acceso a las respuestas puede leerlas y exportarlas. No guardamos su dirección IP con la respuesta.${f.email ? ' Sus respuestas, o un aviso de que llegaron, pueden enviarse por correo al personal que atiende ese formulario.' : ''}`,
   ] });
+  if (f.requests.enabled) s.push({ id: 'requests', title: 'Solicitudes de eventos', text: [
+    `Cuando nos pide un evento, o un cambio a uno, en este sitio${app ? ' o en nuestra app' : ''}, guardamos su nombre, su correo electrónico, el teléfono si lo da, el idioma que usó, los detalles que nos da (qué, cuándo, qué salones, cuántas personas) y su mensaje. Los usamos solo para responder a su solicitud: el personal que administra el calendario la lee, y le escribimos por correo que llegó y nuestra respuesta. Sus datos de contacto nunca aparecen en un evento publicado. Borramos la solicitud ${days(f.requests.keepDays)} después de responderla, o ${days(f.requests.keepDays)} después de recibirla si no la respondemos; las copias de seguridad del sitio pueden conservar una copia un tiempo más.`,
+  ] });
   if (f.guestSignIn) s.push({ id: 'guest', title: 'Inicio de sesión para ver sus reservaciones', text: [
     'Para ver sus reservaciones en nuestra app, puede iniciar sesión con su correo electrónico. Le enviamos un código de seis dígitos que vence a los 10 minutos. Guardamos su correo y esa sesión en su dispositivo hasta que la cierre o pasen 90 días sin usarla.',
   ] });