@acms-subir/core 0.3.55 → 0.3.57

package/src/lib/calendar/moves.ts

@@ -20,7 +20,7 @@ import type { ContentRepository } from '../repo/types';
 import { EventLocation, type CalEvent, type MovedDate } from '../schema';
 import { ApiError, coded } from '../api';
 import { eventSideEffects, type SaveHooks } from '../content-service';
-import { addWallDays, addWallMinutes, eventRoomIds, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence } from './events';
+import { addWallDays, addWallMinutes, eventRoomIds, eventTimeZone, expandEvents, findOccurrence, formatWall, movedInstants, normalizeEventTimes, parseWall, wallMinutesBetween, type Occurrence, partOf, partMinutes, type SeriesPart } from './events';
 import { holdsFromEvents, roomBusy, type BusySlot } from '../booking/holds';
 import { kickEmail } from '../email/service';
 import { waitUntilFrom } from '../webhooks';
@@ -103,14 +103,14 @@ const started = () => refuse(400, 'started', 'That date has already started or p
 
 // The new wall times: `start` in the event's form, `end` defaulting to the
 // date's own length (all-day: the same number of days)
-function newTimes(e: CalEvent, input: MoveInput): { start: string; end: string } {
+function newTimes(e: CalEvent, input: MoveInput, part: SeriesPart): { start: string; end: string } {
   const s = parseWall(input.start);
   if (!s) throw refuse(400, 'bad-time', e.allDay ? 'Pick a date (YYYY-MM-DD).' : 'Pick a date and time (YYYY-MM-DDTHH:mm).');
   if (s.dateOnly !== e.allDay) throw refuse(400, 'bad-time', e.allDay ? 'This event lasts all day: give a date only (YYYY-MM-DD).' : 'Give a date and a time (YYYY-MM-DDTHH:mm).');
   let end = input.end;
   if (!end) {
-    const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
-    const length = es && ee ? wallMinutesBetween(es, ee) : 60;
+    // the length of its part's dates (a change from a date on may have its own)
+    const length = partMinutes(part);
     end = formatWall(e.allDay ? addWallDays(s, Math.round(length / 1440)) : addWallMinutes(s, Math.max(1, length)));
   }
   try {
@@ -162,7 +162,9 @@ async function planMove(repo: ContentRepository, actor: MoveActor | null, id: st
   const settings = await repo.getSettings();
   const current = dateToChange(e, key, settings);
   const prior = e.movedDates[key];
-  const times = newTimes(e, input);
+  // its part of the series (CalEvent.segments): the length, rooms and place it has without a move
+  const part = partOf(e, current);
+  const times = newTimes(e, input, part);
 
   let roomIds = input.roomIds === undefined ? prior?.roomIds : [...new Set(input.roomIds)];
   if (roomIds !== undefined) {
@@ -175,11 +177,11 @@ async function planMove(repo: ContentRepository, actor: MoveActor | null, id: st
       if (roomIds.some((r) => !allowed.has(r))) throw refuse(403, 'room-not-allowed', 'Pick from the rooms this event uses, or ask the team for another room.');
     }
     // the event's own rooms aren't an override
-    if (sameRooms(roomIds, e.roomHold.resourceIds)) roomIds = undefined;
+    if (sameRooms(roomIds, part.roomIds)) roomIds = undefined;
   }
   let location = input.location === undefined ? prior?.location : input.location === null ? undefined : EventLocation.parse({ ...e.location, ...input.location });
   if (location && !location.name.trim() && !location.address.trim()) throw new ApiError(400, 'Give the place a name or an address.');
-  if (location && JSON.stringify(location) === JSON.stringify(e.location)) location = undefined;
+  if (location && JSON.stringify(location) === JSON.stringify(part.location ?? e.location)) location = undefined;
   const note = input.note === undefined ? prior?.note ?? '' : String(input.note).replace(/\s+/g, ' ').trim().slice(0, NOTE_MAX);
 
   const entry: MovedDate = { start: times.start, end: times.end, ...(roomIds ? { roomIds } : {}), ...(location ? { location } : {}), note, by: by || actorId(actor!), at: now };
@@ -306,6 +308,8 @@ export interface DateRow {
   /** "Thu, Jan 10 · 6:00 – 7:00 PM" */
   when: string;
   cancelled: boolean;
+  /** cancelled because every date from some date on is (a cancelled part, CalEvent.segments) */
+  partCancelled: boolean;
   /** moved: "Thu, Jan 10 · 6:00 PM" (where it was) and the note */
   moved: { from: string; note: string } | null;
   roomIds: string[];
@@ -319,19 +323,21 @@ export function upcomingDates(e: CalEvent, settings: Awaited<ReturnType<ContentR
   const day = new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz });
   const time = new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', timeZone: tz });
   const range = (a: number, b: number) => { try { return time.formatRange(a, b); } catch { return `${time.format(a)} – ${time.format(b)}`; } };
-  const es = parseWall(e.start), ee = parseWall(e.end) ?? es;
-  const length = es && ee ? wallMinutesBetween(es, ee) : 60;
   return expandEvents([e], settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: now, windowEndMs: now + 400 * DAY })
     .slice(0, limit)
     .map((o) => {
       const m = o.moved ? e.movedDates[o.key] : undefined;
       const k = parseWall(o.key)!;
+      const part = partOf(e, o);
+      const length = partMinutes(part);
       return {
         key: o.key,
         start: m?.start ?? o.key,
         end: m?.end ?? formatWall(e.allDay ? addWallDays(k, Math.round(length / 1440)) : addWallMinutes(k, length)),
         when: e.allDay ? day.format(o.start) : `${day.format(o.start)} · ${range(o.start, o.end)}`,
         cancelled: o.cancelled,
+        // cancelled with the rest of its part (cancelFromDate): restored from the change, not one by one
+        partCancelled: part.cancelled,
         moved: o.moved ? { from: e.allDay ? day.format(o.moved.from.start) : `${day.format(o.moved.from.start)} · ${time.format(o.moved.from.start)}`, note: o.moved.note } : null,
         roomIds: o.roomIds,
       };

package/src/lib/calendar/request-admin.ts

@@ -0,0 +1,212 @@
+import type { ContentRepository } from '../repo/types';
+import { RequestSettings, slugify, type CalEvent, type RequestRecord, type Settings } from '../schema';
+import { ApiError } from '../api';
+import { validAddress } from '../email/config';
+import { extraLocales, localeName } from '../i18n';
+import { siteLocale } from '../dates';
+import { mergeEventDraft } from '../drafts';
+import { eventClashes } from '../booking/holds';
+import { featuredOccurrence, formatOccurrence } from './events';
+import { requestWhen } from './request-mail';
+import { requestClashes, requestSettings, type NewEventDetails } from './request-service';
+import { pendingRequests } from './requests';
+import { dateRequestClashes, dateRequestWhen } from './host-requests';
+import { MEMBERS } from './members-config';
+
+// Calendar → Requests (pages/admin/calendar/requests.astro): one list of
+// requests from the app, the website and hosts (rows of their own, plus
+// members' requests staged on events), each with what takes its rooms then,
+// and the settings form. Staff see who asked; the public never does.
+
+export type RequestTab = 'pending' | 'approved' | 'declined';
+
+export interface RequestRow {
+  /** 'r:<id>' for request rows, 'e:<eventId>' for members' requests on an event */
+  key: string;
+  /** the same as an HTML id ('r-<id>', 'e-<eventId>'): a request's id is the sender's key, so it can't share a namespace with event ids */
+  dom: string;
+  id: string;
+  kind: RequestRecord['kind'] | 'member-new' | 'member-changes';
+  /** "New event · from the app · 2h ago" */
+  head: string;
+  title: string;
+  line: string;
+  who: string;
+  /** where Reply goes ('' = nowhere to write) */
+  email: string;
+  note: string;
+  /** "Sanctuary is free then" / "Sanctuary on Wed, Dec 2: Advent rehearsal 4:30 – 6:00 PM" */
+  clash: { text: string; taken: boolean } | null;
+  /** staff's answer, for decided ones: "Approved by Ana · 2d ago" and their words */
+  answer: string;
+  reply: string;
+  /** the event it's about, or the draft it became */
+  href: string;
+  /** the version staff are looking at (the `seen` guard) */
+  at: number;
+  canReply: boolean;
+}
+
+const ago = (now: number, ts: number) => {
+  const s = Math.max(0, Math.floor((now - ts) / 1000));
+  if (s < 60) return 'just now';
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  return `${Math.floor(s / 86400)}d ago`;
+};
+const SOURCE = { app: 'from the app', web: 'from the website', member: 'from a host' } as const;
+const KIND = { new: 'New event', change: 'Change', move: 'Move a date', 'from-date': 'Change from a date on' } as const;
+
+function fmt(settings: Settings) {
+  const tz = settings.timezone || 'UTC', locale = siteLocale(settings);
+  const f = (o: Intl.DateTimeFormatOptions) => {
+    try { return new Intl.DateTimeFormat(locale, { ...o, timeZone: tz }); }
+    catch { return new Intl.DateTimeFormat('en-US', { ...o, timeZone: 'UTC' }); }
+  };
+  const day = f({ weekday: 'short', month: 'short', day: 'numeric' });
+  const time = f({ hour: 'numeric', minute: '2-digit' });
+  return { locale, tz, slot: (s: number, e: number) => `${day.format(s)}: ${time.formatRange(s, e)}`, key: (k: string) => {
+    try { return new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: 'UTC' }).format(new Date(`${k.slice(0, 10)}T12:00:00Z`)); }
+    catch { return k.slice(0, 10); }
+  } };
+}
+
+export const ROWS_PER_PAGE = 50;
+
+/**
+ * One page of a tab (ROWS_PER_PAGE), newest answers first; pending ones oldest
+ * first (first come, first answered). `more`: there's a next page. Members'
+ * requests come on the first page.
+ */
+export async function requestRows(repo: ContentRepository, settings: Settings, tab: RequestTab, now = Date.now(), page = 1): Promise<{ rows: RequestRow[]; more: boolean }> {
+  const f = fmt(settings);
+  const [found, users, rooms, events] = await Promise.all([
+    repo.requests.list({ states: tab === 'pending' ? ['pending'] : [tab], order: tab === 'pending' ? 'oldest' : 'decided', limit: ROWS_PER_PAGE + 1, offset: (page - 1) * ROWS_PER_PAGE }),
+    repo.listUsers(), repo.listResources(), repo.listEvents(),
+  ]);
+  const userName = new Map(users.map((u) => [u.id, u.name || u.email]));
+  const roomName = new Map(rooms.map((r) => [r.id, r.name]));
+  const eventById = new Map(events.map((e) => [e.id, e]));
+  const types = requestSettings(settings).types;
+  const records = found.slice(0, ROWS_PER_PAGE);
+  const rows: (RequestRow & { sort: number })[] = [];
+  for (const q of records) {
+    const who = q.requester
+      ? [q.requester.name, q.requester.email, q.requester.phone, q.requester.locale ? localeName(q.requester.locale) : ''].filter(Boolean).join(' · ')
+      : userName.get(q.userId) ?? 'A member';
+    const e = q.eventId ? eventById.get(q.eventId) : undefined;
+    let title = '', line = '', clash: RequestRow['clash'] = null;
+    if (q.kind === 'new') {
+      const d = q.data as unknown as NewEventDetails;
+      const type = types.find((t) => t.id === d.type);
+      title = d.title;
+      line = [requestWhen(d.start, d.end, settings, f.locale), d.repeat === 'weekly' ? 'every week' : d.repeat === 'other' ? d.repeatText : '',
+        d.roomsUnsure ? 'room: not sure' : d.roomIds.map((id) => roomName.get(id) ?? 'a deleted room').join(', '),
+        d.people ? `about ${d.people} people` : '', type?.label ?? ''].filter(Boolean).join(' · ');
+      if (tab === 'pending' && d.roomIds.length) {
+        const found = await requestClashes(repo, q, settings, rooms);
+        const names = d.roomIds.map((id) => roomName.get(id)).filter(Boolean).join(' and ');
+        clash = found.length
+          ? { taken: true, text: `${found[0].room} on ${f.slot(found[0].start, found[0].end)}${found[0].title ? ` (${found[0].title})` : ''}${found.length > 1 ? ` and ${found.length - 1} more` : ''}` }
+          : { taken: false, text: `${names} ${d.roomIds.length > 1 ? 'are' : 'is'} free then` };
+      }
+    } else if (q.kind === 'move' || q.kind === 'from-date') {
+      // a host's date move, or change from a date on ("Thu, Jan 17, 6:00 PM → Wed, Jan 16, 5:00 PM · Weekly on Wednesday")
+      title = e?.title ?? 'A deleted event';
+      line = await dateRequestWhen(repo, q);
+      if (tab === 'pending' && e) {
+        const found = await dateRequestClashes(repo, q);
+        clash = found.length
+          ? { taken: true, text: `${roomName.get(found[0].resourceId) ?? 'A room'} on ${f.slot(found[0].start, found[0].end)}${found[0].title ? ` (${found[0].title})` : ''}${found.length > 1 ? ` and ${found.length - 1} more` : ''}` }
+          : { taken: false, text: 'Its rooms are free then' };
+      }
+    } else {
+      title = e?.title ?? String(q.data.title ?? 'A deleted event');
+      line = q.key ? f.key(q.key) : 'every date';
+    }
+    const answer = q.state === 'pending' ? '' : `${q.state === 'approved' ? 'Approved' : q.state === 'declined' ? 'Declined' : 'Withdrawn'}${q.reviewedBy ? ` by ${userName.get(q.reviewedBy) ?? 'staff'}` : ''} · ${ago(now, q.reviewedAt || q.updatedAt)}`;
+    rows.push({
+      key: `r:${q.id}`, dom: `r-${q.id}`, id: q.id, kind: q.kind, head: `${KIND[q.kind]} · ${SOURCE[q.source]} · ${ago(now, q.createdAt)}`,
+      title, line, who, email: q.requester?.email ?? users.find((u) => u.id === q.userId)?.email ?? '', note: q.note, clash, answer, reply: q.reply,
+      href: q.eventId ? `/admin/calendar/events/${q.eventId}` : '', at: q.updatedAt, canReply: true, sort: q.state === 'pending' ? q.createdAt : q.reviewedAt,
+    });
+  }
+  // members' requests staged on their events (lib/calendar/requests.ts): waiting ones, and declined ones until the host dismisses them
+  if (tab !== 'approved' && MEMBERS.enabled && page === 1) {
+    const staged = tab === 'pending' ? await pendingRequests(repo) : events.filter((e) => e.request?.state === 'declined');
+    for (const e of staged) rows.push({ ...await memberRow(repo, e, settings, userName, now), sort: e.request!.at });
+  }
+  rows.sort((a, b) => (tab === 'pending' ? a.sort - b.sort : b.sort - a.sort));
+  return { rows: rows.map(({ sort: _, ...r }) => r), more: found.length > ROWS_PER_PAGE };
+}
+
+async function memberRow(repo: ContentRepository, e: CalEvent, settings: Settings, userName: Map<string, string>, now: number): Promise<RequestRow> {
+  const req = e.request!;
+  const shown = mergeEventDraft(e);
+  const o = featuredOccurrence(shown, settings, now);
+  const f = fmt(settings);
+  let clash: RequestRow['clash'] = null;
+  if (req.state === 'pending' && shown.roomHold.resourceIds.length) {
+    const { clashes } = await eventClashes(repo, settings, { ...shown, status: 'published' } as CalEvent, { now, horizonDays: 120 });
+    clash = clashes.length ? { taken: true, text: `${clashes.length} date${clashes.length === 1 ? '' : 's'} clash with other events (open it to see)` } : { taken: false, text: 'Its rooms are free then' };
+  }
+  return {
+    key: `e:${e.id}`, dom: `e-${e.id}`, id: e.id, kind: req.kind === 'new' ? 'member-new' : 'member-changes',
+    head: `${req.kind === 'new' ? 'New event' : 'Changes'} · from a host on My events · ${ago(now, req.at)}`,
+    title: shown.title || 'Untitled event', line: o ? `${formatOccurrence(o, f.tz, f.locale).date} · ${formatOccurrence(o, f.tz, f.locale).time}` : '',
+    who: userName.get(req.by) ?? 'A member', email: '', note: req.note, clash,
+    answer: req.state === 'declined' ? `Declined${req.reviewedBy ? ` by ${userName.get(req.reviewedBy) ?? 'staff'}` : ''} · ${ago(now, req.reviewedAt)}` : '',
+    reply: req.reply, href: `/admin/calendar/events/${e.id}`, at: req.at, canReply: false,
+  };
+}
+
+/** How many wait, for the tab's count: rows of their own plus members' requests. */
+export async function pendingCount(repo: ContentRepository): Promise<number> {
+  return (await repo.requests.count({ states: ['pending'] })) + (MEMBERS.enabled ? (await pendingRequests(repo)).length : 0);
+}
+
+const lines = (v: FormDataEntryValue | null) => String(v ?? '').split(/[\s,;]+/).map((x) => x.trim().toLowerCase()).filter(Boolean);
+const num = (v: FormDataEntryValue | null, fallback: number) => { const n = Number.parseInt(String(v ?? ''), 10); return Number.isFinite(n) ? n : fallback; };
+
+/**
+ * The settings form: types as rows (type-label-N, type-tag-N, type-cal-N and
+ * type-<locale>-N; a row without a label is dropped), the words in each
+ * language, the phone, who's told, the daily cap and how long answered
+ * requests are kept.
+ */
+export function settingsFromForm(data: FormData, current: RequestSettings, calendarIds: string[]): RequestSettings {
+  const types: RequestSettings['types'] = [];
+  // ids of the kinds already saved, so a new kind never takes one (renamed kinds keep theirs)
+  const keptIds = new Set(Array.from({ length: 12 }, (_, i) => String(data.get(`type-id-${i}`) ?? '')).filter(Boolean));
+  for (let i = 0; i < 12; i++) {
+    const label = String(data.get(`type-label-${i}`) ?? '').trim().slice(0, 60);
+    if (!label) continue;
+    if (types.some((t) => t.label.toLowerCase() === label.toLowerCase())) throw new ApiError(400, `Two kinds are called “${label}”. Give each kind its own name.`);
+    // a kind keeps its id when renamed (requests point at it); a new one gets a free id from its name
+    const kept = String(data.get(`type-id-${i}`) ?? '');
+    const base = slugify(label.normalize('NFKD').replace(/[\u0300-\u036f]/g, '')).slice(0, 36) || 'kind';
+    let id = kept && !types.some((t) => t.id === kept) ? kept : base;
+    for (let n = 2; types.some((t) => t.id === id) || (!kept && keptIds.has(id)); n++) id = `${base}-${n}`;
+    const cal = String(data.get(`type-cal-${i}`) ?? '');
+    types.push({ id, label, tag: String(data.get(`type-tag-${i}`) ?? '').trim().slice(0, 60), calendarId: calendarIds.includes(cal) ? cal : '',
+      translations: Object.fromEntries(extraLocales().map((l) => [l, String(data.get(`type-${l}-${i}`) ?? '').trim().slice(0, 60)]).filter(([, v]) => v)) });
+  }
+  const notify = lines(data.get('notify'));
+  const bad = notify.find((a) => !validAddress(a));
+  if (bad) throw new ApiError(400, `“${bad.slice(0, 80)}” isn’t an email address.`);
+  if (notify.length > 20) throw new ApiError(400, 'Add up to 20 addresses.');
+  const parsed = RequestSettings.safeParse({
+    open: data.get('open') === '1', types,
+    replyTime: String(data.get('replyTime') ?? '').trim(), notice: String(data.get('notice') ?? '').trim(),
+    translations: Object.fromEntries(extraLocales().map((l) => [l, { replyTime: String(data.get(`replyTime-${l}`) ?? '').trim(), notice: String(data.get(`notice-${l}`) ?? '').trim() }])),
+    phone: String(data.get('phone') ?? '').trim(), notify, phones: data.has('phones') ? data.getAll('phones').includes('1') : current.phones,
+    perDay: num(data.get('perDay'), current.perDay), keepDays: num(data.get('keepDays'), current.keepDays),
+  });
+  if (!parsed.success) {
+    const field = String(parsed.error.issues[0]?.path[0] ?? '');
+    const why: Record<string, string> = { replyTime: 'Keep the reply time under 60 characters.', notice: 'Keep the notice under 400 characters.', phone: 'Keep the phone number under 40 characters.',
+      perDay: 'Pick a daily limit from 0 to 10,000.', keepDays: 'Keep answered requests from 7 to 1,095 days.', translations: 'Keep each translation as short as the original.' };
+    throw new ApiError(400, why[field] ?? 'Check the request settings.');
+  }
+  return parsed.data;
+}

package/src/lib/calendar/request-config.ts

@@ -0,0 +1,8 @@
+import { userConfig } from 'virtual:acms-config';
+
+// acms({ requests }) config (integration.mjs resolves it): off unless a site
+// turns it on, and only with the calendar. `path` is the public form ('/request'
+// by default, '/es/request' in Spanish); `page: false` keeps the app API and
+// Calendar → Requests but drops that form, so a site can build its own.
+export const REQUESTS: { enabled: boolean; path: string; page: boolean } =
+  { enabled: false, path: '/request', page: true, ...userConfig.requests };

package/src/lib/calendar/request-mail.ts

@@ -0,0 +1,158 @@
+import type { ContentRepository } from '../repo/types';
+import type { RequestRecord, Settings } from '../schema';
+import type { Mail } from '../email/types';
+import { siteLang, siteLocale } from '../dates';
+import { I18N, localeName } from '../i18n';
+import { fill } from '../live/words';
+import { parseWall } from './events';
+import { zonedToUtc } from './ics';
+import { requestSettings, type NewEventDetails, type RequestMailPayload } from './request-service';
+import { requestStaffWords, requestStrings } from './request-words';
+
+// The emails about event requests (queued by lib/calendar/request-service.ts
+// as kind 'calendar-request') and the staff push. To the person: in the
+// language they asked in, and never with words they typed (their title or
+// message), so the form can't be used to email someone else a message; only
+// the date, time, kind, rooms and number of people, or the event's own title.
+// Staff get everything, in the site's main language, with Reply-To set to
+// the person. Plain HTML like the other emails, plus a text part.
+
+const esc = (s: string) => s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]!));
+const oneLine = (s: string) => s.replace(/\s+/g, ' ').trim();
+
+/** the site's main language, and the locale for its dates (keeping the site's region when it's the same language) */
+function language(settings: Settings, lang = '') {
+  const l = lang || (I18N.enabled && I18N.defaultLocale) || siteLang(settings);
+  const base = l.toLowerCase().split('-')[0];
+  return { lang: l, locale: base === siteLang(settings) ? siteLocale(settings) : l };
+}
+
+/** "Sat, Nov 7 · 2:00 – 5:00 PM" for site-local wall times, in a language */
+export function requestWhen(start: string, end: string, settings: Settings, locale: string): string {
+  const tz = settings.timezone || 'UTC';
+  const s = parseWall(start), e = parseWall(end);
+  if (!s || s.dateOnly) return start;
+  const at = (w: NonNullable<typeof s>) => zonedToUtc(w.y, w.m, w.d, w.hh, w.mm, 0, tz);
+  const f = (o: Intl.DateTimeFormatOptions) => {
+    try { return new Intl.DateTimeFormat(locale, { ...o, timeZone: tz }); }
+    catch { return new Intl.DateTimeFormat('en-US', { ...o, timeZone: 'UTC' }); }
+  };
+  const date = f({ weekday: 'short', month: 'short', day: 'numeric' }).format(at(s));
+  const time = f({ hour: 'numeric', minute: '2-digit' });
+  return `${date} · ${e && !e.dateOnly ? time.formatRange(at(s), at(e)) : time.format(at(s))}`;
+}
+
+/** a date (YYYY-MM-DD…) as "Sat, Nov 7" */
+function dayText(key: string, settings: Settings, locale: string) {
+  const w = parseWall(key.slice(0, 10));
+  if (!w) return key;
+  try { return new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: 'UTC' }).format(Date.UTC(w.y, w.m - 1, w.d)); }
+  catch { return key.slice(0, 10); }
+}
+
+interface Summary { what: string; lines: string[] }
+/** the request as the person may see it again: never their own words */
+async function personSummary(repo: ContentRepository, q: RequestRecord, settings: Settings, lang: string, locale: string): Promise<Summary> {
+  const w = requestStrings(lang);
+  if (q.kind === 'change') {
+    const e = q.eventId ? await repo.getEvent(q.eventId) : null;
+    const title = e?.title ?? String(q.data.title ?? '');
+    return { what: fill(w.changeTo, { title }), lines: [q.key ? dayText(q.key, settings, locale) : w.everyDate] };
+  }
+  if (q.kind !== 'new') return { what: '', lines: [] };
+  const d = q.data as unknown as NewEventDetails;
+  const rooms = await repo.listResources();
+  const type = requestSettings(settings).types.find((t) => t.id === d.type);
+  const parts = [
+    requestWhen(d.start, d.end, settings, locale),
+    ...(d.repeat === 'weekly' ? [w.weekly] : []),
+    d.roomIds.map((id) => rooms.find((r) => r.id === id)?.name).filter(Boolean).join(', '),
+    d.people ? fill(w.aboutPeople, { count: String(d.people) }) : '',
+    type ? (lang && type.translations[lang]) || type.label : '',
+  ].filter(Boolean);
+  return { what: '', lines: [parts.join(' · ')] };
+}
+
+function page(site: string, heading: string, paras: string[], quote: string, button?: { label: string; url: string }, foot = '') {
+  const box = quote ? `<p style="background:#efebe4;border-radius:8px;padding:10px 12px;white-space:pre-line">${esc(quote)}</p>` : '';
+  const btn = button ? `<p><a style="display:inline-block;background:#ee5d20;color:#fff;padding:10px 18px;border-radius:8px;text-decoration:none" href="${esc(button.url)}">${esc(button.label)}</a></p>` : '';
+  return `<!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">${esc(site)}</p><h1 style="font-size:22px">${esc(heading)}</h1>`
+    + paras.map((p) => `<p>${esc(p)}</p>`).join('') + box + btn + (foot ? `<p style="color:#7d776e;font-size:14px">${esc(foot)}</p>` : '') + '</div></body></html>';
+}
+
+/** One queued request email, or null when it no longer applies. */
+export async function requestMail(repo: ContentRepository, recipient: string, p: RequestMailPayload, origin: string): Promise<Mail | null> {
+  const q = await repo.requests.get(p.requestId);
+  if (!q) return null;
+  const settings = await repo.getSettings();
+  const site = settings.siteTitle;
+  if (p.kind === 'staff-new') {
+    // staff hear only about requests still waiting
+    if (q.state !== 'pending') return null;
+    return staffMail(repo, q, recipient, settings, origin);
+  }
+  const { lang, locale } = language(settings, q.requester?.locale);
+  const w = requestStrings(lang).mail;
+  const s = await personSummary(repo, q, settings, lang, locale);
+  const rq = requestSettings(settings);
+  const replyTime = (q.requester?.locale && rq.translations[q.requester.locale]?.replyTime) || rq.replyTime;
+  const change = q.kind === 'change';
+  const [subject, intro, quote] = p.kind === 'received' ? [w.receivedSubject, [w.received, ...(replyTime ? [fill(w.within, { time: replyTime })] : [])], '']
+    : p.kind === 'reply' ? [w.replySubject, [w.reply], p.message ?? '']
+    : p.kind === 'approved' ? [w.approvedSubject, [change ? w.approvedChange : w.approved], p.message ? `${w.fromTeam} ${p.message}` : '']
+    : [w.declinedSubject, [change ? w.declinedChange : w.declined], p.message ? `${w.fromTeam} ${p.message}` : ''];
+  const details = [s.what, ...s.lines].filter(Boolean);
+  const foot = p.kind === 'received' ? w.notYou : '';
+  return {
+    to: recipient, subject: `${subject} · ${site}`,
+    text: [subject, '', ...intro, '', ...details, ...(quote ? ['', quote] : []), ...(foot ? ['', foot] : [])].join('\n'),
+    html: page(site, subject, [...intro, details.join(' — ')], quote, undefined, foot),
+  };
+}
+
+async function staffMail(repo: ContentRepository, q: RequestRecord, to: string, settings: Settings, origin: string): Promise<Mail> {
+  const { lang, locale } = language(settings);
+  const w = requestStaffWords(lang);
+  const site = settings.siteTitle;
+  const user = q.userId ? await repo.getUser(q.userId) : null;
+  const who = q.requester ?? { name: user?.name ?? '', email: user?.email ?? '', phone: '', locale: '' };
+  const rows: [string, string][] = [];
+  let subject: string;
+  if (q.kind === 'new') {
+    const d = q.data as unknown as NewEventDetails;
+    const rooms = await repo.listResources();
+    const type = requestSettings(settings).types.find((t) => t.id === d.type);
+    subject = fill(w.subjectNew, { title: oneLine(d.title) });
+    rows.push([w.when, requestWhen(d.start, d.end, settings, locale)]);
+    if (d.repeat !== 'once') rows.push([w.repeats, d.repeat === 'weekly' ? requestStrings(lang).weekly : d.repeatText]);
+    rows.push([w.rooms, d.roomsUnsure ? w.roomsUnsure : d.roomIds.map((id) => rooms.find((r) => r.id === id)?.name ?? '').filter(Boolean).join(', ') || '—']);
+    if (d.people) rows.push([w.people, String(d.people)]);
+    if (type) rows.push([w.type, type.label]);
+  } else {
+    const e = q.eventId ? await repo.getEvent(q.eventId) : null;
+    const title = e?.title ?? String(q.data.title ?? '');
+    subject = fill(q.kind === 'change' ? w.subjectChange : w.subjectMove, { title: oneLine(title) });
+    rows.push([w.date, q.key ? dayText(q.key, settings, locale) : w.everyDate]);
+    const d = q.data as { start?: string; end?: string };
+    if (q.kind !== 'change' && d.start && d.end) rows.push([w.when, requestWhen(d.start, d.end, settings, locale)]);
+  }
+  rows.push([w.from, [who.name, who.email, who.phone].filter(Boolean).join(' · ')]);
+  if (who.locale) rows.push([w.language, localeName(who.locale, true)]);
+  const quote = q.note ? `${q.kind === 'change' ? w.whatChange : w.message}: “${q.note}”` : '';
+  const url = `${origin}/admin/calendar/requests#r-${q.id}`;
+  const intro = w.intro[q.source];
+  return {
+    to, subject: `${subject} · ${site}`, ...(who.email ? { replyTo: who.email } : {}),
+    text: [subject, '', intro, '', ...rows.map(([k, v]) => `${k}: ${v}`), ...(quote ? ['', quote] : []), '', `${w.open}: ${url}`, '', w.why].join('\n'),
+    html: page(site, subject, [intro, ...rows.map(([k, v]) => `${k}: ${v}`)], quote, { label: w.open, url }, w.why),
+  };
+}
+
+/** The staff push: that a request arrived and for when, nothing the person typed. */
+export async function requestPush(_repo: ContentRepository, q: RequestRecord, settings: Settings): Promise<{ title: string; body: string }> {
+  const { lang, locale } = language(settings);
+  const w = requestStaffWords(lang);
+  const d = q.data as { start?: string; end?: string };
+  const when = d.start && d.end ? requestWhen(d.start, d.end, settings, locale) : q.key ? dayText(q.key, settings, locale) : '';
+  return { title: w.pushTitle, body: when ? fill(w.pushBody, { when }) : '' };
+}

package/src/lib/calendar/request-page.ts

@@ -0,0 +1,52 @@
+import type { ContentRepository } from '../repo/types';
+import type { RequestRecord, Settings } from '../schema';
+import { requestWhen } from './request-mail';
+import { requestSettings, type NewEventDetails, type RequestInput } from './request-service';
+import { requestStrings } from './request-words';
+import { fill } from '../live/words';
+
+// The built-in request form (pages/request/index.astro): what the posted
+// form means as a request, and the "Request sent" summary. A site's own form
+// can use the server API instead.
+
+const str = (data: FormData, name: string) => String(data.get(name) ?? '');
+
+/** The posted form as RequestInput (the date and times come as separate fields). */
+export function formRequest(data: FormData, locale: string): RequestInput {
+  const kind = str(data, 'kind') === 'change' ? 'change' : 'new';
+  const common = { name: str(data, 'name'), email: str(data, 'email'), phone: str(data, 'phone'), locale, website: str(data, 'website') };
+  if (kind === 'change') return { kind, event: str(data, 'event'), date: str(data, 'onDate'), message: str(data, 'whatChange'), ...common };
+  const date = str(data, 'date');
+  const repeat = str(data, 'repeat');
+  const people = Number.parseInt(str(data, 'people'), 10);
+  return {
+    kind, type: str(data, 'type'), title: str(data, 'title'),
+    start: date && str(data, 'start') ? `${date}T${str(data, 'start')}` : date, end: str(data, 'end'),
+    repeat: repeat === 'weekly' || repeat === 'other' ? repeat : 'once', repeatText: str(data, 'repeatText'),
+    rooms: data.getAll('rooms').map(String).slice(0, 10), roomsUnsure: data.get('roomsUnsure') === '1',
+    people: Number.isFinite(people) && people > 0 ? Math.min(people, 1_000_000) : null, message: str(data, 'message'), ...common,
+  };
+}
+
+/** "Request sent": the request as the person sent it, in their language. */
+export async function sentSummary(repo: ContentRepository, q: RequestRecord, settings: Settings, lang: string, locale: string): Promise<{ title: string; line: string }> {
+  const w = requestStrings(lang);
+  if (q.kind === 'change') {
+    const e = await repo.getEvent(q.eventId);
+    const day = q.key ? new Date(`${q.key.slice(0, 10)}T12:00:00Z`) : null;
+    let date = w.everyDate;
+    if (day) { try { date = new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: 'UTC' }).format(day); } catch { date = q.key.slice(0, 10); } }
+    return { title: fill(w.changeTo, { title: e?.title ?? String(q.data.title ?? '') }), line: date };
+  }
+  const d = q.data as unknown as NewEventDetails;
+  const rooms = await repo.listResources();
+  const type = requestSettings(settings).types.find((t) => t.id === d.type);
+  const line = [
+    requestWhen(d.start, d.end, settings, locale),
+    d.repeat === 'weekly' ? w.weekly : d.repeat === 'other' ? d.repeatText : '',
+    d.roomIds.map((id) => rooms.find((r) => r.id === id)?.name).filter(Boolean).join(', '),
+    d.people ? fill(w.aboutPeople, { count: String(d.people) }) : '',
+    type ? (lang && type.translations[lang]) || type.label : '',
+  ].filter(Boolean).join(' · ');
+  return { title: d.title, line };
+}