@acms-subir/core 0.3.56 → 0.3.58

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @acms-subir/core
 
+## 0.3.58
+
+### Patch Changes
+
+- c26c7c1: Rooms can have a name in each of the site's other languages. Admin → Calendar → Rooms → a room shows **Name in Español** (one field per extra language) under its name, and the editor API takes `translations: { es: { name } }`. Each place that names a room uses the name in its language, and falls back to the main name:
+
+  - public event data: `rooms` in `/api/v1/events`, `/api/v1/events/:slug` and search, following `?locale=` (else the site's main language);
+  - calendar views and cards, including "Reserved" blocks, and section event items on Spanish pages;
+  - the `/request` form and `GET /api/v1/requests/options?locale=`;
+  - the TV display (its room columns and legend);
+  - the hosts' My events;
+  - request emails and the request status page, in the requester's language;
+  - booking emails, in the booker's language.
+
+  The slug stays the same in every language. Staff screens, staff emails and `GET /api/v1/rooms/free` keep the main name. `roomName(room, locale)` in `lib/schema.ts` picks the name, and `es-MX` uses the `es` name. Migration 71 adds `resources.translations` (`'{}'` for existing rooms); changing it refreshes cached pages and API answers. Backups and environment sync carry it.
+
+## 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,13 +1360,23 @@ 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]),
+  // a room's name in other languages (Resource.translations): public, so a
+  // change refreshes cached pages and API answers
+  { version: 71, statements: [
+    `ALTER TABLE resources ADD COLUMN translations TEXT NOT NULL DEFAULT '{}'`,
+    `DROP TRIGGER content_version_resources_update`,
+    contentVersionTriggers("resources", [...CONTENT_VERSION_COLUMNS.resources, "color", "show_on_events", "translations"])[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"],
-  resources: [...CONTENT_VERSION_COLUMNS.resources, "color", "show_on_events"],
+  events: [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates", "moved_dates", "segments"],
+  resources: [...CONTENT_VERSION_COLUMNS.resources, "color", "show_on_events", "translations"],
   announcements: ANNOUNCEMENT_VISIBLE_COLUMNS
 };
 var LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;

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
@@ -169,6 +283,20 @@ Each room also has:
   names the room. When it's off, only staff see that an event uses the room.
 - **Anyone can check if it’s free** (`requestable`, off by default): the room answers
   the public free/busy check below.
+- **Name in Español** (and each of the site's other languages; `translations: { es: {
+  name } }`): the room's name on pages, app answers, TV screens and emails in that
+  language. Without one, the main name shows. The slug stays the same in every
+  language. Site code reads it with `roomName(room, locale)` from the schema.
+
+Where a room's name follows the language:
+- public event data (`rooms`, with `?locale=` in the app API);
+- calendar views, cards and section items;
+- the request form and `GET /api/v1/requests/options`;
+- the TV display;
+- My events;
+- request emails and booking emails, in the person's language.
+
+The admin and staff emails use the main name.
 
 ### Rooms in event data
 

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.58",
   "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>