@acms-subir/core 0.3.55 → 0.3.57

package/src/components/calendar/CalendarBoard.tsx

@@ -17,6 +17,8 @@ import '../../styles/schedule.css';
 
 type View = 'month' | 'week';
 type MoveUndo = { kind: 'series'; id: string; days: number; minutes?: number }
+  // this and following dates: the event's segments as they were (lib/calendar/segments.ts)
+  | { kind: 'following'; id: string; from: string; previous: { from: string; start: string; end: string; rrule?: string }[] }
   | { kind: 'date'; id: string; key: string; previous: { start: string; end: string; roomIds?: string[]; note: string } | null }
   | { kind: 'split'; id: string; seriesId: string; occurrence: string };
 
@@ -195,12 +197,12 @@ export default function CalendarBoard(props: Props) {
   // ---- moving ----------------------------------------------------------------
   const dayLabel = (d: Iso, o: Intl.DateTimeFormatOptions = { weekday: 'short', month: 'short', day: 'numeric' }) =>
     new Intl.DateTimeFormat(locale, { ...o, timeZone: 'UTC' }).format(utc(d));
-  async function move(item: BoardItem, days: number, minutes: number, mode: 'series' | 'one', to: Iso) {
+  async function move(item: BoardItem, days: number, minutes: number, mode: 'series' | 'one' | 'following', to: Iso) {
     setAsk(null);
     const r = await actions.events.move({ id: item.id, days, minutes, mode, occurrence: item.occurrence });
     if (r.error || !r.data) { setToast({ text: r.error?.message ?? 'Couldn’t move the event.', error: true }); return; }
     const when = !item.allDay && (minutes || view === 'week') ? `${dayLabel(to)}, ${shortTime(Math.max(0, Math.min(1439, item.startMin + minutes)))}` : dayLabel(to);
-    setToast({ text: `Moved “${item.title}” to ${when}`, undo: r.data.undo as MoveUndo, warning: r.data.warning || undefined });
+    setToast({ text: mode === 'following' ? `Moved “${item.title}” to ${when} and every date after it` : `Moved “${item.title}” to ${when}`, undo: r.data.undo as MoveUndo, warning: r.data.warning || undefined });
     await refresh();
   }
   async function moveBack(it: BoardItem) {
@@ -612,9 +614,10 @@ export default function CalendarBoard(props: Props) {
         <div className="sch-peek-layer center" onMouseDown={(e) => { if (e.target === e.currentTarget) setAsk(null); }}>
           <div className="sch-ask" role="alertdialog" aria-label={`Move ${ask.item.title}`}>
             <b>Move “{ask.item.title}”?</b>
-            <p>This event repeats. Move only {dayLabel(ask.item.startDay, { weekday: 'long', month: 'short', day: 'numeric' })}, or every date in the series?</p>
+            <p>This event repeats. Move only {dayLabel(ask.item.startDay, { weekday: 'long', month: 'short', day: 'numeric' })}, that date and the ones after it (the dates before stay), or every date in the series?</p>
             <div className="sch-ask-actions">
               <button type="button" className="btn primary" onClick={() => move(ask.item, ask.days, ask.minutes, 'one', ask.to)}>Only this date</button>
+              <button type="button" className="btn" onClick={() => move(ask.item, ask.days, ask.minutes, 'following', ask.to)}>This and following dates</button>
               <button type="button" className="btn" onClick={() => move(ask.item, ask.days, ask.minutes, 'series', ask.to)}>Every date</button>
               <button type="button" className="btn ghost" onClick={() => setAsk(null)}>Cancel</button>
             </div>

package/src/components/editor/event/SingleDates.tsx

@@ -1,16 +1,32 @@
 import { useEffect, useState } from 'react';
 import { actions } from 'astro:actions';
 import { Section } from './Section';
+import { describeRepeat, rruleMap, WEEKDAY_CODES, weekdayOf } from '../../../lib/calendar/rrule';
 
 // Event settings → Single dates: the next dates of a saved repeating event,
-// each with Move… and Cancel (or Move back / Restore). These apply at once,
-// like on the Schedule, without touching unpublished edits: a moved date keeps
-// its sign-ups (they're emailed the new time) and its hosts
-// (lib/calendar/moves.ts). The list shows the event as saved.
+// each with Move…, From here on… and Cancel (or Move back / Restore). These
+// apply at once, like on the Schedule, without touching unpublished edits: a
+// moved date keeps its sign-ups (they're emailed the new time) and its hosts
+// (lib/calendar/moves.ts). From here on… changes the series from that date
+// on, and the dates before it stay (lib/calendar/segments.ts); the changes
+// are listed above the dates with Undo. The list shows the event as saved.
 
-interface DateRow { key: string; start: string; end: string; when: string; cancelled: boolean; moved: { from: string; note: string } | null; roomIds: string[] }
-interface Data { allDay: boolean; roomIds: string[]; dates: DateRow[]; rooms: { id: string; name: string }[] }
-interface Form { key: string; day: string; endDay: string; from: string; to: string; roomIds: string[]; note: string }
+interface DateRow { key: string; start: string; end: string; when: string; cancelled: boolean; partCancelled: boolean; moved: { from: string; note: string } | null; roomIds: string[] }
+interface SegmentRow { from: string; when: string; repeats: string; rooms: string[]; cancelled: boolean; note: string; current: boolean }
+interface Data { allDay: boolean; roomIds: string[]; dates: DateRow[]; rooms: { id: string; name: string }[]; segments: SegmentRow[] }
+interface Form { key: string; day: string; endDay: string; from: string; to: string; roomIds: string[]; note: string; following?: { rrule: string; keep: string } }
+
+// the repeats a change from a date on can take, for its first day: the rule
+// in effect moved there (`keep`), or a common one, ending as `keep` ends
+function repeatOptions(day: string, keep: string): { value: string; label: string }[] {
+  const wd = weekdayOf(day);
+  const code = WEEKDAY_CODES[wd.dow];
+  const p = rruleMap(keep);
+  const ends = p.COUNT ? `;COUNT=${p.COUNT}` : p.UNTIL ? `;UNTIL=${p.UNTIL}` : '';
+  const rules = [`FREQ=WEEKLY;BYDAY=${code}`, `FREQ=WEEKLY;INTERVAL=2;BYDAY=${code}`, `FREQ=MONTHLY;BYDAY=${wd.nth >= 5 ? -1 : wd.nth}${code}`, `FREQ=MONTHLY;BYMONTHDAY=${wd.day}`, 'FREQ=DAILY']
+    .map((r) => r + ends).filter((r) => r !== keep);
+  return [{ value: keep, label: `${describeRepeat(keep, day) || 'Same as now'} (as now)` }, ...rules.map((r) => ({ value: r, label: describeRepeat(r, day) })), { value: '', label: 'Just this date (no more after it)' }];
+}
 
 const datePart = (w: string) => w.slice(0, 10);
 const timePart = (w: string) => w.slice(11, 16);
@@ -28,12 +44,22 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
   };
   useEffect(() => { if (eventId && repeats) void load(); }, [eventId, repeats, limit]);
 
-  if (!eventId || !repeats || !data || !data.dates.length) return null;
-
   const open = (d: DateRow) => {
     setNote(null);
     setForm({ key: d.key, day: datePart(d.start), endDay: datePart(d.end), from: timePart(d.start), to: timePart(d.end), roomIds: d.roomIds, note: d.moved?.note ?? '' });
   };
+  // ?move=<key> (approving a request to change one date, Calendar → Requests)
+  // opens that date's Move…, looking further ahead when it isn't in the first few
+  const [wanted, setWanted] = useState(() => (typeof location === 'undefined' ? '' : new URLSearchParams(location.search).get('move') ?? ''));
+  useEffect(() => {
+    if (!wanted || !data) return;
+    const d = data.dates.find((x) => x.key === wanted);
+    if (d) { open(d); setWanted(''); requestAnimationFrame(() => document.getElementById('ev-dates')?.scrollIntoView({ block: 'start' })); }
+    else if (limit < 52) setLimit(52);
+    else setWanted('');
+  }, [data, wanted]);
+
+  if (!eventId || !repeats || !data || !data.dates.length) return null;
   const run = async (key: string, work: () => Promise<{ error?: { message: string }; data?: object }>, done: string) => {
     setBusy(key);
     const r = await work();
@@ -44,15 +70,50 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
     setNote({ text: warning ? `${done} ${warning}` : done });
     await load();
   };
+  // From here on…: the date's times, the rule in effect there and its rooms to start with
+  const openFollowing = async (d: DateRow) => {
+    setNote(null);
+    const r = await actions.events.fromDateDefaults({ id: eventId, key: d.key });
+    if (r.error || !r.data) { setNote({ text: r.error?.message ?? 'Couldn’t open that date.', error: true }); return; }
+    const x = r.data;
+    setForm({ key: d.key, day: datePart(x.start), endDay: datePart(x.end), from: timePart(x.start), to: timePart(x.end), roomIds: x.roomIds, note: '', following: { rrule: x.rrule, keep: x.rrule } });
+  };
   const save = (f: Form) => {
     const start = data.allDay ? f.day : `${f.day}T${f.from}`;
     // a time that ends before it starts runs past midnight
     const end = data.allDay ? (f.endDay >= f.day ? f.endDay : f.day) : `${f.to <= f.from ? nextDay(f.day) : f.day}T${f.to}`;
+    if (f.following) {
+      // the kept rule follows the new first day on the server; a chosen one is sent as it is
+      const rrule = f.following.rrule === f.following.keep ? undefined : f.following.rrule;
+      return run(f.key, async () => {
+        const r = await actions.events.changeFromDate({ id: eventId, key: f.key, start, end, rrule, roomIds: f.roomIds, note: f.note });
+        if (r.data && !r.data.changed) return { data: { warning: '' } };
+        return r;
+      }, 'Changed from this date on. Dates before it stay as they were, and people who signed up were emailed their new dates.');
+    }
     return run(f.key, () => actions.events.moveDate({ id: eventId, key: f.key, start, end, roomIds: f.roomIds, note: f.note }), 'Moved. People who signed up were emailed the new time.');
   };
 
   return (
-    <Section id="ev-dates" title="Single dates" help="Move or cancel one date. It applies at once, even on a published event, and people who signed up for it are emailed.">
+    <Section id="ev-dates" title="Single dates" help="Move or cancel one date, or change every date from one on. It applies at once, even on a published event, and people who signed up are emailed.">
+      {data.segments.length > 0 && (
+        <ul className="pe-evd pe-evd-segs">
+          {data.segments.map((g) => (
+            <li key={g.from} className={`pe-evd-row${g.cancelled ? ' is-cancelled' : ' is-moved'}`}>
+              <div className="pe-evd-main">
+                <span className="pe-evd-when">{g.cancelled ? `Cancelled from ${g.when}` : `From ${g.when}: ${g.repeats}`}</span>
+                {(g.rooms.length > 0 || g.note) && <small className="pe-evd-state">{[g.rooms.join(', '), g.note && `“${g.note}”`].filter(Boolean).join(' · ')}</small>}
+              </div>
+              {!g.current && (
+                <div className="pe-evd-acts">
+                  <button type="button" className="pe-btn sm" disabled={busy === g.from}
+                    onClick={() => { if (confirm(`Undo the change from ${g.when}? Those dates go back to the pattern before it, and people who signed up are emailed.`)) void run(g.from, () => actions.events.revertFromDate({ id: eventId, from: g.from }), 'Change undone.'); }}>Undo</button>
+                </div>
+              )}
+            </li>
+          ))}
+        </ul>
+      )}
       <ul className="pe-evd">
         {data.dates.map((d) => (
           <li key={d.key} className={`pe-evd-row${d.cancelled ? ' is-cancelled' : d.moved ? ' is-moved' : ''}`}>
@@ -62,11 +123,12 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
               {d.moved && <small className="pe-evd-state">Moved from {d.moved.from}{d.moved.note ? ` · “${d.moved.note}”` : ''}</small>}
             </div>
             <div className="pe-evd-acts">
-              {d.cancelled ? (
+              {d.partCancelled ? null : d.cancelled ? (
                 <button type="button" className="pe-btn sm" disabled={busy === d.key} onClick={() => run(d.key, () => actions.events.cancelDate({ id: eventId, occurrence: d.key, restore: true }), 'Restored.')}>Restore</button>
               ) : (
                 <>
-                  <button type="button" className="pe-btn sm" onClick={() => (form?.key === d.key ? setForm(null) : open(d))} aria-expanded={form?.key === d.key}>Move…</button>
+                  <button type="button" className="pe-btn sm" onClick={() => (form?.key === d.key && !form.following ? setForm(null) : open(d))} aria-expanded={form?.key === d.key && !form.following}>Move…</button>
+                  <button type="button" className="pe-btn sm" onClick={() => (form?.key === d.key && form.following ? setForm(null) : void openFollowing(d))} aria-expanded={Boolean(form?.key === d.key && form.following)}>From here on…</button>
                   {d.moved && <button type="button" className="pe-btn sm" disabled={busy === d.key} onClick={() => run(d.key, () => actions.events.moveDateBack({ id: eventId, key: d.key }), 'Moved back. People who signed up were emailed.')}>Move back</button>}
                   <button type="button" className="pe-btn ghost sm" disabled={busy === d.key}
                     onClick={() => { if (confirm(`Cancel ${d.when}? It shows as cancelled straight away, and people who signed up are emailed.`)) void run(d.key, () => actions.events.cancelDate({ id: eventId, occurrence: d.key, restore: false }), 'Cancelled.'); }}>Cancel date</button>
@@ -76,7 +138,7 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
             {form?.key === d.key && (
               <form className="pe-evd-form" onSubmit={(e) => { e.preventDefault(); void save(form); }}>
                 <div className="pe-evd-fields">
-                  <label className="pe-field"><span>{data.allDay ? 'From' : 'Date'}</span><input type="date" required value={form.day} onChange={(e) => setForm({ ...form, day: e.target.value })} /></label>
+                  <label className="pe-field"><span>{form.following ? 'First date' : data.allDay ? 'From' : 'Date'}</span><input type="date" required value={form.day} onChange={(e) => setForm({ ...form, day: e.target.value })} /></label>
                   {data.allDay ? (
                     <label className="pe-field"><span>To</span><input type="date" required value={form.endDay} min={form.day} onChange={(e) => setForm({ ...form, endDay: e.target.value })} /></label>
                   ) : (
@@ -86,9 +148,17 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
                     </>
                   )}
                 </div>
+                {form.following && (
+                  <label className="pe-field"><span>Repeats</span>
+                    <select value={form.following.rrule} onChange={(e) => setForm({ ...form, following: { ...form.following!, rrule: e.target.value } })}>
+                      {repeatOptions(form.day, form.following.keep).map((o) => <option key={o.value} value={o.value}>{o.label}</option>)}
+                    </select>
+                  </label>
+                )}
+                {form.following && <p className="pe-evd-hint">The new first date can be in the same week as this one. Dates before it stay as they are. Sign-ups, cancelled and moved dates go to the nearest new date within 3½ days; sign-ups with none are cancelled. People are emailed.</p>}
                 {data.rooms.length > 0 && (
                   <fieldset className="pe-evd-rooms">
-                    <legend>Rooms for this date</legend>
+                    <legend>{form.following ? 'Rooms from then on' : 'Rooms for this date'}</legend>
                     {data.rooms.map((r) => (
                       <label key={r.id} className="pe-evd-room">
                         <input type="checkbox" checked={form.roomIds.includes(r.id)}
@@ -98,11 +168,11 @@ export function SingleDates({ eventId, repeats }: { eventId: string; repeats: bo
                     ))}
                   </fieldset>
                 )}
-                <label className="pe-field"><span>Note <em>shown with the date, optional</em></span>
-                  <input type="text" maxLength={500} value={form.note} placeholder="Moved for the youth retreat" onChange={(e) => setForm({ ...form, note: e.target.value })} />
+                <label className="pe-field"><span>Note <em>{form.following ? 'in the email to people who signed up, optional' : 'shown with the date, optional'}</em></span>
+                  <input type="text" maxLength={500} value={form.note} placeholder={form.following ? 'We meet on Wednesdays from now on' : 'Moved for the youth retreat'} onChange={(e) => setForm({ ...form, note: e.target.value })} />
                 </label>
                 <div className="pe-evd-formacts">
-                  <button type="submit" className="pe-btn primary sm" disabled={busy === form.key}>{busy === form.key ? 'Moving…' : 'Move this date'}</button>
+                  <button type="submit" className="pe-btn primary sm" disabled={busy === form.key}>{busy === form.key ? (form.following ? 'Changing…' : 'Moving…') : form.following ? 'Change from this date on' : 'Move this date'}</button>
                   <button type="button" className="pe-btn ghost sm" onClick={() => setForm(null)}>Never mind</button>
                 </div>
               </form>

package/src/layouts/Admin.astro

@@ -5,6 +5,7 @@ import { BRAND } from '../lib/brand';
 import { CONTENT } from '../lib/content';
 import { CALENDAR, bookingsEnabled } from '../lib/calendar/config';
 import { ANNOUNCEMENTS } from '../lib/announcements/config';
+import { REQUESTS } from '../lib/calendar/request-config';
 import { OWNER_ENV } from '../lib/auth';
 import { validateRequestSession } from '../lib/auth/request';
 import { accessFor } from '../lib/permissions/access';
@@ -36,6 +37,8 @@ const [pages, posts, links, home, settings, sessionUser] = await Promise.all([
 ]);
 // pending booking requests, shown as a count on the Bookings nav item
 const pendingBookings = CALENDAR.enabled ? (await repo.listBookings({ from: Date.now(), statuses: ['pending'], ...(!bookingsEnabled() ? { kinds: ['rsvp'] as const as ['rsvp'] } : {}) })).length : 0;
+// event requests waiting for staff (acms({ requests })): a count on Requests
+const pendingAsks = REQUESTS.enabled ? await repo.requests.count({ states: ['pending'] }) : 0;
 const me = {
   name: sessionUser?.name || 'Admin',
   role: roleLabel(sessionUserId === OWNER_ENV ? 'owner' : sessionUser?.role ?? 'editor'),
@@ -74,6 +77,7 @@ const icons: Record<string, string> = {
   user: 'M12 12a4 4 0 1 0 0-8 4 4 0 0 0 0 8zM4 21a8 8 0 0 1 16 0',
   shield: 'M12 3l7 3v5c0 4.5-3 8.3-7 10-4-1.7-7-5.5-7-10V6zM9 12l2 2 4-4',
   calendar: 'M3 5.5h18v15H3zM3 10h18M8 3v4M16 3v4',
+  inbox: 'M3 13h5l1.5 3h5L16 13h5M5.5 5h13L21 13v6H3v-6z',
   calendars: 'M4 6h.01M4 12h.01M4 18h.01M8 6h12M8 12h12M8 18h12',
   bookings: 'M12 21a9 9 0 1 0 0-18 9 9 0 0 0 0 18zM12 7v5l3 2',
   resources: 'M3 21V9l9-5 9 5v12M9 21v-6h6v6',
@@ -130,6 +134,9 @@ const groups: { id: string; label: string; items: Item[] }[] = [
             : []),
           // TV screens: saved display links (lib/display), with private details behind their key
           ...(can('schedule.manage') ? [{ key: 'calendar:screens', label: 'Screens', href: '/admin/calendar/screens', icon: icons.monitor, count: null }] : []),
+          ...(REQUESTS.enabled && can('content.edit')
+            ? [{ key: 'calendar:requests', label: 'Requests', href: '/admin/calendar/requests', icon: icons.inbox, count: pendingAsks || null, attention: pendingAsks > 0 }]
+            : []),
         ],
       }]
     : []),

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