@acms-subir/core 0.3.47 → 0.3.49

package/src/lib/email/templates.ts

@@ -12,11 +12,15 @@ export function accountMail(kind: 'invite'|'reset'|'welcome'|'password-changed'|
   return { to, subject: `${copy[0]} · ${site}`, text: [copy[0], '', copy[1], ...(url ? ['',`${copy[2]}: ${url}`] : [])].join('\n'),
     html: `<!doctype html><html><body style="margin:0;background:#f6f5f2;color:#24211c;font:16px/1.6 system-ui,sans-serif"><div style="max-width:520px;margin:auto;padding:32px 24px"><p style="color:#7d776e">${escape(site)}</p><h1 style="font-size:24px">${escape(copy[0])}</h1><p>${escape(copy[1])}</p>${url ? `<p><a style="display:inline-block;background:#ee5d20;color:#fff;padding:10px 18px;border-radius:8px;text-decoration:none" href="${escape(url)}">${escape(copy[2])}</a></p>` : ''}</div></body></html>` };
 }
-/** members' event requests (lib/calendar/requests.ts): to staff when one arrives, to the member when it's answered */
-export function eventRequestMail(kind: 'staff-new' | 'staff-changes' | 'approved' | 'declined', to: string, site: string, event: { title: string; when: string; by: string; note: string }, reply: string, url: string): Mail {
+/**
+ * members' event requests (lib/calendar/requests.ts): to staff when one arrives, to the member when it's answered;
+ * staff-moved: a host moved one date (lib/calendar/moves.ts), `when` = "old → new"
+ */
+export function eventRequestMail(kind: 'staff-new' | 'staff-changes' | 'staff-moved' | 'approved' | 'declined', to: string, site: string, event: { title: string; when: string; by: string; note: string }, reply: string, url: string): Mail {
   const copy = {
     'staff-new': [`New event request: ${event.title}`, `${event.by || 'A member'} asked for “${event.title}” (${event.when}). It stays a draft until someone approves it.`, 'Review it'],
     'staff-changes': [`Changes to review: ${event.title}`, `${event.by || 'A host'} suggested changes to “${event.title}” (${event.when}). The live event stays as it is until someone approves them.`, 'Review the changes'],
+    'staff-moved': [`Date moved: ${event.title}`, `${event.by || 'A host'} moved one date of “${event.title}”: ${event.when}. People who signed up for it were emailed the new time.`, 'Open the event'],
     approved: [`Approved: ${event.title}`, `Your event “${event.title}” (${event.when}) was approved and is now on the calendar.`, 'See your events'],
     declined: [`Not approved: ${event.title}`, `Your request for “${event.title}” (${event.when}) wasn’t approved.`, 'See your events'],
   }[kind];

package/src/lib/mobile/calendar.ts

@@ -106,9 +106,12 @@ export async function getEventDetail(repo: ContentRepository, url: URL, ref: str
 }
 /** every room by id, for naming the public ones (Resource.showOnEvents) */
 export const roomMap = async (repo: ContentRepository) => new Map((await repo.listResources()).map((r) => [r.id, r]));
-// one date: its time, whether it's cancelled, and the public rooms it holds
+// one date: its time, whether it's cancelled, where it moved from, and the public rooms it holds
 export function occurrenceDto(o: Occurrence, resources: Map<string, Resource>) {
-  return { id: `${o.event.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay, cancelled: o.cancelled,
+  const iso = (n: number) => new Date(n).toISOString();
+  return { id: `${o.event.id}:${o.start}`, start: iso(o.start), end: iso(o.end), allDay: o.allDay, cancelled: o.cancelled,
+    moved: o.moved ? { from: { start: iso(o.moved.from.start), end: iso(o.moved.from.end) }, note: o.moved.note,
+      location: o.moved.location ? { name: o.moved.location.name, address: o.moved.location.address, url: o.moved.location.url } : null } : null,
     rooms: roomsToJson(o.roomIds, resources) };
 }
 // e is already localized; publicCalendars limits which calendars are named

package/src/lib/mobile/schemas.ts

@@ -29,24 +29,28 @@ export const Page = ContentSummary.extend({
 });
 // a room an event (or one date) holds, named only when set to show on public events; color null = none
 export const EventRoom = z.object({ slug: str, name: str, color: str.nullable() });
+// one date moved here from `from` (null when it wasn't); location: its own place, null = the event's
+export const OccurrenceMoved = z.object({ from: z.object({ start: date, end: date }), note: str, location: z.object({ name: str, address: str, url: str }).nullable() }).nullable();
 export const Event = CalEvent.pick({
   id: true, slug: true, title: true, excerpt: true, status: true, cancelled: true, featured: true, start: true, end: true,
   allDay: true, timezone: true, rrule: true, exdates: true, cancelledDates: true, location: true, cta: true, tags: true, fields: true,
 }).extend({ rsvp: CalEvent.shape.rsvp.removeDefault().omit({ notifyStaff: true }).default({}).optional(), url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
   calendars: z.array(z.object({ id: str, slug: str, name: str, color: str })),
   rooms: z.array(EventRoom),
+  // single dates at another time, by original occurrence key (wall-clock, like start/end)
+  movedDates: z.record(z.object({ start: str, end: str, note: str })),
   // push topics told about date, time or place changes (Admin → Mobile app → When an event changes); [] = none
   notify: z.object({ changes: strings }),
 });
 export const Events = z.object({ locale, timezone: str, from: date, to: date, pagination: Pagination,
-  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom), event: Event })),
+  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom), event: Event })),
 });
 const Snippet = z.object({ text: str, highlights: z.array(z.object({ start: z.number().int(), end: z.number().int() })) });
 const ContentHit = ContentSummary.extend({ snippet: Snippet });
-export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom) }).nullable(), event: Event });
+export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom) }).nullable(), event: Event });
 export const SearchResults = z.object({ locale, query: str,
   posts: z.array(ContentHit), pages: z.array(ContentHit),
-  events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom) }).nullable(), event: Event })),
+  events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, rooms: z.array(EventRoom) }).nullable(), event: Event })),
   more: z.object({ posts: bool, pages: bool, events: bool }),
 });
 const Icon = z.object({ type: z.enum(['svg', 'image', 'emoji']), value: str }).nullable();

package/src/lib/origin-check.ts

@@ -0,0 +1,54 @@
+import { userConfig } from 'virtual:acms-config';
+
+// Astro's CSRF origin check (security.checkOrigin), taken over by core.
+// Astro's own copy runs before any middleware and no route can opt out of it,
+// so requests that never come from a browser on another site were refused
+// too: Amazon SNS posts SES bounces as text/plain with no Origin header, and
+// the apps send none either. integration.mjs turns Astro's copy off and the
+// middleware runs this one first instead, in dev as well as on built sites.
+//
+// The rule is Astro 5's for anything a page on another site can send: a POST
+// whose Origin isn't this site's (or that has none) is refused when its body
+// is form-like (form-urlencoded, multipart, text/plain) or it has no
+// Content-Type. JSON and other types need a CORS preflight and pass. What
+// passes besides: the routes below, and requests a browser only sends to
+// another site after a preflight (preflighted()).
+
+const SAFE_METHODS = ['GET', 'HEAD', 'OPTIONS'];
+const FORM_TYPES = ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'];
+
+// Routes whose senders are servers that send no Origin and prove who they are
+// with a signature the route checks itself (lib/email/webhooks.ts), keyed by
+// route pattern as Astro matched it, so a lookalike path never qualifies. A
+// site adds its own with acms({ signedRoutes }).
+export const SIGNED_ROUTES = new Set([
+  '/api/email/webhooks/[provider]',
+  ...(userConfig.originCheck?.signedRoutes ?? []),
+]);
+
+// The editor apps' OAuth endpoints (RFC 6749): form posts that carry their
+// own code, refresh token or token to revoke, and never use cookies.
+export const TOKEN_ROUTES = new Set(['/api/v1/auth/token', '/api/v1/auth/revoke']);
+
+// A request no browser sends to another site without asking it first (a CORS
+// preflight; ACMS never allows credentials in one, so no cookie rides along):
+// any method but POST, or one carrying an app's own credential, a bearer
+// token or a booking token. Basic auth doesn't count: a browser adds that to
+// a form post by itself.
+export function preflighted(request: Request): boolean {
+  return request.method !== 'POST' || /^bearer\s/i.test(request.headers.get('authorization') ?? '') || request.headers.has('booking-token');
+}
+
+// a site that set security.checkOrigin: false itself keeps the check off
+export const ORIGIN_CHECK = { enabled: userConfig.originCheck?.enabled !== false };
+
+type CheckedContext = { request: Request; url: URL; routePattern: string; isPrerendered: boolean };
+
+/** Astro's 403 for a cross-site form submission, or null when the request may go on. */
+export function crossSiteRefusal({ request, url, routePattern, isPrerendered }: CheckedContext): Response | null {
+  if (!ORIGIN_CHECK.enabled || isPrerendered || SAFE_METHODS.includes(request.method)) return null;
+  if (request.headers.get('origin') === url.origin || SIGNED_ROUTES.has(routePattern) || TOKEN_ROUTES.has(routePattern) || preflighted(request)) return null;
+  const type = request.headers.get('content-type');
+  if (type !== null && !FORM_TYPES.some((form) => type.toLowerCase().includes(form))) return null;
+  return new Response(`Cross-site ${request.method} form submissions are forbidden`, { status: 403 });
+}

package/src/lib/push/service.ts

@@ -96,23 +96,30 @@ interface Words {
   // event changes: dates come formatted, `more` ends a list of cancelled dates
   moved: (to: string, was: string) => string; movedTo: (to: string, place: string) => string; place: (p: string) => string;
   cancelled: (d: string) => string; cancelledFrom: (d: string) => string; cancelledOn: (d: string) => string; more: (n: number) => string;
+  // one date of a series moved (CalEvent.movedDates), or several: their new days
+  dateMoved: (to: string, was: string) => string; datesMoved: (d: string) => string;
 }
 const STRINGS: Record<string, Words> = {
   en: { startsIn: (m) => `Starts in ${m} min`, now: 'Starting now', live: 'We’re live',
     moved: (to, was) => `Now ${to} (was ${was})`, movedTo: (to, p) => `Now ${to} · ${p}`, place: (p) => `New place: ${p}`,
-    cancelled: (d) => `Cancelled: ${d}`, cancelledFrom: (d) => `Cancelled: every date from ${d}`, cancelledOn: (d) => `Cancelled on ${d}`, more: (n) => `${n} more` },
+    cancelled: (d) => `Cancelled: ${d}`, cancelledFrom: (d) => `Cancelled: every date from ${d}`, cancelledOn: (d) => `Cancelled on ${d}`, more: (n) => `${n} more`,
+    dateMoved: (to, was) => `Moved to ${to} (was ${was})`, datesMoved: (d) => `New times on ${d}` },
   es: { startsIn: (m) => `Empieza en ${m} min`, now: 'Empieza ahora', live: 'Estamos en vivo',
     moved: (to, was) => `Ahora ${to} (antes ${was})`, movedTo: (to, p) => `Ahora ${to} · ${p}`, place: (p) => `Nuevo lugar: ${p}`,
-    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas las fechas desde el ${d}`, cancelledOn: (d) => `Cancelado el ${d}`, more: (n) => `${n} más` },
+    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas las fechas desde el ${d}`, cancelledOn: (d) => `Cancelado el ${d}`, more: (n) => `${n} más`,
+    dateMoved: (to, was) => `Se cambia al ${to} (antes ${was})`, datesMoved: (d) => `Nuevo horario el ${d}` },
   fr: { startsIn: (m) => `Commence dans ${m} min`, now: 'Commence maintenant', live: 'Nous sommes en direct',
     moved: (to, was) => `Désormais ${to} (au lieu de ${was})`, movedTo: (to, p) => `Désormais ${to} · ${p}`, place: (p) => `Nouveau lieu : ${p}`,
-    cancelled: (d) => `Annulé : ${d}`, cancelledFrom: (d) => `Annulé : toutes les dates à partir du ${d}`, cancelledOn: (d) => `Annulé le ${d}`, more: (n) => `${n} autres` },
+    cancelled: (d) => `Annulé : ${d}`, cancelledFrom: (d) => `Annulé : toutes les dates à partir du ${d}`, cancelledOn: (d) => `Annulé le ${d}`, more: (n) => `${n} autres`,
+    dateMoved: (to, was) => `Déplacé au ${to} (au lieu de ${was})`, datesMoved: (d) => `Nouveaux horaires le ${d}` },
   de: { startsIn: (m) => `Beginnt in ${m} Min.`, now: 'Beginnt jetzt', live: 'Wir sind live',
     moved: (to, was) => `Jetzt ${to} (statt ${was})`, movedTo: (to, p) => `Jetzt ${to} · ${p}`, place: (p) => `Neuer Ort: ${p}`,
-    cancelled: (d) => `Abgesagt: ${d}`, cancelledFrom: (d) => `Abgesagt: alle Termine ab ${d}`, cancelledOn: (d) => `Abgesagt am ${d}`, more: (n) => `${n} weitere` },
+    cancelled: (d) => `Abgesagt: ${d}`, cancelledFrom: (d) => `Abgesagt: alle Termine ab ${d}`, cancelledOn: (d) => `Abgesagt am ${d}`, more: (n) => `${n} weitere`,
+    dateMoved: (to, was) => `Verschoben auf ${to} (statt ${was})`, datesMoved: (d) => `Neue Zeiten am ${d}` },
   pt: { startsIn: (m) => `Começa em ${m} min`, now: 'Começa agora', live: 'Estamos ao vivo',
     moved: (to, was) => `Agora ${to} (antes ${was})`, movedTo: (to, p) => `Agora ${to} · ${p}`, place: (p) => `Novo local: ${p}`,
-    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas as datas a partir de ${d}`, cancelledOn: (d) => `Cancelado em ${d}`, more: (n) => `mais ${n}` },
+    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas as datas a partir de ${d}`, cancelledOn: (d) => `Cancelado em ${d}`, more: (n) => `mais ${n}`,
+    dateMoved: (to, was) => `Mudou para ${to} (antes ${was})`, datesMoved: (d) => `Novos horários em ${d}` },
 };
 export const pushStrings = (locale: string) => STRINGS[locale.split('-')[0]] ?? STRINGS.en;
 
@@ -291,7 +298,8 @@ export const CHANGE_SOON = 3 * HOUR;
 /** The public fields a change notice compares (staged edits live in `draft` and don't count until applied). */
 export function eventSnapshot(e: CalEvent): EventSnapshot {
   return { start: e.start, end: e.end, allDay: e.allDay, timezone: e.timezone, rrule: e.rrule, exdates: [...e.exdates].sort(),
-    cancelled: e.cancelled, cancelledDates: [...e.cancelledDates].sort(), location: { name: e.location.name.trim(), address: e.location.address.trim() } };
+    cancelled: e.cancelled, cancelledDates: [...e.cancelledDates].sort(), location: { name: e.location.name.trim(), address: e.location.address.trim() },
+    movedDates: Object.fromEntries(Object.keys(e.movedDates ?? {}).sort().map((k) => [k, { start: e.movedDates[k].start, end: e.movedDates[k].end }])) };
 }
 function readSnapshot(raw: string | null): EventSnapshot | null {
   try { const r = EventSnapshot.safeParse(JSON.parse(raw ?? '')); return r.success ? r.data : null; } catch { return null; }
@@ -307,6 +315,8 @@ export interface EventChange {
   cancelled?: Slot;
   /** single dates of a repeating event newly cancelled, soonest first */
   cancelledDates?: Slot[];
+  /** single dates of a repeating event at a new time (moved, moved again or moved back), by their new time */
+  movedDates?: { from: Slot; to: Slot }[];
   /** when the soonest date it touches starts (a move: the old or the new time, whichever is sooner) */
   at: number;
 }
@@ -331,6 +341,7 @@ export function eventChange(was: EventSnapshot, e: CalEvent, settings: Pick<Sett
   const { upcoming } = slots(e, settings, now);
   if (!upcoming) return null;
   if (e.cancelled) return { cancelled: upcoming, at: upcoming.start };
+  // the series as people knew it, with today's moved dates (those are compared one by one below)
   const then: CalEvent = { ...e, start: was.start, end: was.end, allDay: was.allDay, timezone: was.timezone, rrule: was.rrule, exdates: was.exdates, cancelledDates: was.cancelledDates };
   // a date taken out of the series (dragged to its own event) or put back isn't a move
   const exdates = [...new Set([...was.exdates, ...e.exdates])];
@@ -353,6 +364,16 @@ export function eventChange(was: EventSnapshot, e: CalEvent, settings: Pick<Sett
     out.cancelledDates = dates.map((o) => ({ start: o.start, allDay: o.allDay }));
     starts.push(dates[0].start);
   }
+  // single dates at a new time (a cancelled one is reported above as cancelled)
+  const knew: CalEvent = { ...then, movedDates: Object.fromEntries(Object.entries(was.movedDates).map(([k, m]) => [k, { ...m, note: '', by: '', at: 0 }])) };
+  const moves = [...new Set([...Object.keys(was.movedDates), ...Object.keys(e.movedDates ?? {})])].filter((k) => !e.cancelledDates.includes(k))
+    .map((k) => ({ a: findOccurrence(knew, k, settings), b: findOccurrence(e, k, settings) }))
+    .filter((m): m is { a: Occurrence; b: Occurrence } => m.a !== null && m.b !== null && (m.a.start !== m.b.start || m.a.end !== m.b.end) && m.b.start > now)
+    .sort((x, y) => x.b.start - y.b.start);
+  if (moves.length) {
+    out.movedDates = moves.map(({ a, b }) => ({ from: { start: a.start, allDay: a.allDay }, to: { start: b.start, allDay: b.allDay } }));
+    starts.push(Math.min(...moves.map(({ a, b }) => (a.start > now ? Math.min(a.start, b.start) : b.start))));
+  }
   return starts.length ? { ...out, at: Math.min(...starts) } : null;
 }
 
@@ -396,11 +417,13 @@ export function eventChangeNotice(e: CalEvent, change: EventChange, settings: Se
   // all-day dates start at midnight in the site's zone (how they were expanded)
   const zone = (x: Slot) => (x.allDay ? siteTz : tz);
   const dates = change.cancelledDates ?? [];
-  const kind = change.cancelled ? 'cancelled' : change.moved ? 'moved' : change.place ? 'place' : 'dateCancelled';
-  // one cancelled date opens that date (?on= is its day in the site's zone, like calendar links)
+  const movedDates = change.movedDates ?? [];
+  const kind = change.cancelled ? 'cancelled' : change.moved ? 'moved' : change.place ? 'place' : movedDates.length ? 'dateMoved' : 'dateCancelled';
+  // one cancelled or moved date opens that date (?on= is its day in the site's zone, like calendar links)
   let on = '';
-  if (kind === 'dateCancelled' && dates.length === 1) {
-    const p = tzParts(dates[0].start, siteTz);
+  const one = kind === 'dateCancelled' && dates.length === 1 ? dates[0] : kind === 'dateMoved' && movedDates.length === 1 && !dates.length ? movedDates[0].to : null;
+  if (one) {
+    const p = tzParts(one.start, siteTz);
     on = `?on=${p.y}-${String(p.m).padStart(2, '0')}-${String(p.d).padStart(2, '0')}`;
   }
   const words = (ev: CalEvent, locale: string): Composed => {
@@ -418,6 +441,17 @@ export function eventChangeNotice(e: CalEvent, change: EventChange, settings: Se
         const sameDay = !from.allDay && !to.allDay && day(from) === day(to);
         parts.push(place ? s.movedTo(at(to), place) : s.moved(at(to), sameDay ? when(from.start, false, zone(from), locale, 'time') : at(from)));
       } else if (place) parts.push(s.place(place));
+      if (movedDates.length === 1) {
+        const { from, to } = movedDates[0];
+        const sameDay = !from.allDay && !to.allDay && day(from) === day(to);
+        parts.push(s.dateMoved(at(to), sameDay ? when(from.start, false, zone(from), locale, 'time') : at(from)));
+      } else if (movedDates.length) {
+        const list = movedDates.slice(0, 3).map(({ to }) => when(to.start, true, zone(to), locale, 'monthDay'));
+        if (movedDates.length > 3) list.push(s.more(movedDates.length - 3));
+        let joined: string;
+        try { joined = new Intl.ListFormat(locale, { type: 'conjunction' }).format(list); } catch { joined = list.join(', '); }
+        parts.push(s.datesMoved(joined));
+      }
       if (dates.length) {
         const list = dates.length === 1 ? [day(dates[0])] : dates.slice(0, 3).map((x) => when(x.start, true, zone(x), locale, 'monthDay'));
         if (dates.length > 3) list.push(s.more(dates.length - 3));

package/src/lib/push/types.ts

@@ -38,6 +38,8 @@ export type PushSettings = z.infer<typeof PushSettings>;
 export const EventSnapshot = z.object({
   start: z.string(), end: z.string(), allDay: z.boolean(), timezone: z.string(), rrule: z.string(), exdates: z.array(z.string()),
   cancelled: z.boolean(), cancelledDates: z.array(z.string()), location: z.object({ name: z.string(), address: z.string() }),
+  // single dates at another time (key → new wall times); notices queued before moved dates have none
+  movedDates: z.record(z.object({ start: z.string(), end: z.string() })).default({}),
 });
 export type EventSnapshot = z.infer<typeof EventSnapshot>;
 

package/src/lib/repo/migrations.ts

@@ -5,7 +5,7 @@ import { WEBHOOK_MIGRATION } from '../webhook-sql';
 import { PUSH_MIGRATION } from '../push/migration';
 import { EDITOR_MIGRATION, EDITOR_GRACE_MIGRATION } from '../editor/migration';
 import { CALENDAR_SETTINGS_MIGRATION, ROOM_HOLD_MIGRATION } from '../calendar/migration';
-import { EVENT_CHANGES_MIGRATION } from '../calendar/change-migration';
+import { EVENT_CHANGES_MIGRATION, MOVED_DATES_MIGRATION } from '../calendar/change-migration';
 import { PLACES_MIGRATION } from '../maps/migration';
 import { ROLES_MIGRATION } from '../permissions/migration';
 import { SYNC_MIGRATION } from '../sync/migration';
@@ -724,13 +724,16 @@ export const MIGRATIONS: Migration[] = [
   // every change to a published event, from any write path, queued for its
   // side effects (webhooks, "event changed" pushes, slug redirects)
   EVENT_CHANGES_MIGRATION,
+  // single dates of a series moved (CalEvent.movedDates): a column on the
+  // row, so the triggers on events (content version, event_changes) see a move
+  MOVED_DATES_MIGRATION(contentVersionTriggers('events', [...CONTENT_VERSION_COLUMNS.events, 'cancelled_dates', 'moved_dates'])[2]),
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.
 export const 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'],
+  events: [...CONTENT_VERSION_COLUMNS.events, 'cancelled_dates', 'moved_dates'],
   resources: [...CONTENT_VERSION_COLUMNS.resources, 'color', 'show_on_events'],
   announcements: ANNOUNCEMENT_VISIBLE_COLUMNS,
 };

package/src/lib/repo/sql.ts

@@ -13,7 +13,7 @@ import { LiveConfig } from '../live/types';
 import { ApiError } from '../api';
 import { EmailStore, bookingJobs, rsvpStaffJobs } from '../email/store';
 import type { ContentRepository, DesignVersion, EventUpdate, ImportRecord, ImportRecordKind, ImportRun, SearchResults, Stats } from './types';
-import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, Place, EventLocation, EventRequest, isInternalTag, roomColor, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
+import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, Place, EventLocation, EventRequest, MovedDate, isInternalTag, roomColor, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
 import { designSnapshot, draftNavItems, pickDesignDraft, pickEventDraft, pickPageDraft, pickPostDraft } from '../drafts';
 import { eventInstants, eventTimeZone, normalizeEventTimes } from '../calendar/events';
 import { cleanRrule } from '../calendar/rrule';
@@ -148,6 +148,15 @@ function parseRequest(raw: unknown): EventRequest | null {
   if (raw === null || raw === undefined || raw === '') return null;
   try { const r = EventRequest.safeParse(JSON.parse(String(raw))); return r.success ? r.data : null; } catch { return null; }
 }
+// a corrupt moved-dates map, or one bad entry, reads as "not moved" rather than breaking the event
+function parseMovedDates(raw: unknown): CalEvent['movedDates'] {
+  let value: unknown;
+  try { value = JSON.parse(String(raw ?? '{}')); } catch { return {}; }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  const out: CalEvent['movedDates'] = {};
+  for (const [key, entry] of Object.entries(value)) { const m = MovedDate.safeParse(entry); if (m.success) out[key] = m.data; }
+  return out;
+}
 function rowToEvent(r: Row): CalEvent {
   return CalEvent.parse({
     id: r.id, slug: r.slug, title: r.title, bodyJson: r.body_json ?? '', bodyHtml: r.body_html ?? '',
@@ -155,7 +164,7 @@ function rowToEvent(r: Row): CalEvent {
     seoTitle: r.seo_title ?? '', seoDesc: r.seo_desc ?? '', status: r.status,
     featured: Boolean(r.featured), tags: json(r.tags, []), template: r.template ?? '',
     start: r.starts, end: r.ends ?? '', allDay: Boolean(r.all_day), timezone: r.timezone ?? '',
-    rrule: r.rrule ?? '', exdates: json(r.exdates, []), cancelled: Boolean(r.cancelled), cancelledDates: json(r.cancelled_dates, []),
+    rrule: r.rrule ?? '', exdates: json(r.exdates, []), cancelled: Boolean(r.cancelled), cancelledDates: json(r.cancelled_dates, []), movedDates: parseMovedDates(r.moved_dates),
     location: json(r.location, {}), cta: json(r.cta, {}), calendarIds: json(r.calendar_ids, []),
     fields: json(r.fields, {}), sourceUid: r.source_uid ?? '', rsvp: json(r.rsvp, {}), roomHold: json(r.room_hold, {}),
     hostIds: json(r.host_ids, []), request: parseRequest(r.request),
@@ -848,8 +857,8 @@ export class SqlRepository implements ContentRepository {
     await this.driver.run(
       `INSERT INTO events (id, slug, title, body_json, body_html, excerpt, cover, cover_alt, seo_title, seo_desc, status, featured, tags, template,
         starts, ends, all_day, timezone, rrule, exdates, cancelled, location, cta, calendar_ids, fields, source_uid, start_at, end_at,
-        published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request, translations)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request, translations, moved_dates)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         id, data.slug, data.title, data.bodyJson ?? '', data.bodyHtml ?? '', data.excerpt ?? '', data.cover ?? '', data.coverAlt ?? '',
         data.seoTitle ?? '', data.seoDesc ?? '', data.status ?? 'draft', data.featured ? 1 : 0, JSON.stringify(data.tags ?? []), data.template ?? '',
@@ -859,6 +868,7 @@ export class SqlRepository implements ContentRepository {
         data.publishedAt ?? (data.status === 'published' ? now : null), data.scheduledAt ?? null, now, now,
         JSON.stringify(data.rsvp ?? {}), JSON.stringify(data.roomHold ?? {}), JSON.stringify(data.cancelledDates ?? []),
         JSON.stringify(data.hostIds ?? []), data.request ? JSON.stringify(data.request) : null, JSON.stringify(data.translations ?? {}),
+        JSON.stringify(data.movedDates ?? {}),
       ]
     );
     await this.syncEventIndex(id);
@@ -883,7 +893,7 @@ export class SqlRepository implements ContentRepository {
       if (v !== undefined) { sets.push(`${col} = ?`); args.push(v); }
     }
     const jsonCols: Record<string, string> = {
-      tags: 'tags', exdates: 'exdates', cancelledDates: 'cancelled_dates', location: 'location', cta: 'cta', calendarIds: 'calendar_ids', fields: 'fields', rsvp: 'rsvp', translations: 'translations', roomHold: 'room_hold',
+      tags: 'tags', exdates: 'exdates', cancelledDates: 'cancelled_dates', movedDates: 'moved_dates', location: 'location', cta: 'cta', calendarIds: 'calendar_ids', fields: 'fields', rsvp: 'rsvp', translations: 'translations', roomHold: 'room_hold',
     };
     for (const [k, col] of Object.entries(jsonCols)) {
       const v = (data as Record<string, unknown>)[k];
@@ -955,6 +965,14 @@ export class SqlRepository implements ContentRepository {
     await this.ready;
     await this.driver.run('UPDATE events SET cancelled_dates = ?, updated_at = ? WHERE id = ?', [JSON.stringify(dates), Date.now(), id]);
   }
+  async setEventMovedDates(id: string, moved: CalEvent['movedDates'], cancelledDates?: string[], opts: { quiet?: boolean } = {}) {
+    await this.ready;
+    const write = cancelledDates
+      ? { sql: 'UPDATE events SET moved_dates = ?, cancelled_dates = ?, updated_at = ? WHERE id = ?', args: [JSON.stringify(moved), JSON.stringify(cancelledDates), Date.now(), id] }
+      : { sql: 'UPDATE events SET moved_dates = ?, updated_at = ? WHERE id = ?', args: [JSON.stringify(moved), Date.now(), id] };
+    // quiet: the change it records sends its webhook but no member push (the flag shares this transaction)
+    await this.driver.batch(opts.quiet ? [{ sql: 'UPDATE push_control SET quiet=1 WHERE id=1' }, write, { sql: 'UPDATE push_control SET quiet=0 WHERE id=1' }] : [write]);
+  }
   async cancelOccurrenceRsvps(id: string, start: number) {
     await this.ready;
     // the mutation id limits the "cancelled" emails to exactly these RSVPs (as deleteEvent does)
@@ -966,12 +984,12 @@ export class SqlRepository implements ContentRepository {
     ]);
     return Number((await this.first("SELECT COUNT(*) AS n FROM bookings WHERE event_id=? AND kind='rsvp' AND email_mutation=?", [id, mutation]))?.n ?? 0);
   }
-  async moveOccurrenceRsvps(id: string, start: number, to: { eventId?: string; start: number; end: number }) {
+  async moveOccurrenceRsvps(id: string, start: number, to: { eventId?: string; start: number; end: number }, message = '') {
     await this.ready;
     const target = to.eventId || id;
     // one mutation id marks every moved row; only the seated ones are emailed
     const mutation = crypto.randomUUID();
-    const notifications = bookingJobs(target,'rescheduled',undefined,false,mutation).map(s=>({...s,sql:s.sql.replace('b.id = ?',"b.event_id = ? AND b.kind='rsvp' AND b.status IN ('pending','confirmed')")}));
+    const notifications = bookingJobs(target,'rescheduled',undefined,false,mutation,message).map(s=>({...s,sql:s.sql.replace('b.id = ?',"b.event_id = ? AND b.kind='rsvp' AND b.status IN ('pending','confirmed')")}));
     await this.driver.batch([
       {sql:`UPDATE bookings SET event_id=?,start_at=?,end_at=?,hold_start=?,hold_end=?,notification_version=notification_version+1,email_mutation=?,reminder_sent_at=NULL,updated_at=?
         WHERE event_id=? AND kind='rsvp' AND start_at=? AND status IN ${RSVP_ACTIVE}`,args:[target,to.start,to.end,to.start,to.end,mutation,Date.now(),id,start]},
@@ -1906,15 +1924,15 @@ export class SqlRepository implements ContentRepository {
       ...(content.events ?? []).map((e) => ({
         sql: `INSERT INTO events (id, slug, title, body_json, body_html, excerpt, cover, cover_alt, seo_title, seo_desc, status, featured, tags, template,
           starts, ends, all_day, timezone, rrule, exdates, cancelled, location, cta, calendar_ids, fields, source_uid, start_at, end_at,
-          draft, published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          draft, published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request, moved_dates)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: [
           e.id, e.slug, e.title, e.bodyJson, e.bodyHtml, e.excerpt, e.cover, e.coverAlt, e.seoTitle, e.seoDesc, e.status, e.featured ? 1 : 0,
           JSON.stringify(e.tags), e.template, e.start, e.end, e.allDay ? 1 : 0, e.timezone, e.rrule, JSON.stringify(e.exdates),
           e.cancelled ? 1 : 0, JSON.stringify(e.location), JSON.stringify(e.cta), JSON.stringify(e.calendarIds), JSON.stringify(e.fields),
           e.sourceUid, e.startAt, e.endAt, e.draft ? JSON.stringify(e.draft) : null, e.publishedAt, e.scheduledAt, e.createdAt, e.updatedAt,
           JSON.stringify(e.rsvp ?? {}), JSON.stringify(e.roomHold ?? {}), JSON.stringify(e.cancelledDates ?? []),
-          JSON.stringify(e.hostIds ?? []), e.request ? JSON.stringify(e.request) : null,
+          JSON.stringify(e.hostIds ?? []), e.request ? JSON.stringify(e.request) : null, JSON.stringify(e.movedDates ?? {}),
         ],
       })),
       // announcements (a backup made before them leaves the current ones). Restored

package/src/lib/repo/types.ts

@@ -48,7 +48,7 @@ export type EventUpdate = Partial<
     CalEvent,
     | 'title' | 'slug' | 'bodyJson' | 'bodyHtml' | 'excerpt' | 'cover' | 'coverAlt'
     | 'seoTitle' | 'seoDesc' | 'status' | 'featured' | 'tags' | 'template'
-    | 'start' | 'end' | 'allDay' | 'timezone' | 'rrule' | 'exdates' | 'cancelled' | 'cancelledDates'
+    | 'start' | 'end' | 'allDay' | 'timezone' | 'rrule' | 'exdates' | 'cancelled' | 'cancelledDates' | 'movedDates'
     | 'location' | 'cta' | 'calendarIds' | 'fields' | 'sourceUid' | 'rsvp' | 'translations' | 'roomHold'
     | 'publishedAt' | 'scheduledAt'
   >
@@ -168,15 +168,18 @@ export interface ContentRepository {
   discardEventDraft(id: string): Promise<void>;
   /** replace an event's cancelled occurrence keys at once, keeping any staged draft */
   setEventCancelledDates(id: string, dates: string[]): Promise<void>;
+  /** replace an event's moved dates (and cancelled dates, when given) at once, keeping any staged draft; quiet: no member push for it */
+  setEventMovedDates(id: string, moved: CalEvent['movedDates'], cancelledDates?: string[], opts?: { quiet?: boolean }): Promise<void>;
   /** Cancels the RSVPs for one date of an event (they get the "cancelled" email). Returns how many. */
   cancelOccurrenceRsvps(id: string, start: number): Promise<number>;
   /**
    * Moves the RSVPs for one date of an event (those starting at `start`) to a
    * new time, and to another event when `to.eventId` is set. Pending and
-   * confirmed ones get the "new time" email; places in line move quietly.
+   * confirmed ones get the "new time" email (with `message`, when given);
+   * places in line move quietly.
    * Returns how many moved.
    */
-  moveOccurrenceRsvps(id: string, start: number, to: { eventId?: string; start: number; end: number }): Promise<number>;
+  moveOccurrenceRsvps(id: string, start: number, to: { eventId?: string; start: number; end: number }, message?: string): Promise<number>;
   deleteEvent(id: string): Promise<void>;
   // saved-place sync (lib/maps/places.ts): rewrite just the location of the
   // live row and/or the staged draft, leaving every other field — and the

package/src/lib/schema.ts

@@ -357,6 +357,24 @@ export const RoomHold = z.object({
 });
 export type RoomHold = z.infer<typeof RoomHold>;
 
+// One date of a repeating event at another time (and maybe in other rooms or
+// another place): CalEvent.movedDates, keyed by the date's ORIGINAL occurrence
+// key. start/end are wall-clock in the event's zone like the event's own
+// (dates for all-day events, end inclusive). Unset roomIds/location = the
+// event's. note is public ("Moved for the youth retreat"); by is who moved it
+// (a user id, or 'google-sync'), at when. lib/calendar/moves.ts writes these.
+export const MovedDate = z.object({
+  start: z.string(),
+  end: z.string(),
+  roomIds: z.array(z.string()).optional(),
+  location: EventLocation.optional(),
+  note: z.string().max(500).default(''),
+  by: z.string().default(''),
+  at: z.number().default(0),
+});
+export type MovedDate = z.infer<typeof MovedDate>;
+export const MovedDates = z.record(z.string(), MovedDate).default({});
+
 // A member's event request (lib/calendar/requests.ts): a new event waiting
 // for approval (kind 'new', the event stays a draft), or changes to a live
 // event staged in its `draft` (kind 'changes'). Staff approve or decline;
@@ -407,6 +425,9 @@ export const CalEvent = z.object({
   // cancelled: shown struck through, but they don't hold rooms. Keys that no
   // longer match an occurrence (the series moved) are ignored.
   cancelledDates: z.array(z.string()).default([]),
+  // single dates at another time (MovedDate above); a date is moved or
+  // cancelled, never both. Keys that no longer match an occurrence are ignored.
+  movedDates: MovedDates,
   location: EventLocation.default({}),
   cta: EventCta.default({}),
   calendarIds: z.array(z.string()).default([]),

package/src/lib/sections.ts

@@ -32,6 +32,8 @@ export interface LinkValue { label: string; href: string; external: boolean }
 export interface EventItem {
   title: string; url: string; summary: string; image: string; imageAlt: string; location: string;
   start: string; end: string; allDay: boolean; cancelled: boolean;
+  /** this date was moved here: from "Thu, Oct 1 · 6:00 PM" (where it was), with staff's public note; null when not moved */
+  moved: { from: string; note: string } | null;
   /** "Sat, Oct 3 · 11:00 AM" */ when: string; /** "Saturday, October 3, 2026" */ date: string;
   /** "11:00 AM – 1:00 PM EDT" */ time: string; month: string; day: string; weekday: string;
   cta: { label: string; href: string } | null;
@@ -141,11 +143,12 @@ async function resolveSource(field: Extract<FieldDef, { type: 'source' }>, value
     return (await upcomingEvents(repo, settings, now, { calendarIds, limit, tag: cfg.tag, excludeTag: cfg.excludeTag })).map((o): EventItem => {
       const e = lang ? localizeDoc(o.event, lang) : o.event;
       const f = formatOccurrence(o, tz, locale);
+      const was = o.moved ? formatOccurrence({ ...o, start: o.moved.from.start, end: o.moved.from.end }, tz, locale) : null;
       const ctaHref = safeUrl(e.cta.href);
       return {
         title: e.title || 'Untitled event', url: lp(eventUrl(e.slug)), summary: e.excerpt, image: safeUrl(e.cover), imageAlt: e.coverAlt,
-        location: locationLine(e.location), start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(),
-        allDay: o.allDay, cancelled: o.cancelled, when: f.range, date: f.date, time: f.time, month: f.month, day: f.day, weekday: f.weekday,
+        location: locationLine(o.moved?.location ?? e.location), start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(),
+        allDay: o.allDay, cancelled: o.cancelled, moved: was && o.moved ? { from: o.allDay ? was.date : was.range, note: o.moved.note } : null, when: f.range, date: f.date, time: f.time, month: f.month, day: f.day, weekday: f.weekday,
         cta: e.cta.label && ctaHref && !o.cancelled ? { label: e.cta.label, href: ctaHref } : null,
       };
     });

package/src/lib/sync/catalog.ts

@@ -130,6 +130,7 @@ const jsonFields = new Set([
   "roomHold",
   "exdates",
   "cancelledDates",
+  "movedDates",
   "amenities",
   "hours",
   "overrides",

package/src/middleware.ts

@@ -15,6 +15,7 @@ import { processPushQueue, runPushJobs } from './lib/push/service';
 import { previewParamRedirect, hasPreviewCookie } from './lib/designPreview';
 import { applyCachePolicy } from './lib/cache/policy';
 import { bindExecutionContext, syncCachePurge } from './lib/cache/purge';
+import { crossSiteRefusal } from './lib/origin-check';
 
 // Legacy content-URL redirects, checked only on would-be 404s (below) so they
 // can never shadow real content. Tags moved from `${base}/tag/` to a
@@ -81,6 +82,10 @@ export const onRequest = defineMiddleware(async (context, next) =>
 
 async function handle(context: APIContext, next: MiddlewareNext): Promise<Response> {
   const { pathname } = context.url;
+  // cross-site form submissions, before anything else runs (Astro's own
+  // check, which signed webhooks and the apps couldn't pass: lib/origin-check.ts)
+  const refused = crossSiteRefusal(context);
+  if (refused) return refused;
   bindAuthEnvironment(context.request, context.locals);
   bindExecutionContext(context.request, context.locals);
 

package/src/pages/api/calendar/events/index.ts

@@ -100,6 +100,12 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
           end: o.allDay ? isoWithOffset(o.end - 86_400_000, etz).slice(0, 10) : isoWithOffset(o.end, etz),
           allDay: o.allDay,
           cancelled: o.cancelled,
+          // the date's key (a moved date keeps its original one), and where it moved from
+          key: o.key,
+          moved: o.moved ? {
+            from: { start: o.allDay ? isoWithOffset(o.moved.from.start, etz).slice(0, 10) : isoWithOffset(o.moved.from.start, etz), end: o.allDay ? isoWithOffset(o.moved.from.end - 86_400_000, etz).slice(0, 10) : isoWithOffset(o.moved.from.end, etz) },
+            note: o.moved.note, location: o.moved.location ?? null,
+          } : null,
           // that date's rooms
           rooms: roomsToJson(o.roomIds, resources, full),
           event: toJson(o.event.id),

package/src/pages/members/_Layout.astro

@@ -62,6 +62,7 @@ const { title, user } = Astro.props;
     .pc-mem-dates li { display: flex; align-items: center; justify-content: space-between; gap: 10px; min-height: 42px; padding: 5px 0; border-top: 1px solid var(--line); font-variant-numeric: tabular-nums; }
     .pc-mem-dates li.is-cancelled > span { color: var(--muted); }
     .pc-mem-dates em { font-style: normal; font-size: 12.5px; font-weight: 600; color: var(--danger); margin-left: 8px; }
+    .pc-mem-dates em.is-moved { color: var(--accent); font-weight: 500; }
     .pc-mem-past > summary { cursor: pointer; font-weight: 600; font-size: 15px; }
     .pc-mem-past .pc-mem-list { margin-top: 10px; }
     /* the request form */

package/src/pages/members/events/index.astro

@@ -175,7 +175,7 @@ const pastShown = past.slice(0, 10);
                 const off = e.cancelledDates.includes(o.key);
                 return (
                   <li class={o.cancelled ? 'is-cancelled' : undefined}>
-                    <span>{o.cancelled ? <s>{when(o)}</s> : when(o)}{o.cancelled && <em>Cancelled</em>}</span>
+                    <span>{o.cancelled ? <s>{when(o)}</s> : when(o)}{o.cancelled && <em>Cancelled</em>}{o.moved && !o.cancelled && <em class="is-moved" title={o.moved.note || undefined}>Moved from {when({ ...o, start: o.moved.from.start, end: o.moved.from.end })}</em>}</span>
                     {e.rrule && !e.cancelled && o.start > now && (
                       <form method="post" onsubmit={off ? undefined : "return confirm('Cancel this date? It shows as cancelled straight away.')"}>
                         <input type="hidden" name="op" value={off ? 'restore-date' : 'cancel-date'} />

package/src/server/index.ts

@@ -37,6 +37,7 @@ export interface ServerUser {
 export type { CalEvent, Occurrence };
 export type { EventRequestInput } from '../lib/calendar/requests';
 export type { EventClash, BusySlot, Hold } from '../lib/booking/holds';
+export type { MoveInput, MoveResult } from '../lib/calendar/moves';
 
 export interface ListEventsOptions {
   /** only published events (default: every event except archived ones) */
@@ -172,6 +173,38 @@ export async function restoreOccurrence(repo: Repo, eventId: string, occurrenceK
   return restore(internal(repo), eventId, occurrenceKey, { url: context.url, locals: context.locals });
 }
 
+// ---- moved dates -------------------------------------------------------------
+// One date of a repeating event at another time (and maybe other rooms or
+// another place), keeping its key, its RSVPs (moved with it; each person gets
+// the "new time" email with their cancel link) and its hosts. These check who
+// is acting: staff ("Create and edit content") and GOOGLE_SYNC may move any
+// date, and a room taken at the new time comes back in `clashes` as a
+// warning; a host of the event may move its dates only while the rooms are
+// free (409 otherwise), and staff are emailed about it.
+
+/** The actor for a calendar sync acting with staff rights (a change already made elsewhere): clashes only warn. */
+export const GOOGLE_SYNC = 'google-sync';
+
+/**
+ * Move one date (by its occurrence key) to `input.start` (and `end`, else it
+ * keeps its length; wall-clock in the event's timezone, like `start`).
+ * `roomIds`/`location`/`note` replace that date's own (omit to keep them).
+ * Applies at once, even on a published event. `quiet` skips the app notice
+ * and the staff email (a sync catching up); RSVP emails still go. Errors have
+ * a `status`: 400 (not a repeating event, not one of its dates, started or a
+ * past time), 401, 404, 409 (a cancelled date, or a taken room for a host).
+ */
+export async function moveOccurrence(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, occurrenceKey: string, input: import('../lib/calendar/moves').MoveInput, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/moves').MoveResult> {
+  const { moveOccurrence: move } = await import('../lib/calendar/moves');
+  return move(internal(repo), who, eventId, occurrenceKey, input, { url: context.url, locals: context.locals }, opts);
+}
+
+/** Put a moved date back where the series has it. Same rules; idempotent. */
+export async function moveOccurrenceBack(repo: Repo, who: Who | typeof GOOGLE_SYNC, eventId: string, occurrenceKey: string, context: WriteContext, opts: { quiet?: boolean } = {}): Promise<import('../lib/calendar/moves').MoveResult> {
+  const { moveOccurrenceBack: back } = await import('../lib/calendar/moves');
+  return back(internal(repo), who, eventId, occurrenceKey, { url: context.url, locals: context.locals }, opts);
+}
+
 // ---- rooms -----------------------------------------------------------------
 // Events hold rooms (CalEvent.roomHold) while they happen. These find where
 // two things want the same room. They don't check permissions, and their