@acms-subir/core 0.3.39 → 0.3.41

package/src/components/editor/EventPanel.tsx

@@ -20,8 +20,9 @@ export interface EventMeta {
   cta: EventCta;
   calendarIds: string[];
   fields: Record<string, string>;
-  // closesAt: wall time like start; closeBefore: minutes before each date (0 = until it ends)
-  rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number; closesAt?: string | null; closeBefore?: number; form?: FormDefinition };
+  // closesAt: wall time like start; closeBefore: minutes before each date (0 = until it ends);
+  // notifyStaff: the hosts get an email about each new or cancelled RSVP; waitlist: a full date takes places in line
+  rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number; closesAt?: string | null; closeBefore?: number; notifyStaff?: boolean; waitlist?: boolean; form?: FormDefinition };
   roomHold: RoomHoldValue;
 }
 

package/src/components/editor/PostEditor.tsx

@@ -169,7 +169,7 @@ const NO_MAPS: MapsStatus = { enabled: false, provider: '', label: '', search: f
 const NO_EVENT: EventMeta = {
   start: '', end: '', allDay: false, timezone: '', rrule: '', exdates: [], cancelled: false,
   location: NO_LOCATION, cta: { label: '', href: '', style: 'primary' }, calendarIds: [], fields: {},
-  rsvp: { enabled: false, capacity: 0, autoConfirm: true, maxSeats: 4, closesAt: null, closeBefore: 0 },
+  rsvp: { enabled: false, capacity: 0, autoConfirm: true, maxSeats: 4, closesAt: null, closeBefore: 0, notifyStaff: true, waitlist: false },
   roomHold: NO_HOLD,
 };
 

package/src/components/editor/event/RegistrationCard.tsx

@@ -73,6 +73,15 @@ export function RegistrationCard({ meta, onChange, eventId, title = '' }: { even
               <span><b>Confirm automatically</b><small>Off: RSVPs wait for your approval in Bookings</small></span>
               <input type="checkbox" role="switch" className="pe-switch" checked={meta.rsvp.autoConfirm} onChange={(e) => onChange({ rsvp: { ...meta.rsvp, autoConfirm: e.target.checked } })} />
             </label>
+            <label className="pe-switch-row">
+              <span><b>Email the hosts</b><small>About each new RSVP and cancellation. Without hosts, the contact email in Settings → Legal gets them</small></span>
+              <input type="checkbox" role="switch" className="pe-switch" checked={meta.rsvp.notifyStaff !== false} onChange={(e) => onChange({ rsvp: { ...meta.rsvp, notifyStaff: e.target.checked } })} />
+            </label>
+            {/* a waitlist needs a limit to be full */}
+            <label className="pe-switch-row">
+              <span><b>Offer a waitlist when it’s full</b><small>{meta.rsvp.capacity ? 'People join a line. When a seat opens, the next person is emailed and it’s held for them for 24 hours' : 'Set a number of seats to use it'}</small></span>
+              <input type="checkbox" role="switch" className="pe-switch" disabled={!meta.rsvp.capacity} checked={Boolean(meta.rsvp.waitlist && meta.rsvp.capacity)} onChange={(e) => onChange({ rsvp: { ...meta.rsvp, waitlist: e.target.checked } })} />
+            </label>
           </div>
           <Deadline meta={meta} onChange={onChange} />
           <div className="pe-evr-form">

package/src/components/editor/event/registration.ts

@@ -9,7 +9,7 @@ export type RegistrationMode = 'none' | 'link' | 'rsvp';
 
 interface RegistrationData {
   cta: EventCta;
-  rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number; closesAt?: string | null; closeBefore?: number };
+  rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number; closesAt?: string | null; closeBefore?: number; notifyStaff?: boolean; waitlist?: boolean };
 }
 
 export function registrationMode({ cta, rsvp }: RegistrationData): RegistrationMode {

package/src/lib/booking/agent.ts

@@ -18,7 +18,7 @@ export const BookingToolInputs = [
     minutes: z.number().int().optional(),
   }).strict() }).strict(),
   z.object({ tool: z.literal('list_bookings'), arguments: z.object({
-    status: z.enum(['pending', 'confirmed', 'declined', 'cancelled']).optional(), resource: z.string().optional(),
+    status: z.enum(['pending', 'confirmed', 'declined', 'cancelled', 'waitlisted', 'offered', 'expired']).optional(), resource: z.string().optional(),
     from: z.string().optional(), limit: z.number().int().min(1).max(100).default(25),
   }).strict() }).strict(),
   z.object({ tool: z.literal('create_booking'), arguments: z.object({

package/src/lib/booking/emails.ts

@@ -13,6 +13,7 @@ import { isExtraLocale } from '../translations';
 import { fill } from '../live/words';
 import { bookingStrings, mailCopy, type BookingStrings } from '../email/booking-words';
 import type { Mail } from '../email';
+import type { RsvpStaffNotice } from '../email/types';
 
 const esc = (s: string) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 
@@ -43,6 +44,11 @@ export function whenText(b: Pick<Booking, 'start' | 'end'>, tz: string, settings
   return `${f({ weekday: 'long', month: 'long', day: 'numeric' }).format(b.start)} · ${f({ hour: 'numeric', minute: '2-digit' }).format(b.start)} – ${f({ hour: 'numeric', minute: '2-digit' }).format(b.end)} ${zone}`.trim();
 }
 
+/** until when a freed spot is held, in the booking's language and the event's zone: "Fri, Nov 7, 6:00 PM UTC" */
+export function untilText(at: number, tz: string, settings: Settings): string {
+  return new Intl.DateTimeFormat(siteLocale(settings), { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZoneName: 'short', timeZone: tz }).format(at);
+}
+
 const utc = (ms: number) => new Date(ms).toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
 
 // lang: the description's language ("Manage: <url>")
@@ -75,30 +81,41 @@ interface Ctx {
   allDay?: boolean;
   /** the words' language: the booking's for guest emails, the main one for staff */
   lang?: string;
+  /** staff RSVP emails: the date's short form, seats taken right after, why they get it and where the person did it */
+  rsvpStaff?: { date: string; taken: number; capacity: number; why: RsvpStaffNotice['why']; via: Booking['source'] };
+  /** manageUrl is the recipient's My events page (a host without Manage bookings) */
+  mineLink?: boolean;
+  /** waitlist emails: the place in line (null once it isn't in line), how many hours a freed spot is held, and until when this one is */
+  waitlist?: { position: number | null; hours: number; until: string };
 }
 
-function layout(heading: string, intro: string, c: Ctx, w: BookingStrings, button?: { href: string; label: string }): { html: string; text: string } {
-  const rows: [string, string][] = [[w.what, c.title], [w.when, c.when], ...(c.location ? [[w.where, c.location] as [string, string]] : [])];
-  if (c.booking.seats > 1) rows.push([w.seats, String(c.booking.seats)]);
-  const reference = fill(w.reference, { ref: c.booking.id.slice(0, 8).toUpperCase() });
+// own: a staff email's own rows and footer instead of the details and reference
+function layout(heading: string, intro: string, c: Ctx, w: BookingStrings, button?: { href: string; label: string }, own?: { rows: [string, string][]; footer: string }): { html: string; text: string } {
+  const rows: [string, string][] = own?.rows ?? [[w.what, c.title], [w.when, c.when], ...(c.location ? [[w.where, c.location] as [string, string]] : [])];
+  if (!own && c.booking.seats > 1) rows.push([w.seats, String(c.booking.seats)]);
+  const footer = own?.footer ?? fill(w.reference, { ref: c.booking.id.slice(0, 8).toUpperCase() });
   const html = `<!doctype html><html lang="${esc(c.lang || 'en')}"><body style="margin:0;background:#f6f5f2;font-family:-apple-system,Segoe UI,Inter,Arial,sans-serif;color:#1e1f24">
 <div style="max-width:520px;margin:0 auto;padding:28px 20px">
 <p style="font-size:13px;color:#6b6e78;margin:0 0 18px">${esc(c.siteTitle)}</p>
-<h1 style="font-size:22px;margin:0 0 8px">${esc(heading)}</h1>
-<p style="font-size:15px;line-height:1.55;margin:0 0 18px;color:#3d3f47">${esc(intro)}</p>
+<h1 style="font-size:22px;margin:0 0 ${intro ? 8 : 18}px">${esc(heading)}</h1>
+${intro ? `<p style="font-size:15px;line-height:1.55;margin:0 0 18px;color:#3d3f47">${esc(intro)}</p>` : ''}
 <table style="width:100%;border-collapse:collapse;background:#fff;border:1px solid #e5e3de;border-radius:10px">${rows
-    .map(([k, v]) => `<tr><td style="padding:10px 14px;font-size:13px;color:#6b6e78;width:70px;border-bottom:1px solid #eeece8">${esc(k)}</td><td style="padding:10px 14px;font-size:14px;border-bottom:1px solid #eeece8">${esc(v)}</td></tr>`)
+    .map(([k, v]) => `<tr><td style="padding:10px 14px;font-size:13px;color:#6b6e78;width:70px;border-bottom:1px solid #eeece8">${esc(k)}</td><td style="padding:10px 14px;font-size:14px;border-bottom:1px solid #eeece8">${esc(v).replace(/\n/g, '<br>')}</td></tr>`)
     .join('')}</table>
 ${c.message ? `<p style="font-size:14px;line-height:1.55;margin:18px 0 0">${esc(c.message)}</p>` : ''}
 ${button ? `<p style="margin:22px 0 0"><a href="${esc(button.href)}" style="display:inline-block;background:#1e1f24;color:#fff;text-decoration:none;font-weight:600;font-size:14px;padding:10px 16px;border-radius:8px">${esc(button.label)}</a></p>` : ''}
-<p style="font-size:12px;color:#8e919a;margin:26px 0 0">${esc(reference)}</p>
+<p style="font-size:12px;color:#8e919a;margin:26px 0 0">${esc(footer)}</p>
 </div></body></html>`;
-  const text = [heading, '', intro, '', ...rows.map(([k, v]) => `${k}: ${v}`), ...(c.message ? ['', c.message] : []), ...(button ? ['', `${button.label}: ${button.href}`] : []), '', reference].join('\n');
+  const text = [heading, '', ...(intro ? [intro, ''] : []), ...rows.map(([k, v]) => `${k}: ${v}`), ...(c.message ? ['', c.message] : []), ...(button ? ['', `${button.label}: ${button.href}`] : []), '', footer].join('\n');
   return { html, text };
 }
 
-// link: the booking's own link again, after someone tried to make it twice
-export type BookingEmail = 'received' | 'confirmed' | 'declined' | 'cancelled' | 'rescheduled' | 'updated' | 'reminder' | 'link' | 'staff-new';
+// link: the booking's own link again, after someone tried to make it twice.
+// waitlisted / offered / left: they joined a full date's waitlist, a spot
+// opened and is held for them, or they're off the waitlist (left it, released
+// the spot or staff removed them). staff-rsvp(-cancelled): the hosts hear
+// about a new RSVP, or one the person cancelled
+export type BookingEmail = 'received' | 'confirmed' | 'declined' | 'cancelled' | 'rescheduled' | 'updated' | 'reminder' | 'link' | 'waitlisted' | 'offered' | 'left' | 'staff-new' | 'staff-rsvp' | 'staff-rsvp-cancelled';
 
 export function bookingEmail(kind: BookingEmail, c: Ctx): Mail {
   const w = bookingStrings(c.lang);
@@ -106,10 +123,11 @@ export function bookingEmail(kind: BookingEmail, c: Ctx): Mail {
   const manage = { href: c.manageUrl, label: rsvp ? w.rsvp.manage : w.manage };
   const ics = (method: 'REQUEST' | 'CANCEL' = 'REQUEST') => [{ filename: 'booking.ics', type: `text/calendar; charset=utf-8; method=${method === 'CANCEL' ? 'CANCEL' : c.organizer ? 'REQUEST' : 'PUBLISH'}`, content: bookingIcs(c.booking, c.title, c.location, c.manageUrl, c.host, method, { organizer: c.organizer, allDay: c.allDay, lang: c.lang }) }];
   // null: no button (nothing left to change)
-  const guest = (k: Exclude<BookingEmail, 'staff-new'>, extra: Partial<Ctx> = {}, button: { href: string; label: string } | null = manage) => {
+  const guest = (k: Exclude<BookingEmail, `staff-${string}`>, extra: Partial<Ctx> = {}, button: { href: string; label: string } | null = manage) => {
     const copy = mailCopy(w, k, rsvp);
-    const vars = { name: c.booking.name || c.booking.email, title: c.title, when: c.when };
-    return { to: c.booking.email, subject: fill(copy.subject, vars), ...layout(copy.heading, fill(copy.intro, vars), { ...c, ...extra }, w, button ?? undefined) };
+    const vars = { name: c.booking.name || c.booking.email, title: c.title, when: c.when,
+      position: String(c.waitlist?.position ?? ''), hours: String(c.waitlist?.hours ?? ''), until: c.waitlist?.until ?? '' };
+    return { to: c.booking.email, subject: fill(copy.subject, vars), ...layout(fill(copy.heading, vars), fill(copy.intro, vars), { ...c, ...extra }, w, button ?? undefined) };
   };
   switch (kind) {
     case 'received': return guest('received');
@@ -119,7 +137,11 @@ export function bookingEmail(kind: BookingEmail, c: Ctx): Mail {
     case 'updated': return { ...guest('updated'), attachments: ics() };
     case 'rescheduled': return { ...guest('rescheduled'), attachments: ics() };
     case 'reminder': return guest('reminder');
-    case 'link': return guest('link');
+    // asked again while in line or holding a spot: that email again
+    case 'link': return c.booking.status === 'waitlisted' || c.booking.status === 'offered' ? bookingEmail(c.booking.status, c) : guest('link');
+    case 'waitlisted': return guest('waitlisted', {}, { href: c.manageUrl, label: w.waitlist.manage });
+    case 'offered': return guest('offered', {}, { href: c.manageUrl, label: w.waitlist.confirm });
+    case 'left': return guest('left', {}, null);
     case 'staff-new': {
       const pending = c.booking.status === 'pending';
       const who = [c.booking.name, c.booking.email, c.booking.phone].filter(Boolean).join(' · ');
@@ -128,5 +150,22 @@ export function bookingEmail(kind: BookingEmail, c: Ctx): Mail {
       const m = layout(pending ? w.staff.pending : w.staff.booked, `${who}${answers ? `\n${answers}` : ''}`, c, w, { href: c.manageUrl, label: pending ? w.staff.review : w.staff.open });
       return { to: [], subject: fill(pending ? w.staff.pendingSubject : w.staff.bookedSubject, vars), ...m, replyTo: c.booking.email || undefined };
     }
+    case 'staff-rsvp':
+    case 'staff-rsvp-cancelled': {
+      const r = w.rsvpStaff, s = c.rsvpStaff!, b = c.booking;
+      const cancelled = kind === 'staff-rsvp-cancelled', pending = !cancelled && b.status === 'pending';
+      const seats = String(b.seats), count = String(s.taken);
+      const answers = Object.entries(b.answers).map(([k, v]) => `${k}: ${v}`).join('\n');
+      const rows: [string, string][] = [
+        [r.name, b.name], [r.email, b.email], ...(b.phone ? [[r.phone, b.phone] as [string, string]] : []), [w.when, c.when],
+        [w.seats, fill(cancelled ? (b.seats === 1 ? r.seatFreed : r.seatsFreed) : pending ? r.pending : r.confirmed, { seats })],
+        ...(answers ? [[r.answers, answers] as [string, string]] : []),
+        [r.now, s.capacity ? fill(r.seatsTakenOf, { count, capacity: String(s.capacity) }) : fill(s.taken === 1 ? r.seatTaken : r.seatsTaken, { count })],
+      ];
+      const vars = { title: c.title, date: s.date };
+      const footer = `${r.via[s.via === 'web' || s.via === 'app' ? s.via : 'staff']} · ${s.why === 'hosts' ? r.hosts : r.noHosts}`;
+      const m = layout(fill(cancelled ? r.cancelledHeading : r.heading, vars), '', c, w, { href: c.manageUrl, label: c.mineLink ? r.openMine : pending ? w.staff.review : w.staff.open }, { rows, footer });
+      return { to: [], subject: fill(cancelled ? r.cancelledSubject : r.subject, vars), ...m, replyTo: b.email || undefined };
+    }
   }
 }

package/src/lib/booking/service.ts

@@ -9,15 +9,21 @@ import { loadFeed, expandVEvents } from '../calendar/ics';
 import { emitWebhook } from '../webhooks';
 import { parseFrom } from '../email/config';
 import { kickEmail } from '../email/service';
+import type { RsvpStaffNotice } from '../email/types';
+import { LEGAL } from '../legal/config';
+import { isRole } from '../roles';
+import { siteLocale } from '../dates';
 import { eventUrl } from '../calendar/config';
 import { eventTimeZone, locationLine, occurrenceKey, rsvpDeadline } from '../calendar/events';
 import { normalizePageLocale } from '../i18n';
 import { localizeDoc } from '../translations';
 import { bookingStrings } from '../email/booking-words';
-import { bookingEmail, bookingLanguage, bookingManagePath, whenText, type BookingEmail } from './emails';
+import { bookingEmail, bookingLanguage, bookingManagePath, untilText, whenText, type BookingEmail } from './emails';
 import { holdOf, isBookable, resourceZone, spanEnd, type AvailabilityContext, type Interval } from './availability';
 import { decideStatus, linkApproval } from './approval';
 import { eventHolds } from './holds';
+import { MEMBERS, memberEventsPath } from '../calendar/members-config';
+import { principalCan } from '../permissions/access';
 
 export interface FlowOptions {
   origin: string;
@@ -37,6 +43,9 @@ const token = () => {
   return btoa(String.fromCharCode(...bytes)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 };
 
+/** how long a spot freed for the next person on a waitlist is held for them (ms) */
+export const WAITLIST_HOLD = 24 * 3_600_000;
+
 // ---- availability context ------------------------------------------------
 
 const busyCache = new Map<string, { at: number; intervals: Interval[] }>();
@@ -88,7 +97,7 @@ async function describe(repo: ContentRepository, b: Booking, settings: Settings,
     const ev = raw && locale ? localizeDoc(raw, locale) : raw;
     const tz = ev ? eventTimeZone(ev, settings) : settings.timezone || 'UTC';
     return {
-      resource: null, link: null, event: ev,
+      resource: null, link: null, event: ev, tz,
       title: ev?.title ?? 'Event',
       location: ev ? locationLine(ev.location) : '',
       when: whenText(b, tz, settings, ev?.allDay),
@@ -97,7 +106,7 @@ async function describe(repo: ContentRepository, b: Booking, settings: Settings,
   const [resource, link] = await Promise.all([repo.getResource(b.resourceId), b.linkId ? repo.getBookingLink(b.linkId) : Promise.resolve(null)]);
   const tz = resource ? resourceZone(resource, settings.timezone) : settings.timezone || 'UTC';
   return {
-    resource, link, event: null as CalEvent | null,
+    resource, link, event: null as CalEvent | null, tz,
     title: [resource?.name, link?.name].filter(Boolean).join(' · ') || 'Booking',
     location: resource?.name ?? '',
     when: whenText(b, tz, settings, link?.mode === 'day'),
@@ -114,11 +123,17 @@ export function bookingJson(b: Booking, extra: { title?: string; resourceSlug?:
   };
 }
 
-// snapshot.locale: the language to use instead of the booking's (a link sent again)
-export async function bookingMail(repo: ContentRepository, b: Booking, kind: BookingEmail, origin: string, from = '', snapshot?: { message?: string; eventTitle?: string; eventLocation?: string; eventAllDay?: number; locale?: string }) {
+// the booking in the admin; an RSVP among its event's (a cancelled one under Cancelled)
+const adminBookingUrl = (origin: string, b: Booking, kind: BookingEmail) =>
+  `${origin}/admin/calendar/bookings?${b.eventId ? `event=${encodeURIComponent(b.eventId)}&` : ''}${kind === 'staff-rsvp-cancelled' ? 'tab=cancelled&' : ''}b=${b.id}`;
+
+// snapshot.locale: the language to use instead of the booking's (a link sent
+// again); taken/why/via: a staff RSVP email's job (rsvpStaffJobs)
+export async function bookingMail(repo: ContentRepository, b: Booking, kind: BookingEmail, origin: string, from = '', snapshot?: { message?: string; eventTitle?: string; eventLocation?: string; eventAllDay?: number; locale?: string; taken?: number; why?: RsvpStaffNotice['why']; via?: Booking['source'] }, recipient = '') {
   const site = await repo.getSettings();
+  const staff = kind.startsWith('staff-');
   // the guest hears in the language they booked in; staff in the main one
-  const language = bookingLanguage(kind === 'staff-new' ? { locale: '' } : typeof snapshot?.locale === 'string' ? { locale: snapshot.locale } : b, site);
+  const language = bookingLanguage(staff ? { locale: '' } : typeof snapshot?.locale === 'string' ? { locale: snapshot.locale } : b, site);
   const settings = language.settings;
   const d = await describe(repo,b,settings,language.locale);
   if (b.kind === 'rsvp' && !d.event && snapshot?.eventTitle) {
@@ -126,10 +141,47 @@ export async function bookingMail(repo: ContentRepository, b: Booking, kind: Boo
     try { d.location = locationLine(JSON.parse(snapshot.eventLocation || '{}')); } catch { d.location = ''; }
     d.when = whenText(b,b.timezone || settings.timezone || 'UTC',settings,!!snapshot.eventAllDay);
   }
+  // "Fri Nov 7": the subject's date, in the event's zone
+  const counts = kind === 'staff-rsvp' || kind === 'staff-rsvp-cancelled' ? {
+    date: new Intl.DateTimeFormat(siteLocale(settings), { weekday: 'short', month: 'short', day: 'numeric', timeZone: d.tz }).format(b.start).replace(/,/g, ''),
+    taken: snapshot?.taken ?? await seatsTaken(repo, b.eventId, b.start), capacity: d.event?.rsvp.capacity ?? 0,
+    why: snapshot?.why ?? 'hosts', via: snapshot?.via ?? b.source,
+  } : undefined;
+  // a host without Manage bookings (a member who hosts) gets their My events
+  // page for the event instead of an admin page they can't open
+  const mine = counts && d.event && recipient ? await memberHostPath(repo, d.event, recipient) : '';
+  // a place in line (its number when sent) or a held spot (until when, in the event's zone)
+  const waitlist = b.status === 'waitlisted' || b.status === 'offered' ? {
+    position: await waitlistPosition(repo, b), hours: WAITLIST_HOLD / 3_600_000,
+    until: b.holdUntil === null ? '' : untilText(b.holdUntil, d.tz, settings),
+  } : undefined;
   return bookingEmail(kind, { booking:b,resource:d.resource,link:d.link,title:d.title,location:d.location,when:d.when,
-    manageUrl:kind === 'staff-new' ? `${origin}/admin/calendar/bookings?b=${b.id}` : origin + bookingManagePath({ manageToken: b.manageToken, locale: language.locale }),
+    manageUrl:mine ? origin + mine : staff ? adminBookingUrl(origin, b, kind) : origin + bookingManagePath({ manageToken: b.manageToken, locale: language.locale }),
+    mineLink: !!mine,
     siteTitle:settings.siteTitle,host:new URL(origin).host,organizer:parseFrom(from)?.email,message:snapshot?.message,
-    allDay:d.link?.mode==='day'||!!d.event?.allDay||(!d.event&&!!snapshot?.eventAllDay), lang:language.lang });
+    allDay:d.link?.mode==='day'||!!d.event?.allDay||(!d.event&&!!snapshot?.eventAllDay), lang:language.lang, rsvpStaff: counts, waitlist });
+}
+
+/** The member's My events page for an event they host, when they can't manage bookings in the admin ('' otherwise). */
+async function memberHostPath(repo: ContentRepository, e: CalEvent, email: string): Promise<string> {
+  const user = (await repo.listUsers()).find((u) => u.email && u.email.trim().toLowerCase() === email.trim().toLowerCase());
+  if (!user || !MEMBERS.enabled || !e.hostIds.includes(user.id)) return '';
+  return (await principalCan(repo, { user }, 'schedule.bookings')) ? '' : `${memberEventsPath()}/${encodeURIComponent(e.id)}`;
+}
+
+/**
+ * Who hears about an event's RSVPs (rsvp.notifyStaff): its hosts, else the
+ * contact email in Settings → Legal (then acms({ legal }), as legalOperator
+ * reads it), else the owners. Accounts that were removed, or whose role the
+ * site no longer has, are skipped. via: where the person did it.
+ */
+export async function rsvpStaff(repo: ContentRepository, e: CalEvent, settings: Settings, via: Booking['source']): Promise<RsvpStaffNotice | undefined> {
+  if (!e.rsvp.notifyStaff) return undefined;
+  const contact = settings.legal.contactEmail || LEGAL.contactEmail;
+  const users = e.hostIds.length || !contact ? (await repo.listUsers()).filter((u) => u.email && isRole(u.role)) : [];
+  const hosts = users.filter((u) => e.hostIds.includes(u.id)).map((u) => u.email);
+  const to = hosts.length ? hosts : contact ? [contact] : users.filter((u) => u.role === 'owner').map((u) => u.email);
+  return { to: [...new Set(to.map((a) => a.trim().toLowerCase()))].filter(Boolean), why: hosts.length ? 'hosts' : 'contact', via };
 }
 async function notify(repo: ContentRepository, _b: Booking, _kinds: BookingEmail[], opts: FlowOptions, _message?: string) {
   // Repository mutations already committed their outbox jobs atomically.
@@ -195,22 +247,29 @@ export function guestChanges(b: Booking, link: BookingLink | null, now = Date.no
   const active = b.status === 'pending' || b.status === 'confirmed';
   const cutoff = b.kind === 'booking' ? (link?.changeCutoff ?? 0) : 0;
   const closed = active && cutoff > 0 && b.start - now < cutoff * 3_600_000;
-  const open = active && b.end > now && !closed;
+  // a place in line or a held spot can be left until the date ends
+  const open = (active || b.status === 'waitlisted' || b.status === 'offered') && b.end > now && !closed;
   return {
     cancel: open,
-    reschedule: open && b.kind === 'booking' && b.start > now && !!link?.active,
+    reschedule: open && active && b.kind === 'booking' && b.start > now && !!link?.active,
+    // a spot offered from the waitlist, still held for them
+    confirm: b.status === 'offered' && (b.holdUntil ?? 0) > now && b.end > now,
     // hours before the start when guest changes close; 0 = until it ends
     cutoffHours: cutoff,
     closed,
   };
 }
 
-export async function guestCancel(repo: ContentRepository, b: Booking, opts: FlowOptions): Promise<Booking> {
+// via: where they cancelled (the manage page, or an app)
+export async function guestCancel(repo: ContentRepository, b: Booking, opts: FlowOptions, via: Booking['source'] = 'web'): Promise<Booking> {
   const link = b.linkId ? await repo.getBookingLink(b.linkId) : null;
   if (b.status === 'cancelled') return b;
   const can = guestChanges(b, link, opts.now);
   if (!can.cancel) throw new BookingError(409, can.closed ? `Changes close ${can.cutoffHours} hours before the start. Please contact us to cancel.` : 'This booking can’t be cancelled.');
-  return setBookingStatus(repo, b, 'cancelled', opts);
+  // the person cancelled an RSVP: its hosts hear about it (staff cancelling never emails staff;
+  // leaving the waitlist or a held spot isn't an RSVP to them)
+  const event = b.kind === 'rsvp' && b.eventId && (b.status === 'pending' || b.status === 'confirmed') ? await repo.getEvent(b.eventId) : null;
+  return setBookingStatus(repo, b, 'cancelled', opts, undefined, event ? await rsvpStaff(repo, event, await repo.getSettings(), via) : undefined);
 }
 
 /** the link as a guest moving a booking sees it: no new time inside the change cutoff */
@@ -266,14 +325,34 @@ export async function createBlock(repo: ContentRepository, resource: Resource, s
   });
 }
 
+// pending, confirmed and held (offered) RSVPs take seats, as in the capacity
+// check; a place in line doesn't
+const seated = (s: BookingStatus) => s === 'pending' || s === 'confirmed' || s === 'offered';
 export async function seatsTaken(repo: ContentRepository, eventId: string, start: number): Promise<number> {
-  const list = await repo.listBookings({ eventId, from: start - 1, to: start + 1, statuses: ['pending', 'confirmed'], kinds: ['rsvp'] });
+  const list = await repo.listBookings({ eventId, from: start - 1, to: start + 1, statuses: ['pending', 'confirmed', 'offered'], kinds: ['rsvp'] });
   return list.filter((b) => b.start === start).reduce((n, b) => n + b.seats, 0);
 }
 
+/** whether a full date takes places in line: the event keeps a waitlist and has a capacity */
+export const waitlistOn = (e: CalEvent) => e.rsvp.enabled && e.rsvp.waitlist && e.rsvp.capacity > 0;
+
+/** a date's waitlist in order: who joined first, then by id */
+export async function waitlistLine(repo: ContentRepository, eventId: string, start: number): Promise<Booking[]> {
+  const list = await repo.listBookings({ eventId, from: start - 1, to: start + 1, statuses: ['waitlisted'], kinds: ['rsvp'] });
+  return list.filter((b) => b.start === start).sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+
+/** a waitlisted RSVP's place in its date's line (1 = next), else null */
+export async function waitlistPosition(repo: ContentRepository, b: Booking): Promise<number | null> {
+  if (b.status !== 'waitlisted') return null;
+  const i = (await waitlistLine(repo, b.eventId, b.start)).findIndex((x) => x.id === b.id);
+  return i < 0 ? null : i + 1;
+}
+
 export async function createRsvp(
   repo: ContentRepository,
-  args: { event: CalEvent; start: number; end: number; seats: number; booker: BookerInput; source?: Booking['source'] },
+  // waitlist: a full date (fewer seats left than asked) takes a place in line instead, when the event keeps one
+  args: { event: CalEvent; start: number; end: number; seats: number; booker: BookerInput; source?: Booking['source']; waitlist?: boolean },
   opts: FlowOptions
 ): Promise<Booking> {
   const e = args.event;
@@ -294,15 +373,22 @@ export async function createRsvp(
   if (formResponse) booker.answers = displayAnswers(formResponse);
   // one RSVP per address and date on public channels; staff may add more
   const once = args.source !== 'admin';
-  const b = await repo.createBooking({
-    kind: 'rsvp', resourceId: '', linkId: '', eventId: e.id, status: e.rsvp.autoConfirm ? 'confirmed' : 'pending',
+  const source = args.source ?? 'web';
+  // the hosts' email is queued with the RSVP: a duplicate or a replay inserts nothing, so it emails no one
+  const data = {
+    kind: 'rsvp' as const, resourceId: '', linkId: '', eventId: e.id, status: (e.rsvp.autoConfirm ? 'confirmed' : 'pending') as BookingStatus,
     start: args.start, end: args.end, holdStart: args.start, holdEnd: args.end, timezone: e.timezone, ...booker, seats,
-    formResponse, notes: '', manageToken: token(), source: args.source ?? 'web', locale: normalizePageLocale(args.booker.locale ?? ''),
-  }, { capacity: e.rsvp.capacity, oncePerEmail: once, idempotency: opts.idempotency });
+    formResponse, notes: '', manageToken: token(), source, locale: normalizePageLocale(args.booker.locale ?? ''),
+  };
+  let b = await repo.createBooking(data, { capacity: e.rsvp.capacity, oncePerEmail: once, idempotency: opts.idempotency, staff: await rsvpStaff(repo, e, settings, source) });
+  // full: a place in line, which takes no seats and emails no staff (still one per address and date)
+  if (!b && args.waitlist && waitlistOn(e) && !(opts.idempotency && await repo.getBookingRequest(opts.idempotency.keyHash))) {
+    b = await repo.createBooking({ ...data, status: 'waitlisted' }, { oncePerEmail: once, idempotency: opts.idempotency });
+  }
   if (!b) {
     // a retry of a request that just committed: the caller replays that one
     const retry = opts.idempotency ? await repo.getBookingRequest(opts.idempotency.keyHash) : null;
-    const mine = once && !retry ? (await repo.listBookings({ eventId: e.id, email: booker.email, from: args.start - 1, to: args.start + 1, statuses: ['pending', 'confirmed'], kinds: ['rsvp'] })).find((x) => x.start === args.start) : undefined;
+    const mine = once && !retry ? (await repo.listBookings({ eventId: e.id, email: booker.email, from: args.start - 1, to: args.start + 1, statuses: ['pending', 'confirmed', 'offered', 'waitlisted'], kinds: ['rsvp'] })).find((x) => x.start === args.start) : undefined;
     if (mine) {
       await resendManageLink(repo, mine, args.booker.locale === undefined ? mine.locale : normalizePageLocale(args.booker.locale), opts);
       // anyone can type an address: say only that it has one
@@ -310,12 +396,101 @@ export async function createRsvp(
     }
     throw new BookingError(409, e.rsvp.capacity ? 'Sorry — that’s more seats than are left.' : 'Couldn’t save your RSVP.');
   }
-  await notify(repo, b, [b.status === 'confirmed' ? 'confirmed' : 'received'], opts);
+  await notify(repo, b, [b.status === 'confirmed' ? 'confirmed' : 'received', 'staff-rsvp'], opts);
   await hook(repo, 'booking.created', b, opts);
   if (b.status === 'confirmed') await hook(repo, 'booking.confirmed', b, opts);
   return b;
 }
 
+/**
+ * Offers a date's freed seats to its waitlist, in order: each person whose
+ * seats fit what's free gets them held for WAITLIST_HOLD, with an email to
+ * confirm; larger requests keep their place. Runs after anything that frees
+ * seats (a cancellation, a decline, a spot that ran out, a capacity raised)
+ * and from the scheduler. Only while the event keeps a waitlist and before
+ * the date starts, past its RSVP deadline too: those in line joined in time.
+ * Each offer re-checks the seats in the database, so racing runs (or a new
+ * RSVP) never take more than the capacity. Returns how many it offered.
+ */
+export async function offerWaitlist(repo: ContentRepository, eventId: string, start: number, opts: FlowOptions): Promise<number> {
+  const now = opts.now ?? Date.now();
+  if (start <= now) return 0;
+  const line = await waitlistLine(repo, eventId, start);
+  if (!line.length) return 0;
+  const e = await repo.getEvent(eventId);
+  // turning the waitlist off only stops new people joining: those already in line still get their turn
+  if (!e || !e.rsvp.enabled || e.cancelled) return 0;
+  if (e.cancelledDates?.length && e.cancelledDates.includes(occurrenceKey(e, start, await repo.getSettings()))) return 0;
+  const cap = e.rsvp.capacity;
+  const free = async () => (cap ? cap - await seatsTaken(repo, eventId, start) : Infinity);
+  let left = await free(), offered = 0;
+  for (const b of line) {
+    if (left <= 0) break;
+    if (b.seats > left) continue;
+    if (await repo.offerBooking(b.id, now + WAITLIST_HOLD, cap)) { left -= b.seats; offered++; }
+    // someone took seats meanwhile: count again
+    else left = await free();
+  }
+  if (offered) await kickEmail(repo, opts.locals, opts.waitUntil);
+  return offered;
+}
+
+/** every upcoming date of one event with people in line (after an edit that may have freed seats) */
+export async function offerEventWaitlist(repo: ContentRepository, eventId: string, opts: FlowOptions): Promise<number> {
+  const now = opts.now ?? Date.now();
+  const starts = new Set((await repo.listBookings({ eventId, from: now, statuses: ['waitlisted'], kinds: ['rsvp'] })).map((b) => b.start));
+  let offered = 0;
+  for (const start of starts) offered += await offerWaitlist(repo, eventId, start, opts);
+  return offered;
+}
+
+/**
+ * The person takes the spot held for them (manage page, app): confirmed, or
+ * pending when the event approves each RSVP, with the usual email and the
+ * hosts' "New RSVP" one. Past its hold the spot is released (410) and goes
+ * to the next person in line. Repeating it is harmless.
+ */
+export async function confirmOffer(repo: ContentRepository, b: Booking, opts: FlowOptions, via: Booking['source'] = 'web'): Promise<Booking> {
+  const now = opts.now ?? Date.now();
+  if (b.status === 'confirmed' || b.status === 'pending') return b;
+  if (b.status === 'offered' && (b.holdUntil ?? 0) <= now) {
+    await releaseOffer(repo, b, opts);
+    throw new BookingError(410, 'This held spot was released.');
+  }
+  if (b.status === 'expired') throw new BookingError(410, 'This held spot was released.');
+  if (b.status !== 'offered') throw new BookingError(409, 'There’s no held spot to confirm.');
+  if (b.end <= now) throw new BookingError(410, 'This event has already happened.');
+  const event = b.eventId ? await repo.getEvent(b.eventId) : null;
+  try {
+    return await setBookingStatus(repo, b, event?.rsvp.autoConfirm === false ? 'pending' : 'confirmed', opts, undefined, event ? await rsvpStaff(repo, event, await repo.getSettings(), via) : undefined);
+  } catch (err) {
+    if ((await repo.getBooking(b.id))?.status === 'expired') throw new BookingError(410, 'This held spot was released.');
+    throw err;
+  }
+}
+
+// a held spot nobody confirmed in time: expired (no email; only if it's still
+// offered), and its seats go to the next person in line
+async function releaseOffer(repo: ContentRepository, b: Booking, opts: FlowOptions) {
+  if (await repo.expireBooking(b.id, opts.now ?? Date.now())) await offerWaitlist(repo, b.eventId, b.start, opts);
+}
+
+// cron: held spots past their time run out, and every upcoming date with
+// people in line is offered what's free (catching up on seats freed by edits,
+// or by a change that lost a race)
+export async function sweepWaitlist(repo: ContentRepository, opts: FlowOptions): Promise<number> {
+  const now = opts.now ?? Date.now();
+  const list = await repo.listBookings({ from: now, statuses: ['waitlisted', 'offered'], kinds: ['rsvp'] });
+  const dates = new Map<string, { eventId: string; start: number }>();
+  for (const b of list) {
+    if (b.status === 'offered' && (b.holdUntil ?? 0) <= now) await repo.expireBooking(b.id, now);
+    dates.set(`${b.eventId}:${b.start}`, { eventId: b.eventId, start: b.start });
+  }
+  let offered = 0;
+  for (const d of dates.values()) offered += await offerWaitlist(repo, d.eventId, d.start, opts);
+  return offered;
+}
+
 // The address gets its RSVP's own link again, in the language it just used,
 // at most once per 10 minutes per RSVP so the form can't flood an inbox.
 async function resendManageLink(repo: ContentRepository, b: Booking, locale: string, opts: FlowOptions) {
@@ -330,9 +505,14 @@ const TRANSITIONS: Record<BookingStatus, BookingStatus[]> = {
   confirmed: ['cancelled'],
   declined: ['confirmed'],
   cancelled: ['confirmed'],
+  // only offerWaitlist offers a place in line, and only the clock expires a held spot
+  waitlisted: ['cancelled'],
+  offered: ['confirmed', 'pending', 'cancelled'],
+  expired: [],
 };
 
-export async function setBookingStatus(repo: ContentRepository, b: Booking, status: BookingStatus, opts: FlowOptions, message?: string): Promise<Booking> {
+// staff: who to tell that the person cancelled (guestCancel); staff changes tell no one
+export async function setBookingStatus(repo: ContentRepository, b: Booking, status: BookingStatus, opts: FlowOptions, message?: string, staff?: RsvpStaffNotice): Promise<Booking> {
   if (b.status === status) return b;
   if (!TRANSITIONS[b.status].includes(status)) throw new BookingError(409, `A ${b.status} booking can’t become ${status}.`);
   // re-confirming a declined/cancelled booking must re-check the slot
@@ -341,13 +521,17 @@ export async function setBookingStatus(repo: ContentRepository, b: Booking, stat
       .some((x) => x.id !== b.id && x.kind !== 'rsvp' && x.holdStart < b.holdEnd && x.holdEnd > b.holdStart);
     if (clash) throw new BookingError(409, 'That time has been booked since — it can’t be restored.');
   }
-  await repo.updateBooking(b.id, { status, notificationMessage: message });
+  // only from the status it was read in: a spot that ran out meanwhile can't be confirmed
+  await repo.updateBooking(b.id, { status, from: b.status, notificationMessage: message, staff });
   const next = (await repo.getBooking(b.id))!;
   if (!next || next.status !== status) throw new BookingError(409, 'This booking changed. Refresh and try again.');
   if (b.kind !== 'block') {
     await notify(repo, next, [status === 'confirmed' ? 'confirmed' : status === 'declined' ? 'declined' : 'cancelled'], opts, message);
-    await hook(repo, status === 'confirmed' ? 'booking.confirmed' : status === 'declined' ? 'booking.declined' : 'booking.cancelled', next, opts);
+    // a held spot taken up for approval is no webhook yet (approving it is)
+    if (status !== 'pending') await hook(repo, status === 'confirmed' ? 'booking.confirmed' : status === 'declined' ? 'booking.declined' : 'booking.cancelled', next, opts);
   }
+  // the seats it held go to the next people in line
+  if (b.kind === 'rsvp' && seated(b.status) && !seated(status)) await offerWaitlist(repo, b.eventId, b.start, opts);
   return next;
 }
 

package/src/lib/calendar/api.ts

@@ -27,7 +27,8 @@ export interface EventJson {
   cancelledDates: string[];
   location: CalEvent['location'];
   cta: CalEvent['cta'];
-  rsvp?: CalEvent['rsvp'];
+  // notifyStaff (whether the hosts get RSVP emails) only for staff callers
+  rsvp?: Omit<CalEvent['rsvp'], 'notifyStaff'> & Partial<Pick<CalEvent['rsvp'], 'notifyStaff'>>;
   image: string;
   imageAlt: string;
   tags: string[];
@@ -59,7 +60,7 @@ export function eventToJson(e: CalEvent, origin: string, calendars: Map<string,
     cancelledDates: e.cancelledDates ?? [],
     location: e.location,
     cta: e.cta,
-    rsvp: e.rsvp,
+    rsvp: opts.includePrivate ? e.rsvp : (({ notifyStaff: _, ...rsvp }) => rsvp)(e.rsvp),
     image: e.cover ? abs(origin, e.cover) : '',
     imageAlt: e.coverAlt,
     tags: e.tags.filter((t) => !t.startsWith('#')),

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

@@ -0,0 +1,5 @@
+import { userConfig } from 'virtual:acms-config';
+
+/** where the built-in member pages live (acms({ members })); `notify` hears about new requests */
+export const MEMBERS: { enabled: boolean; base: string; notify: string[] } = { enabled: false, base: '/members', notify: [], ...(userConfig.members ?? {}) };
+export const memberEventsPath = () => `${MEMBERS.base}/events`;

package/src/lib/calendar/requests.ts

@@ -1,4 +1,3 @@
-import { userConfig } from 'virtual:acms-config';
 import type { ContentRepository } from '../repo/types';
 import type { CalEvent, EventRequest } from '../schema';
 import { EventLocation } from '../schema';
@@ -20,9 +19,10 @@ import { kickEmail } from '../email/service';
 // Everything here checks who is acting, so the built-in member pages and a
 // site's own pages (through @acms-subir/core/server) share the same rules.
 
-/** where the built-in member pages live (acms({ members })); `notify` hears about new requests */
-export const MEMBERS: { enabled: boolean; base: string; notify: string[] } = { enabled: false, base: '/members', notify: [], ...(userConfig.members ?? {}) };
-export const memberEventsPath = () => `${MEMBERS.base}/events`;
+// acms({ members }) and the My events path live on their own, so booking
+// emails (which this code depends on) can read them without an import cycle
+export { MEMBERS, memberEventsPath } from './members-config';
+import { MEMBERS, memberEventsPath } from './members-config';
 
 /** who is acting: currentUser() from @acms-subir/core/server fits */
 export interface Actor { id: string; can(permission: string): boolean }