@acms-subir/core 0.3.55 → 0.3.57

package/src/lib/mobile/calendar.ts

@@ -113,6 +113,7 @@ export function occurrenceDto(o: Occurrence, resources: Map<string, Resource>) {
   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,
+    location: o.location ? { name: o.location.name, address: o.location.address, url: o.location.url } : null,
     rooms: roomsToJson(o.roomIds, resources) };
 }
 // e is already localized; publicCalendars limits which calendars are named

package/src/lib/mobile/http.ts

@@ -33,7 +33,8 @@ export function failure(error: unknown) {
   const status = error instanceof ApiError || error instanceof BookingError ? error.status : error instanceof z.ZodError ? 400 : 500;
   const codes: Record<number, string> = { 400: 'invalid_request', 401: 'unauthorized', 403: 'forbidden', 404: 'not_found', 405: 'method_not_allowed', 409: 'conflict', 410: 'gone', 413: 'payload_too_large', 415: 'unsupported_media_type', 429: 'rate_limited', 502: 'upstream_error' };
   return Response.json({ version: 1, error: {
-    code: (error instanceof BookingError && error.code) || (codes[status] ?? 'internal_error'),
+    // a refusal's own code (BookingError, or an ApiError with one: requests, moves)
+    code: ((error instanceof BookingError || error instanceof ApiError) && typeof (error as { code?: unknown }).code === 'string' && (error as { code: string }).code) || (codes[status] ?? 'internal_error'),
     message: status === 500 ? 'Request failed. Please try again.' : error instanceof z.ZodError ? 'Invalid request parameters.' : (error as Error).message,
     ...(error instanceof z.ZodError ? { issues: error.issues.map(({ path, message }) => ({ path, message })) } : {}),
   } }, { status, headers: { ...headers, ...(status === 429 ? { 'Retry-After': String((error as ApiError).retryAfter ?? 60) } : {}),

package/src/lib/mobile/openapi.ts

@@ -9,6 +9,8 @@ import { pagesQuery } from './pages';
 import { searchQuery } from './search';
 import { manageAvailabilityQuery, rescheduleInput } from './manage';
 import { formResponseInput } from './forms';
+import { requestOptionsQuery } from './requests';
+import { RequestInput } from '../calendar/request-service';
 import { codeInput, tokenInput, myBookingsQuery } from './guest';
 import { deviceInput, deviceUpdate, staffLinkInput } from '../push/api';
 import { announcementsQuery } from '../announcements/api';
@@ -116,6 +118,12 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
   paths['/api/v1/forms/{id}/responses'] = { post: { ...priv('Send a response to a published form', ref('FormReceipt'), { body: formResponseInput, write: true, status: 201,
     description: 'Same validation as the web form. Idempotency-Key (UUID v4) is the response id: retries never duplicate. 10 responses per address per form per minute, plus the owner’s daily ceiling per form (429). version from GET /forms/{id}: a changed form answers 409 (a translation alone doesn’t change it). A choice may be sent as shown in the requested language or in the main one; it is stored as the main-language choice. A time answer is HH:mm (24-hour). locale: the confirmation in that language (one the site doesn’t have gets the main language’s). Leave website empty (spam trap).' }),
     parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }, { name: 'locale', in: 'query', required: false, schema: { type: 'string', minLength: 1, maxLength: 35 } }, { name: 'Idempotency-Key', in: 'header', required: true, schema: { type: 'string', format: 'uuid' } }] }, ...cors };
+  const requestNote = 'Requires acms({ requests }) (site.features.requests); 404 when off. No account.';
+  paths['/api/v1/requests/options'] = { get: priv('What the event request form offers: open or closed, the types, requestable rooms and changeable events (with their dates), the site’s reply time and notice (in the requested language) and its phone', ref('RequestOptions'), { query: requestOptionsQuery,
+    description: `${requestNote} Never cached. When open is false, say so and show phone; keep the screen itself reachable. Check whether a room is free with GET /rooms/free.` }), ...cors };
+  paths['/api/v1/requests'] = { post: { ...priv('Ask for a new event or a change to one, without an account', ref('RequestReceipt'), { body: RequestInput, write: true, status: 201,
+    description: `${requestNote} kind new: type (from options; required when the site lists types), title, start (site-local YYYY-MM-DDTHH:mm, in the future), end (the same, or HH:mm: the start's day, or the next when it's before the start; within a day), repeat (once, weekly, or other with repeatText), rooms (slugs from options) or roomsUnsure, people, message. kind change: event (a public event's slug), date (YYYY-MM-DD, optional: one of its dates; none = every date), message (what should change, required). name and email are required, phone optional; locale is the language for replies. Idempotency-Key (UUID v4) is the request's id: a retry answers the same, other details with the same key answer 409 changed. Refusals carry a code (see Error). 10 requests a minute and 20 a day per client address, 5 a day per email address, and the site's daily cap (429). A retry is answered before any limit. Leave website empty (spam trap). The person gets an email that it arrived, without the words they typed.` }),
+    parameters: [{ name: 'Idempotency-Key', in: 'header', required: true, schema: { type: 'string', format: 'uuid' } }] }, ...cors };
   const guestNote = 'Guest sign-in needs the calendar, working email, EMAIL_ENCRYPTION_KEY and the owner switch guestSignIn (site.features.guestSignIn); 404 otherwise.';
   paths['/api/v1/guest/code'] = { post: priv('Email a 6-digit sign-in code (always answers the same, whether or not the address has bookings)', ref('GuestCodeSent'), { body: codeInput, write: true, status: 202,
     description: `${guestNote} Codes last 10 minutes; a new request voids the old code. 3 codes per address and 20 per client address per 15 minutes.` }), ...cors };

package/src/lib/mobile/requests.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { ApiError, readJson } from '../api';
+import { REQUESTS } from '../calendar/request-config';
+import { requestOptions, submitRequest } from '../calendar/request-service';
+import { queryParams } from './http';
+import type { PublicContext } from './route';
+
+// Event requests from apps (acms({ requests })): the options the form needs,
+// and sending one. No account; an Idempotency-Key per request (retries never
+// duplicate); 10 a minute per address and the site's daily cap
+// (lib/calendar/request-service.ts holds the rules). Never cached: "closed"
+// and the rooms must show at once.
+
+export const requestOptionsQuery = z.object({ locale: z.string().max(35).optional() }).strict();
+
+export async function getRequestOptions(c: PublicContext) {
+  if (!REQUESTS.enabled) throw new ApiError(404, 'Not found.');
+  const q = requestOptionsQuery.parse(queryParams(c.url));
+  return requestOptions(c.repo, q.locale);
+}
+
+export async function postRequest(c: PublicContext) {
+  const key = c.request.headers.get('idempotency-key') ?? '';
+  const body = await readJson(c.request, 20_000);
+  const { id } = await submitRequest(c.repo, body, { source: 'app', key, address: c.address, locals: c.locals });
+  return { id };
+}

package/src/lib/mobile/schemas.ts

@@ -9,7 +9,7 @@ const Palette = z.object({ bg: str, ink: str, muted: str, line: str, accent: str
 export const Site = z.object({
   name: str, description: str, logo: str, logoDark: str, icon: str, menu: z.array(z.object({ label: str, href: str })),
   languages: z.object({ default: locale, locales: z.array(z.object({ code: str, name: str })) }),
-  features: z.object({ blog: z.array(z.object({ key: str, name: str, url: str, redirectFrom: strings })), calendar: bool, bookings: bool, rsvp: bool, search: bool, bookingChanges: bool, guestSignIn: bool, forms: bool, links: bool, live: bool, announcements: bool }),
+  features: z.object({ blog: z.array(z.object({ key: str, name: str, url: str, redirectFrom: strings })), calendar: bool, bookings: bool, rsvp: bool, search: bool, bookingChanges: bool, guestSignIn: bool, forms: bool, links: bool, live: bool, announcements: bool, requests: bool }),
   legal: z.object({ privacy: str.nullable(), terms: str.nullable() }), apiVersion: z.literal(1),
 });
 export const Theme = z.object({
@@ -32,6 +32,11 @@ export const Page = ContentSummary.extend({
 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();
+// a date's own place (a moved date's, or from its event's change from a date on); null = the event's
+export const OccurrencePlace = z.object({ name: str, address: str, url: str }).nullable();
+// the series from one date on (CalEvent.segments): `from` is the occurrence key where it took over; location null = the event's
+export const EventSegment = z.object({ from: str, start: str, end: str, rrule: str, repeats: str, cancelled: bool, note: str,
+  location: z.object({ name: str, address: str, url: str }).nullable(), rooms: z.array(EventRoom) });
 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,
@@ -40,18 +45,20 @@ export const Event = CalEvent.pick({
   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 })),
+  // changed from a date on, in order ([] = never); `repeats` above is the part in effect now
+  segments: z.array(EventSegment),
   // 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, moved: OccurrenceMoved, rooms: z.array(EventRoom), event: Event })),
+  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, moved: OccurrenceMoved, location: OccurrencePlace, 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, moved: OccurrenceMoved, 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, location: OccurrencePlace, 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, moved: OccurrenceMoved, 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, location: OccurrencePlace, 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();
@@ -159,8 +166,19 @@ export const LiveStatus = z.object({
   snapshot: LiveSnapshot.nullable(), serverNow: ms,
   display: z.object({ style: z.enum(['poster', 'split', 'row']), bar: bool, header: bool, dock: bool }),
 });
+// GET /requests/options: types and rooms to offer, the site's words (in the asked language), the phone for when it's closed
+export const RequestOptions = z.object({
+  open: bool, types: z.array(z.object({ id: str, label: str })), rooms: z.array(z.object({ slug: str, name: str, color: str })),
+  replyTime: str, notice: str, phone: str, timezone: str,
+  // what a change can be about: public events by title, each with its dates (site-local days) in the next 120 days
+  events: z.array(z.object({ slug: str, title: str, dates: z.array(str) })),
+});
+export const RequestReceipt = z.object({ id: str });
 export const Error = z.object({ version: z.literal(1), error: z.object({
-  // duplicate (409): that email already has an RSVP for the date
-  code: z.enum(['invalid_request', 'unauthorized', 'forbidden', 'not_found', 'method_not_allowed', 'conflict', 'duplicate', 'gone', 'payload_too_large', 'unsupported_media_type', 'rate_limited', 'upstream_error', 'internal_error']),
+  // duplicate (409): that email already has an RSVP for the date. POST /requests refusals say
+  // which field (title, type, start, end, past, far, repeat, room, people, event, date, what,
+  // name, email, phone; 400), closed or changed (409), busy or full (429), trap (400)
+  code: z.enum(['invalid_request', 'unauthorized', 'forbidden', 'not_found', 'method_not_allowed', 'conflict', 'duplicate', 'gone', 'payload_too_large', 'unsupported_media_type', 'rate_limited', 'upstream_error', 'internal_error',
+    'closed', 'trap', 'busy', 'full', 'changed', 'title', 'type', 'start', 'end', 'past', 'far', 'repeat', 'room', 'people', 'event', 'date', 'what', 'name', 'email', 'phone']),
   message: str, issues: z.array(z.object({ path: z.array(z.union([str, z.number()])), message: str })).optional(),
 }) });

package/src/lib/mobile/site.ts

@@ -4,6 +4,7 @@ import { CONTENT, legacyBases } from '../content';
 import { I18N, localeName } from '../i18n';
 import { CALENDAR, bookingsEnabled } from '../calendar/config';
 import { ANNOUNCEMENTS } from '../announcements/config';
+import { REQUESTS } from '../calendar/request-config';
 import { SEARCH } from '../search-config';
 import { siteOrigin } from '../seo';
 import { resolveDesign } from '../theme';
@@ -51,6 +52,8 @@ export async function getSite(repo: ContentRepository, url: URL, _id = '', local
       live: settings.live.mode !== 'off',
       // acms({ announcements }): GET /api/v1/announcements
       announcements: ANNOUNCEMENTS.enabled,
+      // acms({ requests }): GET /api/v1/requests/options, POST /api/v1/requests (on even while requests are closed)
+      requests: REQUESTS.enabled,
     },
     // in the requested language (?locale=es → /es/privacy)
     legal: { privacy: legalUrl('privacy'), terms: legalUrl('terms') },

package/src/lib/push/service.ts

@@ -5,7 +5,8 @@ import type { ContentRepository } from '../repo/types';
 import type { CalEvent, Calendar, Post, Settings } from '../schema';
 import { CONTENT, collectionUrl } from '../content';
 import { CALENDAR, eventUrl } from '../calendar/config';
-import { eventIsListed, eventTimeZone, expandEvents, findOccurrence, type Occurrence } from '../calendar/events';
+import { cutsAt, eventIsListed, eventTimeZone, expandEvents, findOccurrence, partOf, type Occurrence } from '../calendar/events';
+import { describeRepeat } from '../calendar/rrule';
 import { tzParts } from '../calendar/ics';
 import { I18N, stripLocale } from '../i18n';
 import { localizeDoc } from '../translations';
@@ -98,28 +99,30 @@ interface Words {
   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;
+  // the series changed from a date on (CalEvent.segments): "From Wed, Jan 16: Weekly on Wednesday, 5:00 PM"
+  fromDate: (d: string, what: 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`,
-    dateMoved: (to, was) => `Moved to ${to} (was ${was})`, datesMoved: (d) => `New times on ${d}` },
+    dateMoved: (to, was) => `Moved to ${to} (was ${was})`, datesMoved: (d) => `New times on ${d}`, fromDate: (d, w) => `From ${d}: ${w}` },
   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`,
-    dateMoved: (to, was) => `Se cambia al ${to} (antes ${was})`, datesMoved: (d) => `Nuevo horario el ${d}` },
+    dateMoved: (to, was) => `Se cambia al ${to} (antes ${was})`, datesMoved: (d) => `Nuevo horario el ${d}`, fromDate: (d, w) => `Desde el ${d}: ${w}` },
   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`,
-    dateMoved: (to, was) => `Déplacé au ${to} (au lieu de ${was})`, datesMoved: (d) => `Nouveaux horaires le ${d}` },
+    dateMoved: (to, was) => `Déplacé au ${to} (au lieu de ${was})`, datesMoved: (d) => `Nouveaux horaires le ${d}`, fromDate: (d, w) => `À partir du ${d} : ${w}` },
   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`,
-    dateMoved: (to, was) => `Verschoben auf ${to} (statt ${was})`, datesMoved: (d) => `Neue Zeiten am ${d}` },
+    dateMoved: (to, was) => `Verschoben auf ${to} (statt ${was})`, datesMoved: (d) => `Neue Zeiten am ${d}`, fromDate: (d, w) => `Ab ${d}: ${w}` },
   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}`,
-    dateMoved: (to, was) => `Mudou para ${to} (antes ${was})`, datesMoved: (d) => `Novos horários em ${d}` },
+    dateMoved: (to, was) => `Mudou para ${to} (antes ${was})`, datesMoved: (d) => `Novos horários em ${d}`, fromDate: (d, w) => `A partir de ${d}: ${w}` },
 };
 export const pushStrings = (locale: string) => STRINGS[locale.split('-')[0]] ?? STRINGS.en;
 
@@ -299,7 +302,8 @@ export const CHANGE_SOON = 3 * HOUR;
 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() },
-    movedDates: Object.fromEntries(Object.keys(e.movedDates ?? {}).sort().map((k) => [k, { start: e.movedDates[k].start, end: e.movedDates[k].end }])) };
+    movedDates: Object.fromEntries(Object.keys(e.movedDates ?? {}).sort().map((k) => [k, { start: e.movedDates[k].start, end: e.movedDates[k].end }])),
+    segments: (e.segments ?? []).map(({ from, start, end, rrule, cancelled }) => ({ from, start, end, rrule, cancelled })).sort((a, b) => (a.from < b.from ? -1 : 1)) };
 }
 function readSnapshot(raw: string | null): EventSnapshot | null {
   try { const r = EventSnapshot.safeParse(JSON.parse(raw ?? '')); return r.success ? r.data : null; } catch { return null; }
@@ -317,6 +321,10 @@ export interface EventChange {
   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 }[];
+  /** the series changed from a date on (or back): its first new date, and the rule it follows from there */
+  fromDate?: { at: Slot; rrule: string; start: string };
+  /** every date from this one on cancelled (a cancelled segment) */
+  cancelledFrom?: Slot;
   /** when the soonest date it touches starts (a move: the old or the new time, whichever is sooner) */
   at: number;
 }
@@ -342,7 +350,24 @@ export function eventChange(was: EventSnapshot, e: CalEvent, settings: Pick<Sett
   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)
+  // (its segments are today's: a change to them is told on its own, 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 };
+  // changed from a date on (or back): one notice from the first date it touches; the dates it carried over aren't news on their own
+  const segs = (list: EventSnapshot['segments']) => new Map(list.map((g) => [g.from, JSON.stringify(g)]));
+  const before = segs(was.segments), after = segs(eventSnapshot(e).segments);
+  const touched = [...new Set([...before.keys(), ...after.keys()])].filter((k) => before.get(k) !== after.get(k)).sort()[0];
+  // (when the whole series moved, its segments moved with it: that's told as a move below)
+  const sameSeries = was.start === e.start && was.end === e.end && was.rrule === e.rrule && was.allDay === e.allDay && was.timezone === e.timezone;
+  if (touched !== undefined && sameSeries) {
+    const first = expandEvents([e], settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: now, windowEndMs: now + 400 * DAY })
+      .find((o) => o.start > now && (cutsAt(touched, o.key) || (o.segment ?? '') >= touched));
+    if (!first) return null;
+    const part = partOf(e, first);
+    const slot = { start: first.start, allDay: first.allDay };
+    const place = { name: e.location.name.trim(), address: e.location.address.trim() };
+    const placeChange = (place.name || place.address) && (place.name !== was.location.name || place.address !== was.location.address) ? { place: { from: was.location, to: place } } : {};
+    return part.cancelled ? { cancelledFrom: slot, at: slot.start, ...placeChange } : { fromDate: { at: slot, rrule: part.rrule, start: part.start }, at: slot.start, ...placeChange };
+  }
   // 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])];
   const from = slots({ ...then, exdates }, settings, now).next;
@@ -418,10 +443,11 @@ export function eventChangeNotice(e: CalEvent, change: EventChange, settings: Se
   const zone = (x: Slot) => (x.allDay ? siteTz : tz);
   const dates = change.cancelledDates ?? [];
   const movedDates = change.movedDates ?? [];
-  const kind = change.cancelled ? 'cancelled' : change.moved ? 'moved' : change.place ? 'place' : movedDates.length ? 'dateMoved' : 'dateCancelled';
+  const kind = change.cancelled ? 'cancelled' : change.cancelledFrom ? 'cancelledFrom' : change.fromDate ? 'fromDate' : 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 = '';
-  const one = kind === 'dateCancelled' && dates.length === 1 ? dates[0] : kind === 'dateMoved' && movedDates.length === 1 && !dates.length ? movedDates[0].to : null;
+  const one = kind === 'dateCancelled' && dates.length === 1 ? dates[0] : kind === 'dateMoved' && movedDates.length === 1 && !dates.length ? movedDates[0].to
+    : change.fromDate?.at ?? change.cancelledFrom ?? 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')}`;
@@ -432,7 +458,13 @@ export function eventChangeNotice(e: CalEvent, change: EventChange, settings: Se
     const day = (x: Slot) => when(x.start, true, zone(x), locale);
     const parts: string[] = [];
     if (change.cancelled) parts.push(ev.rrule ? s.cancelledFrom(day(change.cancelled)) : s.cancelled(at(change.cancelled)));
-    else {
+    else if (change.cancelledFrom) parts.push(s.cancelledFrom(day(change.cancelledFrom)));
+    else if (change.fromDate) {
+      const { at: first, rrule, start } = change.fromDate;
+      const rule = describeRepeat(rrule, start, undefined, locale);
+      parts.push(s.fromDate(day(first), first.allDay || !rule ? rule || at(first) : `${rule}, ${when(first.start, false, zone(first), locale, 'time')}`));
+      if (change.place) parts.push(s.place(ev.location.name.trim() || ev.location.address.trim()));
+    } else {
       const loc = { name: ev.location.name.trim(), address: ev.location.address.trim() };
       // a new name is enough; the same name at a new address needs both
       const place = !change.place ? '' : change.place.to.name !== change.place.from.name ? loc.name || loc.address : [loc.name, loc.address].filter(Boolean).join(', ');

package/src/lib/push/types.ts

@@ -40,6 +40,8 @@ export const EventSnapshot = z.object({
   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({}),
+  // the series from a date on (CalEvent.segments); notices queued before segments have none
+  segments: z.array(z.object({ from: z.string(), start: z.string(), end: z.string(), rrule: z.string(), cancelled: z.boolean() })).default([]),
 });
 export type EventSnapshot = z.infer<typeof EventSnapshot>;
 
@@ -57,7 +59,7 @@ export interface PushDevice {
  * new form response, to the linked phones of staff on its alert list. Neither
  * counts in the weekly pace.
  */
-export type PushSource = 'manual' | 'post' | 'event' | 'soon' | 'live' | 'announcement' | 'change' | 'test' | 'form';
+export type PushSource = 'manual' | 'post' | 'event' | 'soon' | 'live' | 'announcement' | 'change' | 'test' | 'form' | 'request';
 export interface PushNotification {
   id: string; title: string; body: string; url: string;
   /** ['*'] = everyone */

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, MOVED_DATES_MIGRATION } from '../calendar/change-migration';
+import { EVENT_CHANGES_MIGRATION, MOVED_DATES_MIGRATION, SEGMENTS_MIGRATION } from '../calendar/change-migration';
 import { PLACES_MIGRATION } from '../maps/migration';
 import { ROLES_MIGRATION } from '../permissions/migration';
 import { SYNC_MIGRATION } from '../sync/migration';
@@ -738,13 +738,16 @@ export const MIGRATIONS: Migration[] = [
   // 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,
+  // 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]),
 ];
 
 // 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', '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/src/lib/repo/sql.ts

@@ -16,7 +16,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, MovedDate, 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, SeriesSegment, 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';
@@ -164,6 +164,13 @@ function parseMovedDates(raw: unknown): CalEvent['movedDates'] {
 // (push_control.quiet shares the write's transaction)
 const quietly = (write: SqlStatement, quiet?: boolean): SqlStatement[] =>
   quiet ? [{ sql: 'UPDATE push_control SET quiet=1 WHERE id=1' }, write, { sql: 'UPDATE push_control SET quiet=0 WHERE id=1' }] : [write];
+// a corrupt segments list, or one bad segment, reads as "not changed from a date"
+function parseSegments(raw: unknown): CalEvent['segments'] {
+  let value: unknown;
+  try { value = JSON.parse(String(raw ?? '[]')); } catch { return []; }
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => { const s = SeriesSegment.safeParse(entry); return s.success ? [s.data] : []; }).sort((a, b) => (a.from < b.from ? -1 : a.from > b.from ? 1 : 0));
+}
 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 ?? '',
@@ -172,6 +179,7 @@ function rowToEvent(r: Row): CalEvent {
     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, []), movedDates: parseMovedDates(r.moved_dates),
+    segments: parseSegments(r.segments),
     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),
@@ -870,8 +878,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, moved_dates)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request, translations, moved_dates, segments)
+       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 ?? '',
@@ -881,7 +889,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 ?? {}),
+        JSON.stringify(data.movedDates ?? {}), JSON.stringify(data.segments ?? []),
       ]
     );
     await this.syncEventIndex(id);
@@ -907,7 +915,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', movedDates: 'moved_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', segments: 'segments', 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];
@@ -986,6 +994,14 @@ export class SqlRepository implements ContentRepository {
       : { sql: 'UPDATE events SET moved_dates = ?, updated_at = ? WHERE id = ?', args: [JSON.stringify(moved), Date.now(), id] };
     await this.driver.batch(quietly(write, opts.quiet));
   }
+  async setEventDates(id: string, dates: Partial<Pick<CalEvent, 'segments' | 'movedDates' | 'cancelledDates' | 'exdates'>>, opts: { quiet?: boolean } = {}) {
+    await this.ready;
+    const cols: [keyof typeof dates, string][] = [['segments', 'segments'], ['movedDates', 'moved_dates'], ['cancelledDates', 'cancelled_dates'], ['exdates', 'exdates']];
+    const set = cols.filter(([k]) => dates[k] !== undefined);
+    if (!set.length) return;
+    const write = { sql: `UPDATE events SET ${set.map(([, c]) => `${c} = ?`).join(', ')}, updated_at = ? WHERE id = ?`, args: [...set.map(([k]) => JSON.stringify(dates[k])), Date.now(), id] };
+    await this.driver.batch(quietly(write, opts.quiet));
+  }
   async cancelOccurrenceRsvps(id: string, start: number) {
     await this.ready;
     // the mutation id limits the "cancelled" emails to exactly these RSVPs (as deleteEvent does)
@@ -1939,15 +1955,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, moved_dates)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          draft, published_at, scheduled_at, created_at, updated_at, rsvp, room_hold, cancelled_dates, host_ids, request, moved_dates, segments)
+          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.movedDates ?? {}),
+          JSON.stringify(e.hostIds ?? []), e.request ? JSON.stringify(e.request) : null, JSON.stringify(e.movedDates ?? {}), JSON.stringify(e.segments ?? []),
         ],
       })),
       // announcements (a backup made before them leaves the current ones). Restored

package/src/lib/repo/types.ts

@@ -51,7 +51,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' | 'movedDates'
+    | 'start' | 'end' | 'allDay' | 'timezone' | 'rrule' | 'exdates' | 'cancelled' | 'cancelledDates' | 'movedDates' | 'segments'
     | 'location' | 'cta' | 'calendarIds' | 'fields' | 'sourceUid' | 'rsvp' | 'translations' | 'roomHold'
     | 'publishedAt' | 'scheduledAt'
   >
@@ -179,6 +179,8 @@ export interface ContentRepository {
   setEventCancelledDates(id: string, dates: string[], opts?: { quiet?: boolean }): 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>;
+  /** replace an event's rule segments, moved, cancelled or skipped dates together in one write (lib/calendar/segments.ts), keeping any staged draft; quiet as above */
+  setEventDates(id: string, dates: Partial<Pick<CalEvent, 'segments' | 'movedDates' | 'cancelledDates' | 'exdates'>>, 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>;
   /**

package/src/lib/scheduler.ts

@@ -6,6 +6,7 @@ import { dispatchEmail } from './email/service';
 import { decideOverdue, sendDueReminders, sweepWaitlist } from './booking/service';
 import { runPushJobs } from './push/service';
 import { runAnnouncementJobs } from './announcements/service';
+import { pruneRequests } from './calendar/request-service';
 import { GUEST_IDLE_MS } from './mobile/guest-store';
 import { pushHeartbeat, pushUrlFor } from './monitoring';
 import { syncCachePurge } from './cache/purge';
@@ -35,6 +36,8 @@ export async function runScheduledTasks(repo: ContentRepository, locals?: unknow
     announcements: () => runAnnouncementJobs(repo, { locals, now: startedAt }),
     // queued first-publish notices, starting-soon reminders, receipts, retention
     push: () => runPushJobs(repo, { locals, now: startedAt }),
+    // event requests past Calendar → Requests' retention (after the answer, or after arriving if nobody answered)
+    requests: () => pruneRequests(repo, startedAt),
     // expired guest sign-in codes and app sessions unused for 90 days
     guests: () => repo.guests.purge(GUEST_IDLE_MS, startedAt).then(() => 0),
     // clear shared caches after scheduled publishes, and retry a purge that

package/src/lib/schema.ts

@@ -375,6 +375,28 @@ export const MovedDate = z.object({
 export type MovedDate = z.infer<typeof MovedDate>;
 export const MovedDates = z.record(z.string(), MovedDate).default({});
 
+// A repeating event changed from one date on (CalEvent.segments, C4): the
+// rule before it stops at `from` (an occurrence key of that rule: its dates
+// from there on are gone) and this one takes over with its own first date
+// (`start`/`end`, wall-clock like the event's, and possibly before `from`),
+// rule, rooms and place. It stays one event: same page, hosts and RSVPs.
+// `cancelled`: every date from `from` on is cancelled (struck through,
+// restorable). note is public; by/at as for MovedDate. lib/calendar/segments.ts
+// writes these; they're sorted by `from`.
+export const SeriesSegment = z.object({
+  from: z.string(),
+  start: z.string(),
+  end: z.string(),
+  rrule: z.string().default(''),
+  roomIds: z.array(z.string()).optional(),
+  location: EventLocation.optional(),
+  cancelled: z.boolean().default(false),
+  note: z.string().max(500).default(''),
+  by: z.string().default(''),
+  at: z.number().default(0),
+});
+export type SeriesSegment = z.infer<typeof SeriesSegment>;
+
 // 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;
@@ -406,8 +428,10 @@ export type EventRequest = z.infer<typeof EventRequest>;
 //   on (C3/C4); `data` holds the move.
 // `userId` is the member who asked; `requester` is the person without an
 // account (never both). `note` is their own words to staff, `reply` staff's
-// last answer. Decided rows (and withdrawn ones, which set reviewedAt too)
-// are deleted some days after `reviewedAt` (CalendarSettings.requests).
+// last answer. `data.sent` on new and change requests is a hash of what was
+// sent (a retry must match it). Rows are deleted some days after
+// `reviewedAt` (withdrawing sets it too), or after `createdAt` while nobody
+// answered (CalendarSettings.requests).
 export const RequestKind = z.enum(['new', 'change', 'move', 'from-date']);
 export type RequestKind = z.infer<typeof RequestKind>;
 export const RequestState = z.enum(['pending', 'approved', 'declined', 'withdrawn']);
@@ -475,6 +499,8 @@ export const CalEvent = z.object({
   // 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,
+  // the series changed from a date on (SeriesSegment above); only used while it repeats
+  segments: z.array(SeriesSegment).default([]),
   location: EventLocation.default({}),
   cta: EventCta.default({}),
   calendarIds: z.array(z.string()).default([]),
@@ -651,6 +677,44 @@ export type ApprovalRules = z.infer<typeof ApprovalRules>;
 export const EventImageUrl = z.string().trim().max(2000).refine((value) => !value || Boolean(safeEventImageUrl(value)), 'Choose an image or use an http(s) URL or site-relative image path.');
 
 // Site-wide calendar preferences (Calendar settings → Defaults / Bookings)
+// Event requests from people without an account (acms({ requests }),
+// lib/calendar/request-service.ts), set on Calendar → Requests. A type is
+// what people pick under "Kind" (Class, Meeting…): approving a request makes
+// a draft with its tag, in its calendar.
+export const RequestType = z.object({
+  id: z.string().regex(/^[a-z0-9][a-z0-9-]{0,39}$/),
+  label: z.string().min(1).max(60),
+  // the label in each other site language
+  translations: z.record(z.string().max(60)).default({}),
+  // what an approved draft gets: this tag ('' = none), this calendar ('' = the default calendar)
+  tag: z.string().max(60).default(''),
+  calendarId: z.string().default(''),
+});
+export type RequestType = z.infer<typeof RequestType>;
+export const RequestWords = z.object({ replyTime: z.string().max(60).default(''), notice: z.string().max(400).default('') });
+export const RequestSettings = z.object({
+  // closed: the form says so (with the phone number) and new requests are refused
+  open: z.boolean().default(true),
+  types: z.array(RequestType).max(12).default([]),
+  // "We usually answer within {replyTime}" ("3 days"); '' leaves the sentence out
+  replyTime: z.string().max(60).default(''),
+  // the form's opening line ('' = the built-in "It isn't on the calendar until…")
+  notice: z.string().max(400).default(''),
+  // replyTime and notice in each other site language
+  translations: z.record(RequestWords).default({}),
+  // the office phone, shown when requests are closed and on "Request sent"
+  phone: z.string().max(40).default(''),
+  // who hears about new requests; [] = acms({ members.notify }), else the owners
+  notify: z.array(z.string().max(254)).max(20).default([]),
+  // staff on that list who linked a phone also get a push (with no details)
+  phones: z.boolean().default(false),
+  // new requests a day from the app and the website together; 0 = no cap
+  perDay: z.number().int().min(0).max(10000).default(100),
+  // requests are deleted this many days after the answer (or after they arrived, if nobody answered)
+  keepDays: z.number().int().min(7).max(1095).default(180),
+});
+export type RequestSettings = z.infer<typeof RequestSettings>;
+
 export const CalendarSettings = z.object({
   // Display-only fallback: event covers remain empty until an image is explicitly chosen.
   eventFallbackImage: EventImageUrl.default(''),
@@ -663,6 +727,7 @@ export const CalendarSettings = z.object({
   approvalRules: ApprovalRules.default({}),
   // show bookings on the Schedule grid
   showBookings: z.boolean().default(true),
+  requests: RequestSettings.default({}),
 });
 export type CalendarSettings = z.infer<typeof CalendarSettings>;
 

package/src/lib/sections.ts

@@ -135,7 +135,7 @@ async function resolveSource(field: Extract<FieldDef, { type: 'source' }>, value
       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(o.moved?.location ?? e.location), start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(),
+        location: locationLine(o.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,
         rooms: (o.rooms ?? []).map((r) => ({ slug: r.slug, name: r.name, color: r.color || 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

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