@acms-subir/core 0.3.56 → 0.3.57

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @acms-subir/core
 
+## 0.3.57
+
+### Patch Changes
+
+- b9eed5e: Change a repeating event from one of its dates on, and keep the dates before it as they were.
+
+  - **One event.** When a class moves for good, from Thursdays 6 PM to Wednesdays 5 PM, the dates before the change stay exactly as they were, and it stays one event: the same page, slug, hosts, RSVPs and My events entry. Each change is a segment on the events row (`CalEvent.segments`, migration 70), with its own first date, repeat, rooms and place.
+  - **Where.** Change it from the event editor's Single dates (**From here on…**, with **Undo**), or drag a date on the Schedule and choose **This and following dates**. Hosts can ask with **Change from this date on…** on My events, and staff apply it from Requests.
+  - **What follows.** Sign-ups move to the new date nearest them within half a week, and each person is emailed the new time with your note. Cancelled, skipped and moved dates follow the same way. Sign-ups with no new date near them are cancelled, with the email. `npx acms docs calendar` has the rule.
+  - **Every output.** `/calendar`, the event page ("Weekly on Thursday · From Wed, Jan 9: Weekly on Wednesday"), cards, the TV display, room holds and the app API show the new dates. `calendar.ics` writes one VEVENT per part, as Google does for "this and following". The "When an event changes" rule sends one notice: "From Wed, Jan 9: Weekly on Wednesday, 5:00 PM".
+  - **API.** Events carry `segments` (`from`, `start`, `end`, `rrule`, `repeats`, `cancelled`, `note`, `location`, `rooms`). `repeats` is the rule in effect now, and each occurrence has its own `location`. Push data gains `change: 'fromDate' | 'cancelledFrom'`.
+  - **Server API.** `@acms-subir/core/server` adds `changeFromDate`, `cancelFromDate`, `restoreFromDate`, `revertFromDate` (staff and `GOOGLE_SYNC`, all idempotent, `quiet` for a sync) and `requestFromDate` for hosts.
+
 ## 0.3.56
 
 ### Patch Changes

package/cli/migrations.generated.mjs

@@ -283,8 +283,8 @@ var V65_COLUMNS = [
   "start_at",
   "end_at"
 ];
-var EVENT_CHANGE_SNAPSHOT = [...V65_SNAPSHOT, "moved_dates"];
-var EVENT_CHANGE_COLUMNS = [...V65_COLUMNS, "moved_dates"];
+var EVENT_CHANGE_SNAPSHOT = [...V65_SNAPSHOT, "moved_dates", "segments"];
+var EVENT_CHANGE_COLUMNS = [...V65_COLUMNS, "moved_dates", "segments"];
 var snapshotOf = (cols, row) => `json_object(${cols.map((c) => `'${c}',${row}.${c}`).join(",")})`;
 var live = "(SELECT suppressed FROM webhook_control WHERE id=1)=0";
 var quiet = "COALESCE((SELECT quiet FROM push_control WHERE id=1),0)";
@@ -331,6 +331,15 @@ var MOVED_DATES_MIGRATION = (contentVersionUpdate) => ({ version: 66, statements
   `DROP TRIGGER event_changes_delete`,
   ...eventChangeTriggers([...V65_SNAPSHOT, "moved_dates"], [...V65_COLUMNS, "moved_dates"])
 ] });
+var SEGMENTS_MIGRATION = (contentVersionUpdate) => ({ 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"])
+] });
 
 // src/lib/maps/migration.ts
 var PLACES_MIGRATION = { version: 43, statements: [
@@ -1351,12 +1360,15 @@ var MIGRATIONS = [
   { version: 68, statements: REQUEST_TABLE },
   // two-way Google Calendar sync: the account, links, pairs, outgoing queue
   // (triggers on events) and Recent changes. Not public, so no cache trigger.
-  GCAL_MIGRATION
+  GCAL_MIGRATION,
+  // a series changed from one date on (CalEvent.segments): a column on the
+  // row, so the triggers on events see it, like moved_dates
+  SEGMENTS_MIGRATION(contentVersionTriggers("events", [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates", "moved_dates", "segments"])[2])
 ];
 var CURRENT_CONTENT_VERSION_COLUMNS = {
   ...CONTENT_VERSION_COLUMNS,
   settings: [...CONTENT_VERSION_COLUMNS.settings, "links_verified", "links_avatar_shape", "links_avatar_fit", "links_avatar_scale", "legal"],
-  events: [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates", "moved_dates"],
+  events: [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates", "moved_dates", "segments"],
   resources: [...CONTENT_VERSION_COLUMNS.resources, "color", "show_on_events"],
   announcements: ANNOUNCEMENT_VISIBLE_COLUMNS
 };

package/docs/calendar.md

@@ -1,7 +1,7 @@
 # Calendar: repeats, single dates, rooms, clashes and requests
 
-How events repeat, how one date of a series is changed, how events hold rooms, and
-how people ask for events.
+How events repeat, how one date of a series is changed, how a series changes from a
+date on, how events hold rooms, and how people ask for events.
 Read it with `npx acms docs calendar`. The functions named here come from
 `@acms-subir/core/server` (`npx acms docs server` has their signatures), and the app
 API is in `docs/mobile-api-v1.md` in the framework repository.
@@ -148,6 +148,120 @@ Errors carry a `status`, a message safe to show people, and a `code`:
 | 403 | `room-not-allowed` | a host picking a room the event doesn't use and nobody may request |
 | 401, 404 | | who is acting |
 
+## From this date on
+
+When a class moves for good, say from Thursdays 6 PM to Wednesdays 5 PM, change the
+series **from one of its dates on**. The dates before it stay exactly as they were. It
+stays one event: the same page, slug, hosts, RSVPs and My events entry.
+
+Ways to do it:
+
+- the event editor's **Single dates** list: **From here on…** on a date (the new first
+  date, its times, how it repeats, its rooms and a note);
+- dragging a date of a repeating event on the Schedule, then **This and following
+  dates**. **Undo** puts it back;
+- a host's **Change from this date on…** on My events, which is a request staff apply
+  from Schedule → List → Requests;
+- `changeFromDate` from site code or a calendar sync.
+
+The new first date may come before the date you change from (from Thursday Jan 10 to
+Wednesday Jan 9), but it has to come after the date before it. Leave the repeat as it
+is and it carries on from the new day: "weekly on Thursday" moved to a Wednesday becomes
+"weekly on Wednesday", a COUNT becomes what's left of it, and an end date stays.
+
+### What follows the change
+
+Each date from the change point on is matched to the new date nearest it, within half
+a week (3½ days). Each new date takes at most one old date, closest pairs first. Then:
+
+- its RSVPs move to that date, and each person gets the "new time" email in their own
+  language, with your note. Places in line move quietly;
+- a cancelled date stays cancelled on its match, and a skipped one stays skipped;
+- a moved date keeps its new time, as its match's date;
+- a date with no match has its RSVPs cancelled (with the "cancelled" email). Its
+  cancellation, skip or move is dropped, and `changeFromDate` lists it in `dropped`.
+
+So Thursday → Wednesday moves each week's sign-ups to that week's Wednesday, and twice
+a week → once a week keeps the day that matches and cancels the other.
+
+Changing again from a later date replaces every change after it, the way Google's
+"this and following" works. Changing from the first date of an earlier change replaces
+that change. A change that gives exactly the dates the rule before it gives is no
+change at all: it's removed. **Undo** in the editor (`revertFromDate`) removes a change
+the same way, with RSVPs following back.
+
+### How it shows
+
+- `/calendar`, the event page, cards, the TV display, the app API and room holds show
+  the new dates like any other date of the series. Its rooms and place hold from then.
+- The event page's repeat line says the rule in effect and the change still to come:
+  "Weekly on Thursday · From Wed, Jan 9: Weekly on Wednesday". Once it has taken over,
+  just "Weekly on Wednesday".
+- `calendar.ics` has one VEVENT per part, the way Google writes "this and following":
+  the event's own rule keeps its UID and stops with an UNTIL at the end of the day
+  before the change,
+  and each change is a recurring event of its own with UID `<id>-<from>@<host>` (`from`
+  as `YYYYMMDDTHHmm`), with its own cancelled and moved dates. Calendar apps that
+  subscribed show both parts.
+- The "When an event changes" rule sends one notice: "Music class · From Wed, Jan 9:
+  Weekly on Wednesday, 5:00 PM" (`data.change: 'fromDate'`), or "Cancelled: every date
+  from …" (`'cancelledFrom'`).
+- `/api/v1/events` and `/api/calendar/events` carry `segments: [{ from, start, end,
+  rrule, repeats, cancelled, note, location, rooms }]` on each event, and `repeats` is
+  the rule in effect now. Each occurrence has `location`: its own place (a moved
+  date's, or its segment's), `null` for the event's.
+
+### Stored on the event row
+
+Changes are `CalEvent.segments`, sorted by `from`, on the events row (so its triggers,
+the event_changes outbox and the content version see them):
+
+`{ from, start, end, rrule, roomIds?, location?, cancelled, note, by, at }`
+
+- `from` is an occurrence key of the rule before it: that rule's dates from that day on
+  are gone (so retiming the earlier rule never leaves a second date that day);
+- `start`/`end` are the new part's first date, wall-clock like the event's own;
+- `rrule` is its rule (`''` = just that date);
+- `roomIds`/`location` are its rooms and place (unset = the event's);
+- `cancelled: true` cancels every date of it.
+
+Its dates have their own keys, so `cancelledDates`, `movedDates` and `exdates` work on
+them, and so do `moveOccurrence` and `cancelOccurrence`. `seriesParts(event)` splits a
+series into its parts. Dragging the whole series on the Schedule moves every part.
+
+Why one event with segments, and not a second event for the later part: hosts, RSVPs,
+the page and slug, My events and the Classes card all stay with the one event, every
+event write path already goes through the row's triggers, and calendar feeds can still
+show the parts as separate series.
+
+### Server API
+
+```ts
+changeFromDate(repo, who, eventId, fromKey, { start, end?, rrule?, roomIds?, location?, note? }, ctx, { quiet? })
+  → { event, clashes, changed, rsvps: { moved, cancelled }, dropped }
+cancelFromDate(repo, who, eventId, fromKey, ctx, { quiet? })   // every date from it on, struck through
+restoreFromDate(repo, who, eventId, fromKey, ctx, { quiet? })  // undo that; RSVPs stay cancelled
+revertFromDate(repo, who, eventId, from, ctx, { quiet? })      // remove a change: the rule before it carries on
+```
+
+`who` is staff ("Create and edit content") or `GOOGLE_SYNC`. Room clashes at the new
+times (180 days ahead) come back in `clashes` as warnings. Hosts get 403
+`host-request`: they send `requestFromDate` instead (`npx acms docs server`). All are
+idempotent (`changed: false`). `quiet` skips the member push; the RSVP emails still go.
+A `fromKey` that a change took over from (no longer a date itself) means that change,
+so a sync can retry safely: the same change again is `changed: false`, whoever sends it
+and whenever. A change whose first date has started can't be replaced or undone
+(`started`), and neither can a cancelled part be restored once its dates have started.
+
+| status | code | when |
+|---|---|---|
+| 400 | `one-off`, `not-a-date`, `started`, `past`, `bad-time` | as for moves |
+| 400 | `first-date` | changing from the series' very first date (edit the event instead) |
+| 400 | `previous-date` | the new first date isn't after the date before the change |
+| 400 | `bad-rule` | a rule the calendar can't read, or a first date that isn't one of its dates |
+| 403 | `host-request` | a host: send it as a request |
+| 409 | `cancelled-event` | the whole event is cancelled |
+
 ## Rooms
 
 Rooms, people and equipment are **Resources** (Admin → Calendar → Rooms; they need

package/docs/server.md

@@ -18,6 +18,7 @@ import {
   withdrawEventRequest, approveEventRequest, declineEventRequest, setHostedOccurrence,
   moveHostedDate, moveHostedDateBack, requestDateMove, listMyDateRequests, withdrawDateRequest,
   approveDateRequest, declineDateRequest,
+  changeFromDate, cancelFromDate, restoreFromDate, revertFromDate, requestFromDate,
 } from '@acms-subir/core/server';
 ```
 
@@ -38,6 +39,10 @@ cancelOccurrence(repo: Repo, eventId: string, occurrenceKey: string, ctx: WriteC
 restoreOccurrence(repo: Repo, eventId: string, occurrenceKey: string, ctx: WriteContext): Promise<CalEvent>
 moveOccurrence(repo: Repo, who: ServerUser | null | typeof GOOGLE_SYNC, eventId: string, occurrenceKey: string, input: MoveInput, ctx: WriteContext, opts?: { quiet?: boolean }): Promise<MoveResult>
 moveOccurrenceBack(repo: Repo, who: ServerUser | null | typeof GOOGLE_SYNC, eventId: string, occurrenceKey: string, ctx: WriteContext, opts?: { quiet?: boolean }): Promise<MoveResult>
+changeFromDate(repo: Repo, who: ServerUser | null | typeof GOOGLE_SYNC, eventId: string, fromKey: string, input: ChangeFromInput, ctx: WriteContext, opts?: { quiet?: boolean }): Promise<ChangeFromResult>
+cancelFromDate(repo: Repo, who: ServerUser | null | typeof GOOGLE_SYNC, eventId: string, fromKey: string, ctx: WriteContext, opts?: { quiet?: boolean }): Promise<ChangeFromResult>
+restoreFromDate(repo: Repo, who: ServerUser | null | typeof GOOGLE_SYNC, eventId: string, fromKey: string, ctx: WriteContext, opts?: { quiet?: boolean }): Promise<ChangeFromResult>
+revertFromDate(repo: Repo, who: ServerUser | null | typeof GOOGLE_SYNC, eventId: string, from: string, ctx: WriteContext, opts?: { quiet?: boolean }): Promise<ChangeFromResult>
 eventRoomClashes(repo: Repo, event: string | CalEvent, opts?: { horizonDays?: number; now?: Date | number }): Promise<EventClash[]>
 roomBusy(repo: Repo, q: { roomIds: string[]; from: Date | number; to: Date | number; ignore?: { eventId: string; key?: string } }): Promise<BusySlot[]>
 
@@ -61,9 +66,10 @@ setHostedOccurrence(repo: Repo, who: ServerUser | null, eventId: string, occurre
 moveHostedDate(repo: Repo, who: ServerUser | null, eventId: string, occurrenceKey: string, input: MoveInput, ctx: WriteContext): Promise<HostMoveResult>
 moveHostedDateBack(repo: Repo, who: ServerUser | null, eventId: string, occurrenceKey: string, ctx: WriteContext): Promise<HostMoveResult>
 requestDateMove(repo: Repo, who: ServerUser | null, eventId: string, occurrenceKey: string, input: MoveInput | null, message: string, ctx: WriteContext): Promise<RequestRecord>
+requestFromDate(repo: Repo, who: ServerUser | null, eventId: string, fromKey: string, input: Omit<ChangeFromInput, 'location'>, message: string, ctx: WriteContext): Promise<RequestRecord>
 listMyDateRequests(repo: Repo, who: ServerUser | null, eventId?: string): Promise<RequestRecord[]>
 withdrawDateRequest(repo: Repo, who: ServerUser | null, requestId: string): Promise<void>
-approveDateRequest(repo: Repo, who: ServerUser | null, requestId: string, ctx: WriteContext, seen?: number): Promise<{ request: RequestRecord; moved: MoveResult }>
+approveDateRequest(repo: Repo, who: ServerUser | null, requestId: string, ctx: WriteContext, seen?: number): Promise<{ request: RequestRecord; moved?: MoveResult; changed?: ChangeFromResult }>
 declineDateRequest(repo: Repo, who: ServerUser | null, requestId: string, reply: string, ctx: WriteContext, seen?: number): Promise<RequestRecord>
 
 // requests without an account (acms({ requests })): asking needs no account; listing needs
@@ -84,6 +90,9 @@ interface MoveResult { event: CalEvent; clashes: BusySlot[]; changed: boolean }
 type HostMoveResult = { moved: MoveResult } | { request: RequestRecord }
 interface RequestRecord { id: string; kind: 'new' | 'change' | 'move' | 'from-date'; state: 'pending' | 'approved' | 'declined' | 'withdrawn'; source: 'member' | 'web' | 'app'; userId: string; requester: { name: string; email: string; phone: string; locale: string } | null; eventId: string; key: string; data: Record<string, unknown>; note: string; reply: string; reviewedBy: string; reviewedAt: number; createdAt: number; updatedAt: number }
 interface MoveRequestData { start: string; end: string; roomIds?: string[]; note: string; back?: boolean }
+interface FromDateRequestData { start: string; end: string; rrule: string; roomIds?: string[]; note: string }
+interface ChangeFromInput { start: string; end?: string; rrule?: string; roomIds?: string[]; location?: Partial<EventLocation> | null; note?: string }
+interface ChangeFromResult { event: CalEvent; clashes: BusySlot[]; changed: boolean; rsvps: { moved: number; cancelled: number }; dropped: string[] }
 interface Hold { resourceId: string; eventId: string; key: string; title: string; start: number; end: number; eventStart: number; eventEnd: number }
 interface EventClash { hold: Hold; other: Hold }
 interface BusySlot { resourceId: string; start: number; end: number; kind: 'event' | 'booking' | 'block' | 'calendar'; title: string; eventId?: string; key?: string; bookingId?: string }
@@ -187,6 +196,29 @@ full table is in `npx acms docs calendar`).
 `npx acms docs calendar` has the details: what follows a moved date, how it shows,
 and the error statuses.
 
+## From this date on
+
+- **`changeFromDate(repo, who, eventId, fromKey, input, ctx, opts?)`**: changes a repeating
+  event from one of its dates (`fromKey`, an occurrence key) on. `input.start` is the new
+  first date, wall-clock in the event's timezone. It may come before `fromKey` but has to
+  come after the date before it. `end` defaults to the dates' length, `rrule` to the rule
+  in effect on the new weekday (`''` = just that date), and `roomIds` / `location` to
+  what's in effect there. Dates before it stay exactly as they were. RSVPs, cancelled,
+  skipped and moved dates follow to the new date nearest them within half a week. RSVPs
+  with no new date are cancelled, and `dropped` lists the other dates that had none.
+  `clashes` lists what else holds the new rooms over the next 180 days.
+- **`cancelFromDate(...)`** / **`restoreFromDate(...)`**: cancel every date from one on
+  (they stay listed, struck through) and undo that.
+- **`revertFromDate(repo, who, eventId, from, ctx)`**: removes the change that took over
+  at `from`.
+
+All four check `who`: staff ("Create and edit content") or `GOOGLE_SYNC`. A host gets 403
+with code `host-request` and sends **`requestFromDate`** instead (rooms among the event's
+own and the requestable ones). Staff answer it with `approveDateRequest` /
+`declineDateRequest`. All of these are idempotent (`changed: false`), and a `fromKey` that a
+change took over from means that change. The changes are stored on the event as
+`segments`. `npx acms docs calendar` has the rules and the error codes.
+
 ## Rooms
 
 Events hold rooms (`event.roomHold.resourceIds`, the Rooms box in the event editor)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acms-subir/core",
-  "version": "0.3.56",
+  "version": "0.3.57",
   "publishConfig": {
     "access": "public"
   },

package/src/actions/index.ts

@@ -11,7 +11,7 @@ import { validateRequestSession } from '../lib/auth/request';
 import { accessFor } from '../lib/permissions/access';
 import { deniedMessage, type Permission } from '../lib/permissions/catalog';
 import { isStaffRole } from '../lib/roles';
-import { DocTranslations, LinksAvatarShape, LinksAvatarFit, LinksAvatarScale, LinkKind, parseConfig, slugify, widgetTypes, type WidgetType } from '../lib/schema';
+import { DocTranslations, LinksAvatarShape, LinksAvatarFit, LinksAvatarScale, LinkKind, SeriesSegment, parseConfig, slugify, widgetTypes, type WidgetType } from '../lib/schema';
 import { env } from '../lib/env';
 import { CONTENT, collectionUrl } from '../lib/content';
 import { invalidateRedirectCache } from '../middleware';
@@ -30,8 +30,9 @@ import { loadFeed } from '../lib/calendar/ics';
 import { NATIVE_ALL } from '../lib/calendar/render';
 import { collectViewEvents } from '../lib/calendar/data';
 import { loadBoard } from '../lib/calendar/board';
-import { cancelOccurrence, duplicateEvent, moveDateBy, moveSeries, quickCreate, restoreOccurrence, undoMove } from '../lib/calendar/schedule';
+import { cancelOccurrence, duplicateEvent, moveDateBy, moveFollowingBy, moveSeries, quickCreate, restoreOccurrence, undoMove } from '../lib/calendar/schedule';
 import { moveOccurrence, moveOccurrenceBack, upcomingDates } from '../lib/calendar/moves';
+import { changeFromDate, changeFromDefaults, revertFromDate, upcomingSegments } from '../lib/calendar/segments';
 import type { BusySlot } from '../lib/booking/holds';
 import { waitUntilFrom } from '../lib/webhooks';
 import { siteOrigin } from '../lib/seo';
@@ -1153,16 +1154,17 @@ export const server = {
     }),
     // Schedule: drag to another day (and, in the week view, another time:
     // `minutes` more). `occurrence` + mode 'one' moves a single date of a
-    // series (a moved date that keeps its RSVPs); otherwise the whole event
-    // moves. `warning`: what else takes its rooms at the new time.
+    // series (a moved date that keeps its RSVPs), mode 'following' that date
+    // and every one after it (a change from that date on); otherwise the
+    // whole event moves. `warning`: what else takes its rooms at the new time.
     move: defineAction({
-      input: z.object({ id: z.string(), days: z.number().int(), minutes: z.number().int().min(-1440).max(1440).default(0), mode: z.enum(['series', 'one']).default('series'), occurrence: z.string().max(20).default('') }),
+      input: z.object({ id: z.string(), days: z.number().int(), minutes: z.number().int().min(-1440).max(1440).default(0), mode: z.enum(['series', 'one', 'following']).default('series'), occurrence: z.string().max(20).default('') }),
       handler: async ({ id, days, minutes, mode, occurrence }, ctx) => {
         const who = actorOf(await requireCan(ctx, 'content.edit'));
         const repo = await getRepo(ctx.locals);
         try {
-          if (mode === 'one') {
-            const r = await moveDateBy(repo, who, id, occurrence, days * 1440 + minutes, await publishHooks(ctx));
+          if (mode === 'one' || mode === 'following') {
+            const r = await (mode === 'one' ? moveDateBy : moveFollowingBy)(repo, who, id, occurrence, days * 1440 + minutes, await publishHooks(ctx));
             return { id: r.event.id, undo: r.undo, warning: await clashWarning(repo, r.clashes) };
           }
           const r = await moveSeries(repo, id, days, await publishHooks(ctx), minutes);
@@ -1178,6 +1180,7 @@ export const server = {
           location: z.object({ name: z.string().max(300).default(''), address: z.string().max(500).default(''), url: z.string().max(2000).default('') }).partial().optional(),
         }).nullable() }),
         z.object({ kind: z.literal('split'), id: z.string(), seriesId: z.string(), occurrence: z.string().max(20) }),
+        z.object({ kind: z.literal('following'), id: z.string(), from: z.string().max(20), previous: z.array(SeriesSegment).max(50) }),
       ]),
       handler: async (undo, ctx) => {
         const who = actorOf(await requireCan(ctx, 'content.edit'));
@@ -1212,7 +1215,8 @@ export const server = {
       },
     }),
     // Event editor → Single dates: the next dates of a series (as saved), each
-    // moved, cancelled or as planned, and the rooms a date can move into
+    // moved, cancelled or as planned, the rooms a date can move into, and the
+    // changes from a date on still to come or in effect
     dates: defineAction({
       input: z.object({ id: z.string(), limit: z.number().int().min(1).max(52).default(12) }),
       handler: async ({ id, limit }, ctx) => {
@@ -1220,7 +1224,46 @@ export const server = {
         const repo = await getRepo(ctx.locals);
         const [e, settings, resources] = await Promise.all([repo.getEvent(id), repo.getSettings(), bookingsEnabled() ? repo.listResources() : Promise.resolve([])]);
         if (!e) throw new ActionError({ code: 'NOT_FOUND', message: 'Event not found.' });
-        return { allDay: e.allDay, roomIds: e.roomHold.resourceIds, dates: upcomingDates(e, settings, limit), rooms: resources.map((r) => ({ id: r.id, name: r.name })) };
+        return { allDay: e.allDay, roomIds: e.roomHold.resourceIds, dates: upcomingDates(e, settings, limit), rooms: resources.map((r) => ({ id: r.id, name: r.name })),
+          segments: upcomingSegments(e, settings, new Map(resources.map((r) => [r.id, r.name]))) };
+      },
+    }),
+    // …change the series from one of those dates on (new first date, times,
+    // repeat, rooms; the dates before it stay). `rrule` omitted: the rule in
+    // effect, on the new weekday. `warning`: what else takes the rooms then.
+    changeFromDate: defineAction({
+      input: z.object({ id: z.string(), key: z.string().max(20), start: z.string().max(20), end: z.string().max(20).default(''), rrule: z.string().max(500).optional(),
+        roomIds: z.array(z.string()).max(50).optional(), note: z.string().max(500).default('') }),
+      handler: async ({ id, key, start, end, rrule, roomIds, note }, ctx) => {
+        const who = actorOf(await requireCan(ctx, 'content.edit'));
+        const repo = await getRepo(ctx.locals);
+        try {
+          const r = await changeFromDate(repo, who, id, key, { start, end: end || undefined, rrule, roomIds, note }, await publishHooks(ctx));
+          return { id, changed: r.changed, rsvps: r.rsvps, dropped: r.dropped.length, warning: await clashWarning(repo, r.clashes) };
+        } catch (e) { asActionError(e); }
+      },
+    }),
+    // …what that form starts with for a date (its times, the rule in effect there, its rooms)
+    fromDateDefaults: defineAction({
+      input: z.object({ id: z.string(), key: z.string().max(20) }),
+      handler: async ({ id, key }, ctx) => {
+        await requireAdmin(ctx);
+        const repo = await getRepo(ctx.locals);
+        const d = await changeFromDefaults(repo, id, key);
+        if (!d) throw new ActionError({ code: 'BAD_REQUEST', message: 'That date isn’t part of this event.' });
+        return d;
+      },
+    }),
+    // …and undo one: the rule before it carries on
+    revertFromDate: defineAction({
+      input: z.object({ id: z.string(), from: z.string().max(20) }),
+      handler: async ({ id, from }, ctx) => {
+        const who = actorOf(await requireCan(ctx, 'content.edit'));
+        const repo = await getRepo(ctx.locals);
+        try {
+          const r = await revertFromDate(repo, who, id, from, await publishHooks(ctx));
+          return { id, changed: r.changed, rsvps: r.rsvps };
+        } catch (e) { asActionError(e); }
       },
     }),
     // Schedule: cancel (or restore) one date of a repeating event, at once

package/src/components/EventPage.astro

@@ -6,8 +6,8 @@
 // the page's language (lib/calendar/event-words.ts, also in the theme SDK).
 import type { CalEvent, Calendar, Settings } from '../lib/schema';
 import { CALENDAR, eventIcsUrl, eventUrl, calendarPageUrl } from '../lib/calendar/config';
-import { addToCalendarLinks, eventTimeZone, formatOccurrence, safeColor, type Occurrence } from '../lib/calendar/events';
-import { describeRepeat } from '../lib/calendar/rrule';
+import { addToCalendarLinks, describeSeries, eventTimeZone, formatOccurrence, safeColor, type Occurrence } from '../lib/calendar/events';
+
 import { eventCardHtml, safeHref } from '../lib/calendar/cards';
 import { siteLang, siteLocale } from '../lib/dates';
 import { I18N, localePath, requestLocale } from '../lib/i18n';
@@ -36,7 +36,7 @@ const { event: e, occurrence: o, settings, calendars, html, upcoming, origin, pr
 // the whole event, or just this date of a repeating one
 const cancelled = e.cancelled || Boolean(o.cancelled);
 // a moved date may be at its own place
-const where = o.moved?.location ?? e.location;
+const where = o.location ?? e.location;
 const image = eventImage(e, settings);
 const tz = eventTimeZone(e, settings);
 const locale = siteLocale(settings);
@@ -49,10 +49,11 @@ const ew = eventStrings(lang);
 const here = (path: string) => localePath(path, reqLocale);
 const pageUrl = origin + here(eventUrl(e.slug));
 const links = addToCalendarLinks(e, o, { pageUrl, icsUrl: eventIcsUrl(e.slug), tz });
-const repeats = describeRepeat(e.rrule, e.start, (ymd) => {
+// the rule in effect, and a change from a date on still to come (CalEvent.segments)
+const repeats = describeSeries(e, settings, Date.now(), lang, (ymd) => {
   const [y, m, d] = ymd.split('-').map(Number);
   return new Date(Date.UTC(y, m - 1, d)).toLocaleDateString(locale, { month: 'short', day: 'numeric', year: 'numeric', timeZone: 'UTC' });
-}, lang);
+}, locale);
 const ctaHref = safeHref(e.cta.href);
 const mapHref = where.url
   ? safeHref(where.url)

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);
@@ -54,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' : ''}`}>
@@ -72,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>
@@ -86,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>
                   ) : (
@@ -96,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)}
@@ -108,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>