@acms-subir/core 0.3.55 → 0.3.57

package/src/lib/calendar/events.ts

@@ -1,9 +1,9 @@
 // Native events: wall-clock time math, recurrence expansion (reusing the ICS
 // expander, so feed events and native events follow identical rules),
 // visibility, and "add to calendar" links. Pure — no repo, no fetch.
-import type { CalEvent, Calendar, EventLocation, MovedDate, Settings } from '../schema';
+import type { CalEvent, Calendar, EventLocation, MovedDate, SeriesSegment, Settings } from '../schema';
 import { expandVEvents, tzParts, zonedToUtc, type CalendarWindow, type IcsTime, type VEvent } from './ics';
-import { cleanRrule } from './rrule';
+import { cleanRrule, describeRepeat } from './rrule';
 import { eventStrings } from './event-words';
 
 const DAY = 86_400_000;
@@ -130,6 +130,11 @@ export interface Occurrence {
   roomIds: string[];
   // this date was moved here (CalEvent.movedDates): where it was, and why
   moved?: OccurrenceMove;
+  // the part of the series it belongs to, when the series changed from a
+  // date on (CalEvent.segments): that segment's `from` key
+  segment?: string;
+  // the date's own place (a moved date's, or its segment's), when not the event's
+  location?: EventLocation;
 }
 
 export interface OccurrenceMove {
@@ -141,13 +146,105 @@ export interface OccurrenceMove {
   location?: EventLocation;
 }
 
-/** Every room an event may hold: its own and any a moved date holds instead. */
-export function eventRoomIds(e: Pick<CalEvent, 'roomHold' | 'movedDates'>): string[] {
+/** Every room an event may hold: its own and any a moved date or a segment holds instead. */
+export function eventRoomIds(e: Pick<CalEvent, 'roomHold' | 'movedDates'> & { segments?: CalEvent['segments'] }): string[] {
   const ids = new Set(e.roomHold?.resourceIds ?? []);
   for (const m of Object.values(e.movedDates ?? {})) for (const id of m.roomIds ?? []) ids.add(id);
+  for (const seg of e.segments ?? []) for (const id of seg.roomIds ?? []) ids.add(id);
   return [...ids];
 }
 
+// ---- segments ------------------------------------------------------------
+// A series changed from a date on (CalEvent.segments) is one event made of
+// parts: its own rule up to the first segment's `from`, then each segment's
+// rule (from its own first date) up to the next one's `from`. A part's dates
+// stop at the day of the next part's `from` (wall-clock in the event's
+// zone), so retiming the earlier rule never leaves a second date on that
+// day. A date of any part is like any other: cancelled, moved and skipped by
+// its own key.
+
+/** One part of a series: the event's own rule (`from` '') or a segment. */
+export interface SeriesPart {
+  /** the segment's `from` key; '' for the event's own rule */
+  from: string;
+  /** the next part's `from` ('' = none): this part's dates from that day on are gone (cutsAt) */
+  until: string;
+  start: string;
+  end: string;
+  rrule: string;
+  roomIds: string[];
+  location?: EventLocation;
+  cancelled: boolean;
+  note: string;
+}
+
+/** Whether a part that stops at `until` (a key; '' = never) has no date at `key`: from that day on, it's the next part's. */
+export const cutsAt = (until: string, key: string) => Boolean(until) && key.slice(0, 10) >= until.slice(0, 10);
+
+/** The parts of an event's series, in order (just its own rule when it has no segments or doesn't repeat). */
+export function seriesParts(e: Pick<CalEvent, 'start' | 'end' | 'rrule' | 'allDay' | 'roomHold'> & { segments?: SeriesSegment[] }): SeriesPart[] {
+  const own: SeriesPart = { from: '', until: '', start: e.start, end: e.end, rrule: e.rrule, roomIds: e.roomHold?.resourceIds ?? [], cancelled: false, note: '' };
+  if (!e.rrule || !e.segments?.length) return [own];
+  // usable segments only: keys and times in the event's own form (all-day or timed)
+  const usable = e.segments.filter((g) => { const f = parseWall(g.from), st = parseWall(g.start); return f && st && f.dateOnly === e.allDay && st.dateOnly === e.allDay; })
+    .sort((a, b) => (a.from < b.from ? -1 : a.from > b.from ? 1 : 0));
+  const parts = [own, ...usable.map((g): SeriesPart => ({
+    from: g.from, until: '', start: g.start, end: g.end || g.start, rrule: g.rrule, roomIds: g.roomIds ?? e.roomHold?.resourceIds ?? [],
+    ...(g.location ? { location: g.location } : {}), cancelled: g.cancelled, note: g.note,
+  }))];
+  for (let i = 0; i < parts.length - 1; i++) parts[i].until = parts[i + 1].from;
+  return parts;
+}
+
+/** A part's dates' length in wall-clock minutes (all-day: whole days × 1440). */
+export function partMinutes(p: Pick<SeriesPart, 'start' | 'end'>): number {
+  const s = parseWall(p.start), en = parseWall(p.end) ?? s;
+  return s && en ? wallMinutesBetween(s, en) : 60;
+}
+
+/** The part of the series in effect at `now`: the one its next date (or, once all are over, its last) belongs to. */
+export function currentPart(e: CalEvent, settings: Pick<Settings, 'timezone'>, now = Date.now()): SeriesPart {
+  const parts = seriesParts(e);
+  if (parts.length === 1) return parts[0];
+  const o = featuredOccurrence(e, settings, now);
+  return o ? partOf(e, o) : parts[0];
+}
+
+/**
+ * The repeat line of a series in `locale`: the rule in effect now, then the
+ * next change still to come ("Weekly on Thursday · From Wed, Jan 16: Weekly
+ * on Wednesday"), or "Cancelled from …". `formatDate` writes UNTIL dates as
+ * describeRepeat's does; `dateLocale` the change's day (default: `locale`).
+ */
+export function describeSeries(e: CalEvent, settings: Pick<Settings, 'timezone'>, now: number, locale?: string, formatDate?: (ymd: string) => string, dateLocale?: string): string {
+  if (!e.rrule) return '';
+  const w = eventStrings(locale);
+  const parts = seriesParts(e);
+  const current = currentPart(e, settings, now);
+  const text = describeRepeat(current.rrule, current.start, formatDate, locale);
+  if (parts.length === 1) return text;
+  const tz = e.allDay ? settings.timezone || 'UTC' : eventTimeZone(e, settings);
+  const day = (ms: number) => {
+    try { return new Intl.DateTimeFormat(dateLocale || locale || 'en', { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz }).format(ms); }
+    catch { return new Date(ms).toISOString().slice(0, 10); }
+  };
+  const dates = expandEvents([e], settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: now - 400 * DAY, windowEndMs: now + 400 * DAY });
+  const firstOf = (p: SeriesPart) => dates.find((o) => (o.segment ?? '') === p.from);
+  const out = [current.cancelled ? fillWords(w.cancelledFrom, { date: firstOf(current) ? day(firstOf(current)!.start) : '' }) : text];
+  const next = parts[parts.findIndex((p) => p.from === current.from) + 1];
+  const first = next && firstOf(next);
+  if (next && first && first.start > now) {
+    out.push(next.cancelled ? fillWords(w.cancelledFrom, { date: day(first.start) })
+      : fillWords(w.fromDate, { date: day(first.start), repeat: describeRepeat(next.rrule, next.start, formatDate, locale) }));
+  }
+  return out.filter(Boolean).join(' · ');
+}
+const fillWords = (t: string, v: Record<string, string>) => t.replace(/\{(\w+)\}/g, (m, k: string) => v[k] ?? m);
+
+/** The part of the series a date belongs to (its occurrence's `segment`, '' for the event's own rule). */
+export const partOf = (e: Parameters<typeof seriesParts>[0], o: Pick<Occurrence, 'segment'>): SeriesPart =>
+  seriesParts(e).find((p) => p.from === (o.segment ?? '')) ?? seriesParts(e)[0];
+
 /**
  * The occurrence key for an occurrence start. Timed events use the event's
  * own zone; all-day occurrences start at midnight in the display zone (how
@@ -166,16 +263,21 @@ export function expandEvents(events: CalEvent[], settings: Pick<Settings, 'timez
   const out: Occurrence[] = [];
   for (const e of events) {
     const tz = eventTimeZone(e, settings);
-    const v = toVEvent(e, tz);
-    if (!v) continue;
     // ?? []: editor previews pass unsaved events that may lack the field
     const cancelledDates = new Set(e.cancelledDates ?? []);
     const moved = movedEntries(e);
-    for (const o of expandVEvents([v], tz, win, 0)) {
-      const key = occurrenceKey(e, o.start, settings, win.displayTz);
-      // a moved date comes out at its new time below
-      if (moved.has(key)) continue;
-      out.push({ event: e, start: o.start, end: o.end, allDay: o.allDay, days: o.days, key, cancelled: e.cancelled || cancelledDates.has(key), roomIds: e.roomHold?.resourceIds ?? [] });
+    for (const part of seriesParts(e)) {
+      const v = toVEvent(part.from ? { ...e, start: part.start, end: part.end, rrule: part.rrule } : e, tz);
+      if (!v) continue;
+      for (const o of expandVEvents([v], tz, win, 0)) {
+        const key = occurrenceKey(e, o.start, settings, win.displayTz);
+        // the next part has the dates from its `from` on; a moved date comes out at its new time below
+        if (cutsAt(part.until, key) || moved.has(key)) continue;
+        out.push({
+          event: e, start: o.start, end: o.end, allDay: o.allDay, days: o.days, key, cancelled: e.cancelled || part.cancelled || cancelledDates.has(key), roomIds: part.roomIds,
+          ...(part.from ? { segment: part.from } : {}), ...(part.location ? { location: part.location } : {}),
+        });
+      }
     }
     for (const [key, m] of moved) {
       const at = movedInstants(e, m, settings, win.displayTz);
@@ -230,10 +332,13 @@ function movedOccurrence(e: CalEvent, key: string, m: MovedDate, settings: Pick<
   const at = movedInstants(e, m, settings, displayTz);
   const was = at && seriesOccurrence(e, key, settings, displayTz);
   if (!at || !was) return null;
+  // its own rooms and place, else its part's (a segment's, or the event's)
+  const location = m.location ?? was.location;
   return {
-    event: e, start: at.start, end: at.end, allDay: e.allDay, days: at.days, key, cancelled: e.cancelled,
-    roomIds: m.roomIds ?? e.roomHold?.resourceIds ?? [],
+    event: e, start: at.start, end: at.end, allDay: e.allDay, days: at.days, key, cancelled: was.cancelled,
+    roomIds: m.roomIds ?? was.roomIds,
     moved: { from: { start: was.start, end: was.end }, note: m.note ?? '', ...(m.location ? { location: m.location } : {}) },
+    ...(was.segment ? { segment: was.segment } : {}), ...(location ? { location } : {}),
   };
 }
 
@@ -358,7 +463,7 @@ const dateStamp = (ms: number, tz: string) => {
 
 export function addToCalendarLinks(
   e: CalEvent,
-  o: Pick<Occurrence, 'start' | 'end' | 'allDay'>,
+  o: Pick<Occurrence, 'start' | 'end' | 'allDay'> & Pick<Partial<Occurrence>, 'segment'>,
   opts: { pageUrl: string; icsUrl: string; tz: string }
 ): { google: string; outlook: string; ics: string } {
   const details = [e.excerpt, opts.pageUrl].filter(Boolean).join('\n\n');
@@ -371,7 +476,15 @@ export function addToCalendarLinks(
     location: loc,
   });
   if (!o.allDay) g.set('ctz', opts.tz);
-  const rule = cleanRrule(e.rrule);
+  // the rule of the part of the series this date is in, stopped where the next part takes over
+  const part = partOf(e, o);
+  let rule = cleanRrule(part.rrule);
+  const cut = parseWall(part.until);
+  if (rule && cut) {
+    const ends = rule.split(';').filter((x) => !/^(COUNT|UNTIL)=/.test(x));
+    const last = zonedToUtc(cut.y, cut.m, cut.d, 0, 0, 0, opts.tz) - 1000;
+    rule = [...ends, o.allDay ? `UNTIL=${dateStamp(last, opts.tz)}` : `UNTIL=${utcStamp(last)}`].join(';');
+  }
   if (rule) g.set('recur', `RRULE:${rule}`);
   const iso = (ms: number) => new Date(ms).toISOString();
   const ol = new URLSearchParams({

package/src/lib/calendar/google/map.ts

@@ -396,7 +396,7 @@ export function asSiteEvent(f: Fields, settings: Pick<Settings, 'timezone'>, id
   return {
     id, slug: '', title: f.title, bodyJson: '', bodyHtml: '', excerpt: '', cover: '', coverAlt: '', seoTitle: '', seoDesc: '', status: 'published', featured: false,
     tags: [], template: '', start: f.when.start, end: f.when.end, allDay: f.when.allDay, timezone, rrule: f.repeat.rrule, exdates: f.repeat.exdates, cancelled: false,
-    cancelledDates: [], movedDates: {}, location: EventLocation.parse({ name: f.place }), cta: { label: '', href: '', style: 'primary' }, calendarIds: [], fields: {},
+    cancelledDates: [], movedDates: {}, segments: [], location: EventLocation.parse({ name: f.place }), cta: { label: '', href: '', style: 'primary' }, calendarIds: [], fields: {},
     sourceUid: '', rsvp: { enabled: false, capacity: 0, autoConfirm: true, maxSeats: 4, closesAt: null, closeBefore: 0, notifyStaff: true, waitlist: false },
     roomHold: { resourceIds: [], span: 'event', before: 0, after: 0, whileDraft: false, keep: [] }, hostIds: [], request: null, startAt, endAt,
     translations: {}, draft: null, publishedAt: null, scheduledAt: null, createdAt: 0, updatedAt: 0,

package/src/lib/calendar/host-requests.ts

@@ -6,7 +6,9 @@
 // - 'approve': every host move, and every move back, is a request.
 // Requests are rows in event_requests (repo.requests, RequestRecord kind
 // 'move', data: MoveRequestData) that staff who can publish approve (the move
-// runs as them, recorded as the host's) or decline with a note.
+// runs as them, recorded as the host's) or decline with a note. A host's
+// "Change from this date on" (C4) is always a request (kind 'from-date', data:
+// FromDateRequestData), which staff apply with changeFromDate (segments.ts).
 //
 // Like requests.ts, everything checks who is acting, so the built-in My
 // events page and a site's own pages share the rules. Hosts need no
@@ -17,7 +19,9 @@ import type { CalEvent, RequestRecord } from '../schema';
 import { ApiError, coded } from '../api';
 import type { SaveHooks } from '../content-service';
 import { GOOGLE_SYNC, checkMove, moveOccurrence, moveOccurrenceBack, type MoveInput, type MoveResult } from './moves';
-import { eventTimeZone, findOccurrence, type Occurrence } from './events';
+import { changeFromDate, checkChangeFromDate, type ChangeFromInput, type ChangeFromResult } from './segments';
+import { eventRoomIds, eventTimeZone, findOccurrence, type Occurrence } from './events';
+import { describeRepeat } from './rrule';
 import { MEMBERS } from './members-config';
 import { siteLocale } from '../dates';
 import { kickEmail } from '../email/service';
@@ -38,6 +42,16 @@ export interface MoveRequestData {
   back?: boolean;
 }
 
+/** RequestRecord.data of a 'from-date' request: the series from its `key` on (ChangeFromInput, checked); `rrule` '' = just that date */
+export interface FromDateRequestData {
+  start: string;
+  end: string;
+  rrule: string;
+  roomIds?: string[];
+  /** the note in the email to people who signed up */
+  note: string;
+}
+
 /** What a host's move did: moved at once (`moved`), or became a request (`request`). */
 export type HostMoveResult = { moved: MoveResult; request?: undefined } | { request: RequestRecord; moved?: undefined };
 
@@ -100,15 +114,40 @@ export async function requestDateMove(repo: ContentRepository, who: HostActor |
   const data: MoveRequestData = input && !check.back
     ? { start: check.start!, end: check.end!, ...(input.roomIds !== undefined ? { roomIds: [...new Set(input.roomIds)] } : {}), note: check.note ?? '' }
     : { start: '', end: '', note: '', back: true };
-  const note = text(message, LIMITS.note);
-  const waiting = (await repo.requests.list({ eventId: id, userId: who!.id, kinds: ['move'], states: ['pending'], limit: -1 })).find((r) => r.key === key);
+  return saveRequest(repo, who!, id, 'move', key, data, text(message, LIMITS.note), hooks);
+}
+
+/**
+ * A host asks staff to change their event from one date on (new first date,
+ * times, repeat, rooms): checked like the change itself, then saved as a
+ * pending 'from-date' request. Asking again from the same date replaces the
+ * waiting one. Rooms: the event's own and the requestable ones.
+ */
+export async function requestFromDate(repo: ContentRepository, who: HostActor | null, id: string, key: string, input: ChangeFromInput, message: string, hooks: SaveHooks): Promise<RequestRecord> {
+  const e = await hosted(repo, who, id);
+  if (!e.hostIds.includes(who!.id)) throw coded(404, 'not-found', 'Event not found.');
+  if (input.roomIds !== undefined) {
+    const allowed = new Set([...eventRoomIds(e), ...(await repo.listResources()).filter((r) => r.requestable).map((r) => r.id)]);
+    if (input.roomIds.some((r) => !allowed.has(r))) throw coded(403, 'room-not-allowed', 'Pick from the rooms this event uses, or ask the team for another room.');
+  }
+  const check = await checkChangeFromDate(repo, who!, id, key, { ...input, location: undefined });
+  if (!check.changed) throw coded(400, 'unchanged', 'The dates from then on are already like that.');
+  if (!await repo.email.rateLimit(`event-request:${who!.id}`, 20, 3_600_000)) throw coded(429, 'rate-limit', 'That’s a lot of requests in an hour. Try again later.', 3600);
+  const g = check.segment;
+  const data: FromDateRequestData = { start: g.start, end: g.end, rrule: g.rrule, ...(input.roomIds !== undefined ? { roomIds: [...new Set(input.roomIds)] } : {}), note: g.note };
+  return saveRequest(repo, who!, e.id, 'from-date', key, data, text(message, LIMITS.note), hooks);
+}
+
+// a host's waiting request about this date (and kind) is replaced; else a new one
+async function saveRequest(repo: ContentRepository, who: HostActor, eventId: string, kind: 'move' | 'from-date', key: string, data: object, note: string, hooks: SaveHooks) {
+  const waiting = (await repo.requests.list({ eventId, userId: who.id, kinds: [kind], states: ['pending'], limit: -1 })).find((r) => r.key === key);
   let saved: RequestRecord | null;
   if (waiting) saved = await repo.requests.update(waiting.id, { data: { ...data }, note }, { state: 'pending' });
   else {
-    if (await repo.requests.count({ userId: who!.id, states: ['pending'] }) >= LIMITS.pending) throw coded(429, 'too-many-waiting', 'You have many requests waiting already. Wait for the team to answer them first.');
+    if (await repo.requests.count({ userId: who.id, states: ['pending'] }) >= LIMITS.pending) throw coded(429, 'too-many-waiting', 'You have many requests waiting already. Wait for the team to answer them first.');
     const now = Date.now();
-    saved = await repo.requests.create({ id: crypto.randomUUID(), kind: 'move', state: 'pending', source: 'member', userId: who!.id, requester: null,
-      eventId: id, key, data: { ...data }, note, reply: '', reviewedBy: '', reviewedAt: 0, createdAt: now, updatedAt: now });
+    saved = await repo.requests.create({ id: crypto.randomUUID(), kind, state: 'pending', source: 'member', userId: who.id, requester: null,
+      eventId, key, data: { ...data }, note, reply: '', reviewedBy: '', reviewedAt: 0, createdAt: now, updatedAt: now });
   }
   if (!saved) throw coded(409, 'answered', 'That request was just answered. Look at My events again.');
   await alertStaff(repo, saved, hooks);
@@ -162,10 +201,19 @@ async function answerable(repo: ContentRepository, id: string, seen?: number): P
 }
 
 /** Staff approve a host's move request: the move runs as them (room clashes warn), recorded as the host's, and the host is emailed. Pass `seen` (the request's updatedAt they reviewed). */
-export async function approveDateRequest(repo: ContentRepository, who: HostActor | null, id: string, hooks: SaveHooks, seen?: number): Promise<{ request: RequestRecord; moved: MoveResult }> {
+export async function approveDateRequest(repo: ContentRepository, who: HostActor | null, id: string, hooks: SaveHooks, seen?: number): Promise<{ request: RequestRecord; moved?: MoveResult; changed?: ChangeFromResult }> {
   requireApprover(who);
   const r = await answerable(repo, id, seen);
-  if (r.kind !== 'move') throw coded(400, 'unavailable', 'Open the event to apply this change.');
+  if (r.kind === 'from-date') {
+    const f = r.data as FromDateRequestData;
+    const when = await dateRequestWhen(repo, r);
+    const request = await claim(repo, r, who);
+    let changed: ChangeFromResult;
+    try { changed = await changeFromDate(repo, who, r.eventId, r.key, { start: f.start, end: f.end, rrule: f.rrule, roomIds: f.roomIds, note: f.note }, hooks); }
+    catch (err) { await release(repo, id); throw err; }
+    await tellHost(repo, request, 'from-date-approved', '', when, hooks);
+    return { request, changed };
+  }
   const d = r.data as MoveRequestData;
   // worded before it moves: "where it was → where it goes"
   const when = await dateRequestWhen(repo, r);
@@ -210,11 +258,18 @@ export async function dateRequestTimes(repo: ContentRepository, r: RequestRecord
   const settings = await repo.getSettings();
   const d = r.data as MoveRequestData;
   const tz = e.allDay ? settings.timezone || 'UTC' : eventTimeZone(e, settings);
-  const fmt = (o: Occurrence | null) => {
+  const fmt = (o: Pick<Occurrence, 'start'> | null) => {
     if (!o) return '';
     try { return new Intl.DateTimeFormat(siteLocale(settings), e.allDay ? { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz } : { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZone: tz }).format(o.start); }
     catch { return new Date(o.start).toISOString(); }
   };
+  if (r.kind === 'from-date') {
+    // "Thu, Jan 17, 6:00 PM" → "Wed, Jan 16, 5:00 PM · Weekly on Wednesday": the new first date and its repeat
+    const f = r.data as FromDateRequestData;
+    const first = findOccurrence({ ...e, start: f.start, end: f.end, rrule: f.rrule, segments: [], movedDates: {}, cancelledDates: [], exdates: [] }, f.start, settings);
+    const at = findOccurrence({ ...e, movedDates: {} }, r.key, settings);
+    return { from: fmt(at), to: [fmt(first), describeRepeat(f.rrule, f.start)].filter(Boolean).join(' · ') };
+  }
   const to = d.back ? findOccurrence({ ...e, movedDates: {} }, r.key, settings)
     : findOccurrence({ ...e, movedDates: { ...e.movedDates, [r.key]: { start: d.start, end: d.end, note: d.note, by: '', at: 0, ...(d.roomIds ? { roomIds: d.roomIds } : {}) } } }, r.key, settings);
   return { from: fmt(findOccurrence(e, r.key, settings)), to: fmt(to) };

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',