@acms-subir/core 0.3.56 → 0.3.57

package/src/lib/calendar/api.ts

@@ -7,6 +7,7 @@ import { roomColor, type CalEvent, type Calendar, type MovedDate, type Resource
 import { calendarFeedUrl, eventIcsUrl, eventUrl, publicEventFields } from './config';
 import { describeRepeat } from './rrule';
 import { localizeForm } from '../forms/localize';
+import { currentPart, seriesParts } from './events';
 
 export interface EventJson {
   id: string;
@@ -23,7 +24,10 @@ export interface EventJson {
   allDay: boolean;
   timezone: string;
   rrule: string;
+  // the repeat in words for the part of the series in effect now (a segment's, once it took over)
   repeats: string;
+  // the series changed from a date on (CalEvent.segments), in order; [] = never
+  segments: SegmentJson[];
   exdates: string[];
   cancelledDates: string[];
   // single dates at another time, by original occurrence key: the new wall
@@ -44,6 +48,18 @@ export interface EventJson {
 }
 
 export interface RoomJson { slug: string; name: string; color: string | null }
+/** One segment of a series: from which date (an occurrence key), its first date, rule, words, rooms and place (null = the event's) */
+export interface SegmentJson {
+  from: string;
+  start: string;
+  end: string;
+  rrule: string;
+  repeats: string;
+  cancelled: boolean;
+  note: string;
+  location: Pick<CalEvent['location'], 'name' | 'address' | 'url'> | null;
+  rooms: RoomJson[];
+}
 export type PublicMovedDate = Pick<MovedDate, 'start' | 'end' | 'note'> & Partial<MovedDate>;
 
 /** moved dates as public data: where and why, not who */
@@ -85,8 +101,13 @@ export function eventToJson(e: CalEvent, origin: string, calendars: Map<string,
     allDay: e.allDay,
     timezone: e.timezone || siteTz || 'UTC',
     rrule: e.rrule,
-    repeats: describeRepeat(e.rrule, e.start, opts.locale ? untilDate(opts.locale) : undefined, opts.locale),
-    exdates: e.exdates,
+    // the part of the series in effect now (a change from a date on, once it took over), in the request's language
+    repeats: ((p) => describeRepeat(p.rrule, p.start, opts.locale ? untilDate(opts.locale) : undefined, opts.locale))(currentPart(e, { timezone: siteTz })),
+    segments: seriesParts(e).slice(1).map((p) => ({
+      from: p.from, start: p.start, end: p.end, rrule: p.rrule, repeats: describeRepeat(p.rrule, p.start, opts.locale ? untilDate(opts.locale) : undefined, opts.locale), cancelled: p.cancelled, note: p.note,
+      location: p.location ? { name: p.location.name, address: p.location.address, url: p.location.url } : null,
+      rooms: roomsToJson(p.roomIds, opts.resources, opts.includePrivate),
+    })),    exdates: e.exdates,
     cancelledDates: e.cancelledDates ?? [],
     movedDates: movedDatesToJson(e, opts.includePrivate),
     location: e.location,

package/src/lib/calendar/board.ts

@@ -5,7 +5,7 @@
 import type { ContentRepository } from '../repo/types';
 import type { CalEvent, Settings } from '../schema';
 import { collectViewEvents } from './data';
-import { occurrenceKey, safeColor } from './events';
+import { occurrenceKey, partOf, safeColor } from './events';
 import { tzParts, zonedToUtc } from './ics';
 import { addDays, isIsoDay, type GridItem, type Iso } from './grid';
 import { bookingsEnabled } from './config';
@@ -134,7 +134,8 @@ export async function loadBoard(repo: ContentRepository, settings: Settings, fro
       calendarName: cal?.name ?? '',
       status: e ? eventBoardStatus(e) : 'feed',
       recurring: Boolean(e?.rrule),
-      repeat: e?.rrule ? describeRepeat(e.rrule, e.start) : '',
+      // the rule of the part of the series this date is in (CalEvent.segments)
+      repeat: e?.rrule ? ((p) => describeRepeat(p.rrule, p.start))(partOf(e, { segment: v.segment })) : '',
       rooms: e ? (v.rooms?.map((r) => r.id) ?? e.roomHold.resourceIds).map((id) => roomName.get(id)).filter((n): n is string => Boolean(n)) : [],
       roomsHeld: e ? holdsRooms(e) : false,
       occurrence,

package/src/lib/calendar/cards.ts

@@ -28,7 +28,7 @@ const esc = (s: string) =>
 export const safeHref = (h: string) => (/^(https?:\/\/|\/(?!\/)|mailto:|tel:|#)/i.test(h.trim()) ? h.trim() : '');
 
 export function eventCardHtml(
-  o: Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days'> & { cancelled?: boolean; moved?: Occurrence['moved'] },
+  o: Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days'> & { cancelled?: boolean; moved?: Occurrence['moved']; location?: Occurrence['location'] },
   settings: Settings,
   opts: { showImage: boolean; showCta?: boolean; href?: string; heading?: 'h2' | 'h3' }
 ): string {
@@ -48,7 +48,7 @@ export function eventCardHtml(
       ? `<a class="pc-ev-card-media" href="${esc(href)}" tabindex="-1" aria-hidden="true"><img src="${esc(image.src)}" alt="${esc(image.alt)}" loading="lazy" /></a>`
       : `<a class="pc-ev-card-media is-tile" href="${esc(href)}" tabindex="-1" aria-hidden="true"><span class="pc-ev-tile"><b>${esc(f.month)}</b><span>${esc(f.day)}</span></span></a>`
     : '';
-  const loc = locationLine(o.moved?.location ?? e.location);
+  const loc = locationLine(o.location ?? e.location);
   const ctaHref = safeHref(e.cta.href);
   const cta =
     opts.showCta && e.cta.label && ctaHref && !cancelled
@@ -80,11 +80,11 @@ export async function upcomingEvents(
     displayTz: tz, now, windowStartMs: now, windowEndMs: now + (opts.horizonDays ?? 400) * 86_400_000,
   }, { audience: 'public', calendarIds: opts.calendarIds, includeFeeds: false, filter: opts.filter, locale: opts.locale });
   const seen = new Set<string>();
-  const out: (Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days' | 'cancelled'> & Pick<Partial<Occurrence>, 'moved'> & Pick<ViewEvent, 'rooms'>)[] = [];
+  const out: (Pick<Occurrence, 'event' | 'start' | 'end' | 'allDay' | 'days' | 'cancelled'> & Pick<Partial<Occurrence>, 'moved' | 'location'> & Pick<ViewEvent, 'rooms'>)[] = [];
   for (const v of events) {
     if (!v.event || v.end <= now || seen.has(v.event.id) || !tagged(v.event.tags)) continue;
     seen.add(v.event.id);
-    out.push({ event: v.event, start: v.start, end: v.end, allDay: v.allDay, days: v.days, cancelled: Boolean(v.cancelled), ...(v.moved ? { moved: v.moved } : {}), rooms: v.rooms ?? [] });
+    out.push({ event: v.event, start: v.start, end: v.end, allDay: v.allDay, days: v.days, cancelled: Boolean(v.cancelled), ...(v.moved ? { moved: v.moved } : {}), ...(v.place ? { location: v.place } : {}), rooms: v.rooms ?? [] });
     if (out.length >= opts.limit) break;
   }
   return out;

package/src/lib/calendar/change-migration.ts

@@ -15,7 +15,8 @@
 //
 // Each migration's column lists are frozen: a later events column joins by a
 // new migration that recreates these triggers through eventChangeTriggers()
-// (the test that sorts every column fails until then). v66 added moved_dates.
+// (the test that sorts every column fails until then). v66 added moved_dates,
+// v70 segments.
 const now = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
 
 // v65's lists
@@ -27,9 +28,9 @@ const V65_COLUMNS = ['slug', 'title', 'body_json', 'body_html', 'excerpt', 'cove
   'location', 'cta', 'calendar_ids', 'fields', 'rsvp', 'translations', 'room_hold', 'start_at', 'end_at'];
 
 /** the columns copied into each snapshot (what the webhook payload and push rules read) */
-export const EVENT_CHANGE_SNAPSHOT = [...V65_SNAPSHOT, 'moved_dates'];
+export const EVENT_CHANGE_SNAPSHOT = [...V65_SNAPSHOT, 'moved_dates', 'segments'];
 /** the columns whose change counts (published_at and scheduled_at follow status; room_hold names the rooms public data shows) */
-export const EVENT_CHANGE_COLUMNS = [...V65_COLUMNS, 'moved_dates'];
+export const EVENT_CHANGE_COLUMNS = [...V65_COLUMNS, 'moved_dates', 'segments'];
 /** columns no change is recorded for */
 export const EVENT_CHANGE_IGNORED = ['id', 'draft', 'host_ids', 'request', 'source_uid', 'published_at', 'scheduled_at', 'created_at', 'updated_at'];
 
@@ -88,3 +89,16 @@ export const MOVED_DATES_MIGRATION = (contentVersionUpdate: string) => ({ versio
   `DROP TRIGGER event_changes_delete`,
   ...eventChangeTriggers([...V65_SNAPSHOT, 'moved_dates'], [...V65_COLUMNS, 'moved_dates']),
 ] });
+
+// v70: a series changed from one date on (CalEvent.segments: its rule, times,
+// rooms and place from then), a column on the row like moved_dates: public,
+// so it bumps the content version and its changes are recorded
+export const SEGMENTS_MIGRATION = (contentVersionUpdate: string) => ({ version: 70, statements: [
+  `ALTER TABLE events ADD COLUMN segments TEXT NOT NULL DEFAULT '[]'`,
+  `DROP TRIGGER content_version_events_update`,
+  contentVersionUpdate,
+  `DROP TRIGGER event_changes_insert`,
+  `DROP TRIGGER event_changes_update`,
+  `DROP TRIGGER event_changes_delete`,
+  ...eventChangeTriggers([...V65_SNAPSHOT, 'moved_dates', 'segments'], [...V65_COLUMNS, 'moved_dates', 'segments']),
+] });

package/src/lib/calendar/data.ts

@@ -7,7 +7,7 @@
 // details, lib/display: published events only, private calendars when it
 // names them, bookings with the booker's name, never emails, phones or notes).
 import type { ContentRepository } from '../repo/types';
-import { roomColor, type BookingLink, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
+import { roomColor, type BookingLink, type CalEvent, type Calendar, type EventLocation, type Resource, type Settings } from '../schema';
 import { eventIsListed, eventIsPublic, eventRoomIds, expandEvents, locationLine, safeColor, type OccurrenceMove } from './events';
 import { expandVEvents, loadFeed, tzParts, type CalendarEvent, type CalendarWindow } from './ics';
 import { CALENDAR, eventUrl, resourceUrl, withoutPrivateFields } from './config';
@@ -31,6 +31,10 @@ export interface ViewEvent extends CalendarEvent {
   key?: string;
   // this date was moved here: where it was (UTC ms) and the public note
   moved?: OccurrenceMove;
+  // native events changed from a date on: the segment this date belongs to (its `from` key)
+  segment?: string;
+  // native events: the date's own place (moved there, or its segment's), when not the event's
+  place?: EventLocation;
 }
 
 // color: '#rrggbb', or '' when the room has none
@@ -115,7 +119,8 @@ export async function collectViewEvents(
     events.push({
       start: o.start, end: o.end, allDay: o.allDay, days: o.days,
       title: e.title || words.untitled,
-      location: locationLine(o.moved?.location ?? e.location),
+      // the date's own place (moved there, or its segment's), else the event's
+      location: locationLine(o.location ?? e.location),
       description: e.excerpt,
       cal: cal ? idx.get(cal.id) ?? 0 : 0,
       ref: e.id,
@@ -129,6 +134,8 @@ export async function collectViewEvents(
       rooms: rooms(o.roomIds),
       key: o.key,
       ...(o.moved ? { moved: o.moved } : {}),
+      ...(o.segment ? { segment: o.segment } : {}),
+      ...(o.location ? { place: o.location } : {}),
     });
   }
 

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

@@ -22,6 +22,9 @@ export interface EventStrings {
   moved: string;
   dateMoved: string;
   dateMovedNote: string;
+  /** the series changed from a date on (describeSeries): "From {date}: {repeat}", and every date cancelled from one on */
+  fromDate: string;
+  cancelledFrom: string;
   /** the side column's landmark label */
   details: string;
   joinOnline: string;
@@ -135,6 +138,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Cancelled', eventCancelled: 'This event is cancelled.', eventCancelledNote: 'It stays listed so nobody is left wondering.',
     dateCancelled: 'Cancelled on {date}.', dateCancelledNote: 'Other dates go ahead as usual.',
     moved: 'Moved', dateMoved: 'Moved from {from}.', dateMovedNote: 'Other dates stay as usual.',
+    fromDate: 'From {date}: {repeat}', cancelledFrom: 'Cancelled from {date}',
     details: 'Event details', joinOnline: 'Join online', map: 'Map', directionsTo: 'Directions to {place}', mapOf: 'Map of {place}',
     directionsHere: 'Directions to the location', mapHere: 'Map of the location', showing: 'Showing {date}',
     addToCalendar: 'Add to calendar', downloadIcs: 'Download .ics', share: 'Share', linkCopied: 'Link copied',
@@ -168,6 +172,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Cancelado', eventCancelled: 'Este evento está cancelado.', eventCancelledNote: 'Lo dejamos en la lista para que nadie se quede con la duda.',
     dateCancelled: 'Cancelado el {date}.', dateCancelledNote: 'Las demás fechas siguen como siempre.',
     moved: 'Cambio de horario', dateMoved: 'Cambió de horario: antes era el {from}.', dateMovedNote: 'Las demás fechas siguen como siempre.',
+    fromDate: 'Desde el {date}: {repeat}', cancelledFrom: 'Cancelado desde el {date}',
     details: 'Detalles del evento', joinOnline: 'Unirse en línea', map: 'Mapa', directionsTo: 'Cómo llegar a {place}', mapOf: 'Mapa de {place}',
     directionsHere: 'Cómo llegar al lugar', mapHere: 'Mapa del lugar', showing: 'Mostrando el {date}',
     addToCalendar: 'Agregar al calendario', downloadIcs: 'Descargar .ics', share: 'Compartir', linkCopied: 'Enlace copiado',
@@ -201,6 +206,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Annulé', eventCancelled: 'Cet événement est annulé.', eventCancelledNote: 'Il reste affiché pour que personne ne se pose de questions.',
     dateCancelled: 'Annulé le {date}.', dateCancelledNote: 'Les autres dates sont maintenues.',
     moved: 'Déplacé', dateMoved: 'Déplacé : prévu initialement le {from}.', dateMovedNote: 'Les autres dates sont maintenues.',
+    fromDate: 'À partir du {date} : {repeat}', cancelledFrom: 'Annulé à partir du {date}',
     details: 'Détails de l’événement', joinOnline: 'Rejoindre en ligne', map: 'Carte', directionsTo: 'Itinéraire vers {place}', mapOf: 'Carte de {place}',
     directionsHere: 'Itinéraire vers le lieu', mapHere: 'Carte du lieu', showing: 'Date affichée : {date}',
     addToCalendar: 'Ajouter au calendrier', downloadIcs: 'Télécharger le .ics', share: 'Partager', linkCopied: 'Lien copié',
@@ -234,6 +240,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Abgesagt', eventCancelled: 'Diese Veranstaltung ist abgesagt.', eventCancelledNote: 'Sie bleibt sichtbar, damit sich niemand wundert.',
     dateCancelled: 'Abgesagt am {date}.', dateCancelledNote: 'Die anderen Termine finden wie gewohnt statt.',
     moved: 'Verschoben', dateMoved: 'Verschoben: ursprünglich am {from}.', dateMovedNote: 'Die anderen Termine finden wie gewohnt statt.',
+    fromDate: 'Ab {date}: {repeat}', cancelledFrom: 'Abgesagt ab {date}',
     details: 'Veranstaltungsdetails', joinOnline: 'Online teilnehmen', map: 'Karte', directionsTo: 'Route zu {place}', mapOf: 'Karte von {place}',
     directionsHere: 'Route zum Ort', mapHere: 'Karte des Ortes', showing: 'Angezeigt: {date}',
     addToCalendar: 'Zum Kalender hinzufügen', downloadIcs: '.ics herunterladen', share: 'Teilen', linkCopied: 'Link kopiert',
@@ -267,6 +274,7 @@ const STRINGS: Record<string, EventStrings> = {
     cancelled: 'Cancelado', eventCancelled: 'Este evento foi cancelado.', eventCancelledNote: 'Ele continua na lista para que ninguém fique na dúvida.',
     dateCancelled: 'Cancelado em {date}.', dateCancelledNote: 'As outras datas continuam normalmente.',
     moved: 'Remarcado', dateMoved: 'Remarcado: antes era em {from}.', dateMovedNote: 'As outras datas continuam normalmente.',
+    fromDate: 'A partir de {date}: {repeat}', cancelledFrom: 'Cancelado a partir de {date}',
     details: 'Detalhes do evento', joinOnline: 'Participar on-line', map: 'Mapa', directionsTo: 'Como chegar a {place}', mapOf: 'Mapa de {place}',
     directionsHere: 'Como chegar ao local', mapHere: 'Mapa do local', showing: 'Exibindo {date}',
     addToCalendar: 'Adicionar ao calendário', downloadIcs: 'Baixar .ics', share: 'Compartilhar', linkCopied: 'Link copiado',

package/src/lib/calendar/events.ts

@@ -1,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) };