@acms-subir/core 0.3.39 → 0.3.41

package/src/lib/mobile/bookings.ts

@@ -23,8 +23,9 @@ export const bookingInput = z.union([
   z.object({ ...common, resource: z.string().min(1).max(200), link: z.string().min(1).max(200),
     minutes: z.number().int().min(1).max(44640).optional(),
   }).strict(),
-  // formVersion: from GET /events/{slug}/rsvp; required when the event asks questions
-  z.object({ ...common, event: z.string().min(1).max(200), seats: z.number().int().min(1).max(1000).default(1), formVersion: z.string().max(100).optional() }).strict(),
+  // formVersion: from GET /events/{slug}/rsvp; required when the event asks questions.
+  // waitlist: a full date takes a place in line instead (when the event keeps a waitlist)
+  z.object({ ...common, event: z.string().min(1).max(200), seats: z.number().int().min(1).max(1000).default(1), formVersion: z.string().max(100).optional(), waitlist: z.boolean().optional() }).strict(),
 ]);
 function canonical(value: unknown): string {
   if (value && typeof value === 'object' && !Array.isArray(value)) return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k,v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(',')}}`;
@@ -67,7 +68,7 @@ export async function submitBooking(repo: ContentRepository, request: Request, l
       // the app must have seen the current questions: a changed form then answers 409, as on the website
       // (closed dates fall through to createRsvp's own answer)
       if (!body.formVersion && rsvpQuestions(event) && !rsvpClosed(occurrence, settings)) throw new ApiError(400, 'This event asks questions. Send formVersion from GET /api/v1/events/{slug}/rsvp with the answers.');
-      booking = await createRsvp(repo, { event, start, end: occurrence.end, seats: body.seats, booker, source: 'app' }, flow);
+      booking = await createRsvp(repo, { event, start, end: occurrence.end, seats: body.seats, booker, source: 'app', waitlist: body.waitlist }, flow);
     } else {
       const resource = await repo.getResourceBySlug(body.resource);
       const link = resource ? await repo.getBookingLinkBySlug(resource.id, body.link) : null;

package/src/lib/mobile/calendar.ts

@@ -4,7 +4,7 @@ import { publicTags, tagFilter, type BookingLink, type CalEvent, type Calendar,
 import { ApiError } from '../api';
 import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl, publicEventFields } from '../calendar/config';
 import { calendarToJson, eventToJson } from '../calendar/api';
-import { eventIsListed, eventIsPublic, expandEvents } from '../calendar/events';
+import { eventIsListed, eventIsPublic, expandEvents, featuredOccurrence } from '../calendar/events';
 import { availabilityContext } from '../booking/service';
 import { addDaysYmd, describeLink, linkLengths, localMidnight, slotsForDay, ymd } from '../booking/availability';
 import { siteOrigin } from '../seo';
@@ -65,6 +65,28 @@ export async function listEvents(repo: ContentRepository, url: URL) {
     pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
   };
 }
+// one event by slug (or id), whatever its date: apps open it from a link, a
+// push or an announcement, often weeks ahead. `on` ('YYYY-MM-DD', like the
+// website's ?on=) picks that day's occurrence; otherwise the next one, or the
+// most recent when it's over.
+export const eventDetailQuery = z.object({ locale: localeQuery, on: isoDay.optional() }).strict();
+export async function getEventDetail(repo: ContentRepository, url: URL, ref: string) {
+  requireCalendar();
+  const q = eventDetailQuery.parse(queryParams(url));
+  const locale = mobileLocale(q.locale);
+  const [settings, calendars] = await Promise.all([repo.getSettings(), repo.listCalendars()]);
+  const found = ref && ref.length <= 200 ? await repo.getEventBySlug(ref) ?? await repo.getEvent(ref) : null;
+  const all = new Map(calendars.map(c => [c.id, c]));
+  if (!found || !eventIsPublic(found, all)) throw new ApiError(404, 'Event not found.');
+  const e = localizeDoc(found, locale ?? undefined);
+  const o = featuredOccurrence(e, settings, Date.now(), q.on);
+  const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public').map(c => [c.id, c]));
+  return {
+    locale,
+    occurrence: o ? { id: `${e.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay, cancelled: o.cancelled } : null,
+    event: publicEventDto(e, siteOrigin(settings, url), publicCalendars, settings, locale),
+  };
+}
 // e is already localized; publicCalendars limits which calendars are named
 export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, settings: Settings, locale: string | null) {
   const event = eventToJson(e, origin, publicCalendars, settings.timezone);

package/src/lib/mobile/manage.ts

@@ -6,7 +6,7 @@ import { eventTimeZone, locationLine } from '../calendar/events';
 import { resourceZone, linkLengths } from '../booking/availability';
 import { bookingIcs, bookingLanguage, bookingManagePath } from '../booking/emails';
 import { localePath } from '../i18n';
-import { guestCancel, guestChanges, guestMoveLink, guestReschedule } from '../booking/service';
+import { confirmOffer, guestCancel, guestChanges, guestMoveLink, guestReschedule, waitlistPosition } from '../booking/service';
 import { siteOrigin } from '../seo';
 import { waitUntilFrom } from '../webhooks';
 import { isoDay, queryParams } from './http';
@@ -44,7 +44,8 @@ async function managed(c: PublicContext): Promise<Managed> {
   return { booking, settings, resource, link, event, origin: siteOrigin(settings, c.url) };
 }
 
-function view(m: Managed, booking = m.booking) {
+// position: a waitlisted RSVP's place in line (view() can't query)
+function view(m: Managed, booking = m.booking, position: number | null = null) {
   const { resource, link, event, settings, origin } = m;
   const can = guestChanges(booking, link);
   return {
@@ -55,6 +56,8 @@ function view(m: Managed, booking = m.booking) {
       timezone: event ? eventTimeZone(event, settings) : resource ? resourceZone(resource, settings.timezone) : settings.timezone || 'UTC',
       seats: booking.seats, name: booking.name, email: booking.email, phone: booking.phone, answers: booking.answers,
       createdAt: new Date(booking.createdAt).toISOString(),
+      // in line: its place (1 = next); a held spot: until when
+      position, holdUntil: booking.status === 'offered' && booking.holdUntil !== null ? new Date(booking.holdUntil).toISOString() : null,
     },
     title: event ? event.title : [resource?.name, link?.name].filter(Boolean).join(' · ') || 'Booking',
     location: event ? locationLine(event.location) : resource?.name ?? '',
@@ -71,11 +74,22 @@ function view(m: Managed, booking = m.booking) {
 }
 const flow = (m: Managed, c: PublicContext) => ({ origin: m.origin, locals: c.locals, waitUntil: waitUntilFrom(c.locals) });
 
-export const getManaged = async (c: PublicContext) => view(await managed(c));
+const placed = async (c: PublicContext, m: Managed, booking = m.booking) => view(m, booking, await waitlistPosition(c.repo, booking));
+
+export async function getManaged(c: PublicContext) {
+  const m = await managed(c);
+  return placed(c, m);
+}
 
 export async function cancelManaged(c: PublicContext) {
   const m = await managed(c);
-  return view(m, await guestCancel(c.repo, m.booking, flow(m, c)));
+  return view(m, await guestCancel(c.repo, m.booking, flow(m, c), 'app'));
+}
+
+// take the spot the waitlist offered them; past its hold, 410 and it goes to the next person
+export async function confirmManaged(c: PublicContext) {
+  const m = await managed(c);
+  return view(m, await confirmOffer(c.repo, m.booking, flow(m, c), 'app'));
 }
 
 export const manageAvailabilityQuery = z.object({

package/src/lib/mobile/openapi.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import type { ContentRepository } from '../repo/types';
 import { contentQuery, contentDetailQuery } from './content';
-import { eventsQuery, availabilityQuery } from './calendar';
+import { eventsQuery, eventDetailQuery, availabilityQuery } from './calendar';
 import { bookingInput } from './bookings';
 import { rsvpQuery } from './rsvp';
 import { pagesQuery } from './pages';
@@ -51,6 +51,7 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
     ['/content/{id}', 'Published content detail', contentDetailQuery, ref('Content')],
     ['/search', 'Ranked matches across posts, pages and events (top limit per group); requires search', searchQuery, ref('SearchResults')],
     ['/events', 'Public event occurrences; requires calendar', eventsQuery, ref('Events')],
+    ['/events/{slug}', 'One public event by slug or id, whatever its date, with its next occurrence (or the one on `on`, YYYY-MM-DD; the most recent once it is over); requires calendar', eventDetailQuery, ref('EventDetail')],
     ['/calendars', 'Public calendars; requires calendar', empty, ref('Calendars')],
     ['/events/{slug}/rsvp', 'RSVP status of one date (start = the occurrence start exactly): open or why not, live seats, the questions and their version; never cached; requires calendar', rsvpQuery, ref('RsvpStatus'), false],
     ['/resources', 'Public resources and booking links; requires bookings', z.object(pageQuery).strict(), ref('Resources')],
@@ -79,7 +80,7 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
   paths['/api/v1/bookings'] = {
     post: {
       summary: 'Create a guest booking or an RSVP, or replay an existing request; RSVPs require calendar, room bookings also bookings',
-      description: '20 attempts/minute/client address. JSON body up to 50,000 bytes. Responses use no-store. Reuse a random UUID v4 once per booking intent. Checkbox groups send a list of answers. An RSVP to an event with questions needs formVersion from GET /events/{slug}/rsvp; a changed form answers 409. An RSVP from an email that already has one for that date answers 409 with code duplicate (and emails that RSVP’s link again); past the event’s RSVP deadline, 410.',
+      description: '20 attempts/minute/client address. JSON body up to 50,000 bytes. Responses use no-store. Reuse a random UUID v4 once per booking intent. Checkbox groups send a list of answers. An RSVP to an event with questions needs formVersion from GET /events/{slug}/rsvp; a changed form answers 409. An RSVP from an email that already has one for that date (a place on its waitlist too) answers 409 with code duplicate (and emails that RSVP’s link again); past the event’s RSVP deadline, 410. A full date answers 409, unless the event keeps a waitlist (RsvpStatus.waitlist.enabled) and the RSVP sends waitlist: true: then it takes a place in line (status waitlisted, no seats) and is emailed when a spot opens.',
       parameters: [{ name: 'Idempotency-Key', in: 'header', required: true, schema: { type: 'string', format: 'uuid', pattern: '^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$' } }],
       requestBody: { required: true, content: media(jsonSchema(bookingInput)) },
       responses: { ...errors,
@@ -103,7 +104,9 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
   const cors = { options: { summary: 'Public CORS preflight', responses: { 204: { description: 'No body.' } } } };
   const manageNote = 'Requires the calendar and the owner switch bookingChanges. Same rules and emails as the booking’s web page; a booking type’s change cutoff closes guest changes that many hours before the start.';
   paths['/api/v1/bookings/manage'] = { get: priv('The booker’s own booking: status, time, place, what they may still change', ref('ManagedBooking'), { header: bookingToken, description: manageNote }), ...cors };
-  paths['/api/v1/bookings/manage/cancel'] = { post: priv('Cancel the booking (repeating is harmless)', ref('ManagedBooking'), { header: bookingToken, write: true, description: manageNote }), ...cors };
+  paths['/api/v1/bookings/manage/cancel'] = { post: priv('Cancel the booking (repeating is harmless); for an RSVP on the waitlist, leave it or release a held spot', ref('ManagedBooking'), { header: bookingToken, write: true, description: manageNote }), ...cors };
+  paths['/api/v1/bookings/manage/confirm'] = { post: priv('Take a spot the waitlist offered (status offered, can.confirm): confirmed, or pending when the event approves RSVPs; repeating is harmless', ref('ManagedBooking'), { header: bookingToken, write: true,
+    description: `${manageNote} Past its holdUntil the spot was released (410) and goes to the next person in line; a booking with no held spot answers 409.` }), ...cors };
   paths['/api/v1/bookings/manage/availability'] = { get: priv('Open times for moving the booking (its own time counts as free)', ref('Availability'), { header: bookingToken, query: manageAvailabilityQuery, description: manageNote }), ...cors };
   paths['/api/v1/bookings/manage/reschedule'] = { post: priv('Move the booking to a new start (room bookings, not RSVPs)', ref('ManagedBooking'), { header: bookingToken, body: rescheduleInput, write: true, description: manageNote }), ...cors };
   paths['/api/v1/bookings/manage/ics'] = { get: { summary: 'Calendar file for the booking (text/calendar, no v1 envelope)', parameters: [bookingToken],

package/src/lib/mobile/rsvp.ts

@@ -4,7 +4,7 @@ import type { CalEvent, Settings } from '../schema';
 import { ApiError } from '../api';
 import { answerFields } from '../forms/schema';
 import { eventIsPublic, expandEvents, rsvpDeadline, type Occurrence } from '../calendar/events';
-import { seatsTaken } from '../booking/service';
+import { seatsTaken, waitlistLine, waitlistOn } from '../booking/service';
 import { localizeDoc } from '../translations';
 import { siteLang } from '../dates';
 import { rsvpStrings } from '../calendar/rsvp-words';
@@ -14,9 +14,11 @@ import { formJson } from './forms';
 import { localeQuery, mobileLocale } from './locale';
 
 // RSVP status of one date of an event, for apps: whether it takes RSVPs now,
-// live seats and the questions with their version. The same rules as the
-// event's web page: open until the event's deadline or the date ends, no
-// waitlist. Never cached; seats change with every RSVP. POST /bookings saves one.
+// live seats, its waitlist and the questions with their version. The same
+// rules as the event's web page: open until the event's deadline or the date
+// ends; a full date with a waitlist takes places in line (POST /bookings with
+// waitlist: true). Never cached; seats change with every RSVP. POST /bookings
+// saves one.
 
 /** a public event (slug or id) and its occurrence starting exactly at `start` */
 export async function rsvpOccurrence(repo: ContentRepository, ref: string, start: string): Promise<Occurrence> {
@@ -52,8 +54,9 @@ export async function getRsvpStatus(repo: ContentRepository, url: URL, slug: str
   const o = await rsvpOccurrence(repo, slug, q.start);
   const settings = await repo.getSettings();
   const { rsvp } = o.event;
-  // pending and confirmed RSVPs hold seats, as in the capacity check
+  // pending, confirmed and held (waitlist) RSVPs take seats, as in the capacity check
   const going = rsvp.enabled ? await seatsTaken(repo, o.event.id, o.start) : 0;
+  const line = waitlistOn(o.event) ? await waitlistLine(repo, o.event.id, o.start) : [];
   const left = rsvp.capacity ? Math.max(0, rsvp.capacity - going) : null;
   const closed = rsvpClosed(o, settings);
   const deadline = rsvp.enabled ? rsvpDeadline(o, settings) : null;
@@ -74,6 +77,8 @@ export async function getRsvpStatus(repo: ContentRepository, url: URL, slug: str
     closesAt: deadline === null ? null : new Date(deadline).toISOString(),
     // seats one RSVP may take right now
     maxSeats: Math.min(rsvp.maxSeats || 1, left ?? Infinity), autoConfirm: rsvp.autoConfirm,
+    // a full date takes places in line: how many people wait, for how many seats, and the most one may ask for
+    waitlist: { enabled: waitlistOn(o.event), waiting: line.length, seats: line.reduce((n, b) => n + b.seats, 0), maxSeats: rsvp.maxSeats || 1 },
     form: form ? { ...await formJson(form), submitLabel } : null,
   };
 }

package/src/lib/mobile/schemas.ts

@@ -30,7 +30,7 @@ export const Page = ContentSummary.extend({
 export const Event = CalEvent.pick({
   id: true, slug: true, title: true, excerpt: true, status: true, cancelled: true, featured: true, start: true, end: true,
   allDay: true, timezone: true, rrule: true, exdates: true, cancelledDates: true, location: true, cta: true, tags: true, fields: true,
-}).extend({ rsvp: CalEvent.shape.rsvp.optional(), url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
+}).extend({ rsvp: CalEvent.shape.rsvp.removeDefault().omit({ notifyStaff: true }).default({}).optional(), url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
   calendars: z.array(z.object({ id: str, slug: str, name: str, color: str })),
   // push topics told about date, time or place changes (Admin → Mobile app → When an event changes); [] = none
   notify: z.object({ changes: strings }),
@@ -40,6 +40,7 @@ export const Events = z.object({ locale, timezone: str, from: date, to: date, pa
 });
 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 }).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 }).nullable(), event: Event })),
@@ -76,13 +77,20 @@ export const RsvpStatus = z.object({
   going: z.number().int(), left: z.number().int().nullable(), capacity: z.number().int(), maxSeats: z.number().int(), autoConfirm: bool,
   // the event's RSVP deadline for this date (null: open until it ends)
   closesAt: date.nullable(),
+  // enabled: a full date (reason full) takes places in line; waiting: people in line, seats: theirs; maxSeats: the most one may ask for
+  waitlist: z.object({ enabled: bool, waiting: z.number().int(), seats: z.number().int(), maxSeats: z.number().int() }),
   form: Form.omit({ id: true }).nullable(),
 });
-const GuestChanges = z.object({ cancel: bool, reschedule: bool, cutoffHours: z.number().int(), closed: bool });
+// confirm: a spot offered from the waitlist is still held for them
+const GuestChanges = z.object({ cancel: bool, reschedule: bool, confirm: bool, cutoffHours: z.number().int(), closed: bool });
+// waitlisted: in line for a full date; offered: a freed spot held until holdUntil; expired: not confirmed in time
+const BookingStatus = z.enum(['pending', 'confirmed', 'declined', 'cancelled', 'waitlisted', 'offered', 'expired']);
 export const ManagedBooking = z.object({
   booking: z.object({
-    id: str, reference: str, kind: z.enum(['booking', 'rsvp']), status: z.enum(['pending', 'confirmed', 'declined', 'cancelled']),
+    id: str, reference: str, kind: z.enum(['booking', 'rsvp']), status: BookingStatus,
     start: date, end: date, allDay: bool, timezone: str, seats: z.number().int(), name: str, email: str, phone: str, answers: z.record(str), createdAt: date,
+    // waitlisted: the place in line (1 = next); offered: until when the spot is held
+    position: z.number().int().nullable(), holdUntil: date.nullable(),
   }),
   title: str, location: str,
   resource: z.object({ slug: str, name: str }).nullable(),
@@ -95,7 +103,7 @@ export const ManagedBooking = z.object({
 export const GuestCodeSent = z.object({ sent: z.literal(true), expiresInMinutes: z.number().int() });
 export const GuestToken = z.object({ accessToken: str, tokenType: z.literal('Bearer'), email: str, idleDays: z.number().int() });
 export const GuestBookings = z.object({ email: str, pagination: Pagination, items: z.array(z.object({
-  id: str, reference: str, kind: z.enum(['booking', 'rsvp']), status: z.enum(['pending', 'confirmed', 'declined', 'cancelled']),
+  id: str, reference: str, kind: z.enum(['booking', 'rsvp']), status: BookingStatus,
   start: date, end: date, seats: z.number().int(), title: str, manageToken: str, manageUrl: str, can: GuestChanges,
 })) });
 export const GuestSignedOut = z.object({ signedOut: z.literal(true) });

package/src/lib/repo/migrations.ts

@@ -690,6 +690,11 @@ export const MIGRATIONS: Migration[] = [
   { version: 60, statements: [
     `ALTER TABLE bookings ADD COLUMN locale TEXT NOT NULL DEFAULT ''`,
   ] },
+  // RSVP waitlists: an offered spot is held until hold_until (ms); null for
+  // everything else, so older rows need no backfill
+  { version: 61, statements: [
+    `ALTER TABLE bookings ADD COLUMN hold_until INTEGER`,
+  ] },
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.

package/src/lib/repo/sql.ts

@@ -11,7 +11,7 @@ import { PermissionStore } from '../permissions/store';
 import { BackupStore } from '../backup/store';
 import { LiveConfig } from '../live/types';
 import { ApiError } from '../api';
-import { EmailStore, bookingJobs } from '../email/store';
+import { EmailStore, bookingJobs, rsvpStaffJobs } from '../email/store';
 import type { ContentRepository, DesignVersion, EventUpdate, ImportRecord, ImportRecordKind, ImportRun, SearchResults, Stats } from './types';
 import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, Place, EventLocation, EventRequest, isInternalTag, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
 import { designSnapshot, draftNavItems, pickDesignDraft, pickEventDraft, pickPageDraft, pickPostDraft } from '../drafts';
@@ -212,9 +212,14 @@ function rowToBooking(r: Row): Booking {
     formResponse: r.form_response ? json(r.form_response, undefined) : undefined,
     answers: json(r.answers, {}), notes: r.notes ?? '', manageToken: r.manage_token ?? '', source: r.source ?? 'web', locale: r.locale ?? '',
     notificationVersion: Number(r.notification_version ?? 0), reminderSentAt: r.reminder_sent_at === null || r.reminder_sent_at === undefined ? null : Number(r.reminder_sent_at),
+    holdUntil: r.hold_until === null || r.hold_until === undefined ? null : Number(r.hold_until),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
 }
+// RSVP statuses that take seats (a held offer too), and those that are the
+// address's RSVP for a date (a place in line too)
+const SEATED = "('pending','confirmed','offered')";
+const RSVP_ACTIVE = "('pending','confirmed','offered','waitlisted')";
 function rowToApiKey(r: Row): ApiKey {
   return ApiKey.parse({
     id: r.id, name: r.name, prefix: r.prefix, scopes: json(r.scopes, []),
@@ -446,7 +451,7 @@ export class SqlRepository implements ContentRepository {
     await this.ready;
     // One SELECT snapshots bookings and their retry ledger together. No UI
     // list limit; include tombstones for deleted bookings as well.
-    const columns = ['id','kind','resource_id','link_id','event_id','status','start_at','end_at','hold_start','hold_end','timezone','name','email','phone','seats','answers','form_response','notes','manage_token','source','locale','reminder_sent_at','notification_version','created_at','updated_at'];
+    const columns = ['id','kind','resource_id','link_id','event_id','status','start_at','end_at','hold_start','hold_end','timezone','name','email','phone','seats','answers','form_response','notes','manage_token','source','locale','reminder_sent_at','hold_until','notification_version','created_at','updated_at'];
     const rows = await this.driver.all(`SELECT 'booking' AS type, json_object(${columns.map(c => `'${c}',${c}`).join(',')}) AS data FROM bookings
       UNION ALL SELECT 'request', json_object('keyHash',key_hash,'requestHash',request_hash,'bookingId',booking_id,'createdAt',created_at) FROM mobile_booking_requests`);
     return {
@@ -917,6 +922,13 @@ export class SqlRepository implements ContentRepository {
           start_at=CASE WHEN ? THEN (SELECT start_at FROM events WHERE id=?) ELSE start_at END,
           end_at=CASE WHEN ? THEN (SELECT end_at FROM events WHERE id=?) ELSE end_at END
           WHERE event_id=? AND kind='rsvp' AND status IN ('pending','confirmed')`,args:[id,siteTimezone,cancelled?1:0,single?1:0,id,single?1:0,id,id]},
+        // places in line and held spots move with the date too; only its cancellation emails them
+        {sql:`UPDATE bookings SET notification_version=notification_version+?,
+          timezone=COALESCE(NULLIF((SELECT timezone FROM events WHERE id=?),''),?),
+          status=CASE WHEN ? THEN 'cancelled' ELSE status END,
+          start_at=CASE WHEN ? THEN (SELECT start_at FROM events WHERE id=?) ELSE start_at END,
+          end_at=CASE WHEN ? THEN (SELECT end_at FROM events WHERE id=?) ELSE end_at END
+          WHERE event_id=? AND kind='rsvp' AND status IN ('waitlisted','offered')`,args:[cancelled?1:0,id,siteTimezone,cancelled?1:0,single?1:0,id,single?1:0,id,id]},
         ...notifications]);
     } else await this.driver.batch([eventWrite]);
     await this.syncEventIndex(id);
@@ -948,7 +960,7 @@ export class SqlRepository implements ContentRepository {
     const mutation = crypto.randomUUID();
     const notifications = bookingJobs(id,'cancelled',undefined,false,mutation).map(s=>({...s,sql:s.sql.replace('b.id = ?',"b.event_id = ? AND b.kind='rsvp'")}));
     await this.driver.batch([
-      {sql:"UPDATE bookings SET status='cancelled',notification_version=notification_version+1,email_mutation=?,reminder_sent_at=NULL,updated_at=? WHERE event_id=? AND kind='rsvp' AND start_at=? AND status IN ('pending','confirmed')",args:[mutation,Date.now(),id,start]},
+      {sql:`UPDATE bookings SET status='cancelled',notification_version=notification_version+1,email_mutation=?,reminder_sent_at=NULL,updated_at=? WHERE event_id=? AND kind='rsvp' AND start_at=? AND status IN ${RSVP_ACTIVE}`,args:[mutation,Date.now(),id,start]},
       ...notifications,
     ]);
     return Number((await this.first("SELECT COUNT(*) AS n FROM bookings WHERE event_id=? AND kind='rsvp' AND email_mutation=?", [id, mutation]))?.n ?? 0);
@@ -972,7 +984,7 @@ export class SqlRepository implements ContentRepository {
     const mutation = crypto.randomUUID();
     const notifications = bookingJobs(id,'cancelled',undefined,false,mutation).map(s=>({...s,sql:s.sql.replace('b.id = ?',"b.event_id = ? AND b.kind='rsvp'")}));
     await this.driver.batch([
-      {sql:"UPDATE bookings SET status='cancelled',notification_version=notification_version+1,email_mutation=?,reminder_sent_at=NULL WHERE event_id=? AND kind='rsvp' AND status IN ('pending','confirmed')",args:[mutation,id]},
+      {sql:`UPDATE bookings SET status='cancelled',notification_version=notification_version+1,email_mutation=?,reminder_sent_at=NULL WHERE event_id=? AND kind='rsvp' AND status IN ${RSVP_ACTIVE}`,args:[mutation,id]},
       ...notifications,
       { sql: 'DELETE FROM events WHERE id = ?', args: [id] },
       { sql: "DELETE FROM search_index WHERE kind = 'event' AND ref_id = ?", args: [id] },
@@ -1078,9 +1090,9 @@ export class SqlRepository implements ContentRepository {
   private bookingInsert(b: Booking): SqlStatement {
     return {
       sql: `INSERT INTO bookings (id, kind, resource_id, link_id, event_id, status, start_at, end_at, hold_start, hold_end, timezone, name, email, phone,
-        seats, answers, notes, manage_token, source, reminder_sent_at, created_at, updated_at, notification_version, form_response, locale) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        seats, answers, notes, manage_token, source, reminder_sent_at, created_at, updated_at, notification_version, form_response, locale, hold_until) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [b.id, b.kind, b.resourceId, b.linkId, b.eventId, b.status, b.start, b.end, b.holdStart, b.holdEnd, b.timezone, b.name, b.email, b.phone,
-        b.seats, JSON.stringify(b.answers), b.notes, b.manageToken, b.source, b.reminderSentAt, b.createdAt, b.updatedAt, b.notificationVersion, b.formResponse ? JSON.stringify(b.formResponse) : null, b.locale],
+        b.seats, JSON.stringify(b.answers), b.notes, b.manageToken, b.source, b.reminderSentAt, b.createdAt, b.updatedAt, b.notificationVersion, b.formResponse ? JSON.stringify(b.formResponse) : null, b.locale, b.holdUntil],
     };
   }
   async listResources() {
@@ -1221,12 +1233,13 @@ export class SqlRepository implements ContentRepository {
     const holds = b.status === 'pending' || b.status === 'confirmed';
     let write = { sql: `INSERT INTO bookings ${cols} SELECT ${ins.args!.map(() => '?').join(', ')} WHERE 1=1`, args: ins.args };
     if (b.kind === 'rsvp') {
-      const cap = guard.capacity ?? 0;
+      // a place in line takes no seats
+      const cap = holds ? guard.capacity ?? 0 : 0;
       write = { sql: `INSERT INTO bookings ${cols} SELECT ${ins.args!.map(() => '?').join(', ')}
-        WHERE (? = 0 OR (SELECT COALESCE(SUM(seats),0) FROM bookings WHERE kind='rsvp' AND event_id=? AND start_at=? AND status IN ('pending','confirmed')) + ? <= ?)`,
+        WHERE (? = 0 OR (SELECT COALESCE(SUM(seats),0) FROM bookings WHERE kind='rsvp' AND event_id=? AND start_at=? AND status IN ${SEATED}) + ? <= ?)`,
         args: [...ins.args!,cap,b.eventId,b.start,b.seats,cap] };
       // same statement, so two at once from one address can't both get in
-      if (guard.oncePerEmail && holds && b.email) write = { sql: write.sql + ` AND NOT EXISTS (SELECT 1 FROM bookings WHERE kind='rsvp' AND event_id=? AND start_at=? AND email=? AND status IN ('pending','confirmed'))`,
+      if (guard.oncePerEmail && (holds || b.status === 'waitlisted') && b.email) write = { sql: write.sql + ` AND NOT EXISTS (SELECT 1 FROM bookings WHERE kind='rsvp' AND event_id=? AND start_at=? AND email=? AND status IN ${RSVP_ACTIVE})`,
         args: [...write.args!,b.eventId,b.start,b.email] };
     } else if (holds && b.resourceId) {
       write = { sql: `INSERT INTO bookings ${cols} SELECT ${ins.args!.map(() => '?').join(', ')} WHERE NOT EXISTS (
@@ -1241,7 +1254,7 @@ export class SqlRepository implements ContentRepository {
         SELECT ?,?,id,? FROM bookings WHERE id=?`, args: [keyHash, requestHash, now, b.id] });
     }
     // Booking, retry ledger and email outbox commit together on D1 and libSQL.
-    await this.driver.batch([write, ...ledger, ...bookingJobs(b.id, b.status === 'confirmed' ? 'confirmed' : 'received', 0, true)]);
+    await this.driver.batch([write, ...ledger, ...bookingJobs(b.id, b.status === 'confirmed' ? 'confirmed' : b.status === 'waitlisted' ? 'waitlisted' : 'received', 0, true), ...rsvpStaffJobs(b.id, 'staff-rsvp', guard.staff, 0)]);
     return this.getBooking(b.id);
   }
   async moveBooking(id: string, t: { start: number; end: number; holdStart: number; holdEnd: number }) {
@@ -1276,9 +1289,37 @@ export class SqlRepository implements ContentRepository {
     if (data.answers !== undefined) { sets.push('answers = ?'); args.push(JSON.stringify(data.answers)); }
     if (data.reminderSentAt !== undefined) { sets.push('reminder_sent_at = ?'); args.push(data.reminderSentAt); }
     args.push(id);
-    const kind = data.status === 'confirmed' ? 'confirmed' : data.status === 'declined' ? 'declined' : data.status === 'pending' ? 'received' : 'cancelled';
-    await this.driver.batch([{sql:`UPDATE bookings SET ${sets.join(', ')} WHERE id = ? AND notification_version = ?`,args:[...args,current.notificationVersion]},
-      ...(changed ? bookingJobs(id,kind,current.notificationVersion+1,false,mutation,data.notificationMessage) : [])]);
+    if (data.from && data.from !== current.status) return;
+    // the guest's email: leaving the line (or a held spot) isn't a cancelled RSVP; a spot that ran out sends none
+    const waiting = current.status === 'waitlisted' || current.status === 'offered';
+    const kind = data.status === 'confirmed' ? 'confirmed' : data.status === 'declined' ? 'declined' : data.status === 'pending' ? 'received'
+      : data.status === 'offered' ? 'offered' : data.status === 'expired' ? '' : waiting ? 'left' : 'cancelled';
+    // staff: a confirmed offer is a new RSVP to them
+    const staff = data.status === 'cancelled' ? 'staff-rsvp-cancelled' as const : data.status === 'confirmed' || data.status === 'pending' ? 'staff-rsvp' as const : null;
+    await this.driver.batch([{sql:`UPDATE bookings SET ${sets.join(', ')} WHERE id = ? AND notification_version = ?${data.from ? ' AND status = ?' : ''}`,args:[...args,current.notificationVersion,...(data.from ? [data.from] : [])]},
+      ...(changed && kind ? bookingJobs(id,kind,current.notificationVersion+1,false,mutation,data.notificationMessage) : []),
+      ...(changed && staff ? rsvpStaffJobs(id,staff,data.staff,current.notificationVersion+1,mutation) : [])]);
+  }
+  // waitlisted → offered only while its seats still fit: the seat count is in
+  // the same statement, like createBooking's, so two offers (or an offer and a
+  // new RSVP) can't both take the last seats. The email is queued with it.
+  async offerBooking(id: string, holdUntil: number, capacity: number) {
+    await this.ready;
+    const mutation = crypto.randomUUID();
+    await this.driver.batch([
+      { sql: `UPDATE bookings SET status='offered',hold_until=?,notification_version=notification_version+1,email_mutation=?,reminder_sent_at=NULL,updated_at=?
+        WHERE id=? AND kind='rsvp' AND status='waitlisted' AND (? = 0 OR (SELECT COALESCE(SUM(t.seats),0) FROM bookings t WHERE t.kind='rsvp' AND t.event_id=bookings.event_id AND t.start_at=bookings.start_at AND t.status IN ${SEATED}) + seats <= ?)`,
+        args: [holdUntil, mutation, Date.now(), id, capacity, capacity] },
+      ...bookingJobs(id, 'offered', undefined, false, mutation),
+    ]);
+    return !!await this.first('SELECT id FROM bookings WHERE id=? AND email_mutation=?', [id, mutation]);
+  }
+  async expireBooking(id: string, now: number) {
+    await this.ready;
+    const mutation = crypto.randomUUID();
+    await this.driver.run(`UPDATE bookings SET status='expired',notification_version=notification_version+1,email_mutation=?,updated_at=?
+      WHERE id=? AND kind='rsvp' AND status='offered' AND hold_until <= ?`, [mutation, Date.now(), id, now]);
+    return !!await this.first('SELECT id FROM bookings WHERE id=? AND email_mutation=?', [id, mutation]);
   }
   async deleteBooking(id: string) {
     await this.ready;

package/src/lib/repo/types.ts

@@ -7,6 +7,7 @@ import type { SavedForm, FormSubmission } from '../forms/schema';
 import type { LiveStore } from '../live/store';
 import type { BookingRequest } from '../backup/content';
 import type { EmailStore } from '../email/store';
+import type { RsvpStaffNotice } from '../email/types';
 import type { PushStore } from '../push/store';
 import type { AnnouncementStore } from '../announcements/store';
 import type { Announcement } from '../announcements/types';
@@ -189,21 +190,30 @@ export interface ContentRepository {
   // write that can fail on a race: it inserts atomically only if the held
   // range is still free (resource bookings) or seats remain (RSVPs; with
   // oncePerEmail, and the address has no active RSVP for that date), and
-  // returns null when it lost.
+  // returns null when it lost. staff: who hears about a new RSVP (queued with
+  // it, so a lost race or a replay emails no one).
   /** from/to: overlaps the window; endedBy: ended at or before; default order start ascending, at most 5000 rows */
   listBookings(filter?: { resourceId?: string; eventId?: string; email?: string; from?: number; to?: number; endedBy?: number; statuses?: BookingStatus[]; kinds?: Booking['kind'][]; newestFirst?: boolean; limit?: number; offset?: number }): Promise<Booking[]>;
   getBooking(id: string): Promise<Booking | null>;
   getBookingByToken(token: string): Promise<Booking | null>;
   // bookings + RSVPs (never staff blocks) this address made since `since`
   countBookingsByEmail(email: string, since: number): Promise<number>;
-  // locale: the booker's language; '' (the main language) when left out
+  // locale: the booker's language; '' (the main language) when left out.
+  // A waitlisted RSVP takes no seats, so only oncePerEmail guards it.
   createBooking(
-    data: Omit<Booking, 'id' | 'createdAt' | 'updatedAt' | 'reminderSentAt' | 'notificationVersion' | 'locale'> & { locale?: string },
-    guard?: { capacity?: number; oncePerEmail?: boolean; idempotency?: { keyHash: string; requestHash: string } }
+    data: Omit<Booking, 'id' | 'createdAt' | 'updatedAt' | 'reminderSentAt' | 'notificationVersion' | 'locale' | 'holdUntil'> & { locale?: string },
+    guard?: { capacity?: number; oncePerEmail?: boolean; idempotency?: { keyHash: string; requestHash: string }; staff?: RsvpStaffNotice }
   ): Promise<Booking | null>;
   // moves a booking only if the new held range is free (reschedule)
   moveBooking(id: string, times: { start: number; end: number; holdStart: number; holdEnd: number }): Promise<boolean>;
-  updateBooking(id: string, data: Partial<Pick<Booking, 'status' | 'notes' | 'name' | 'email' | 'phone' | 'answers' | 'reminderSentAt'>> & { notificationMessage?: string }): Promise<void>;
+  // staff: who hears that the person cancelled their RSVP, or confirmed a spot
+  // offered from the waitlist; from: change it only if it still has that status
+  updateBooking(id: string, data: Partial<Pick<Booking, 'status' | 'notes' | 'name' | 'email' | 'phone' | 'answers' | 'reminderSentAt'>> & { from?: BookingStatus; notificationMessage?: string; staff?: RsvpStaffNotice }): Promise<void>;
+  // a waitlisted RSVP becomes offered (held until holdUntil, its email queued
+  // with it) only if its seats still fit `capacity` (0 = no limit); false when they don't
+  offerBooking(id: string, holdUntil: number, capacity: number): Promise<boolean>;
+  // an offered RSVP whose hold ended by `now` becomes expired (no email); false when it wasn't
+  expireBooking(id: string, now: number): Promise<boolean>;
   deleteBooking(id: string): Promise<void>;
   // confirmed bookings starting in [from, to) that haven't had a reminder
   listDueReminders(from: number, to: number): Promise<Booking[]>;

package/src/lib/scheduler.ts

@@ -2,7 +2,7 @@ import { syncDueLive } from './live/service';
 import type { ContentRepository } from './repo/types';
 import { processDueDeliveries } from './webhooks';
 import { dispatchEmail } from './email/service';
-import { decideOverdue, sendDueReminders } from './booking/service';
+import { decideOverdue, sendDueReminders, sweepWaitlist } from './booking/service';
 import { runPushJobs } from './push/service';
 import { runAnnouncementJobs } from './announcements/service';
 import { GUEST_IDLE_MS } from './mobile/guest-store';
@@ -21,6 +21,8 @@ export async function runScheduledTasks(repo: ContentRepository, locals?: unknow
     reminders: () => sendDueReminders(repo, { origin: settings.siteUrl, locals, now: startedAt }),
     // pending bookings past their approval deadline (Calendar settings → Bookings)
     approvals: () => decideOverdue(repo, { origin: settings.siteUrl, locals, now: startedAt }),
+    // held waitlist spots that ran out, and freed seats offered to those in line (before email, so offers go out in this run)
+    waitlist: () => sweepWaitlist(repo, { origin: settings.siteUrl, locals, now: startedAt }),
     email: () => dispatchEmail(repo, locals, 10),
     live: () => syncDueLive(repo, locals),
     // scheduled announcements go up (with their push) and ended ones come down

package/src/lib/schema.ts

@@ -417,7 +417,11 @@ export const CalEvent = z.object({
   // RSVP: seats per occurrence (0 = unlimited) and whether RSVPs confirm at
   // once; RSVPs are stored as bookings of kind 'rsvp'. They close at closesAt
   // (wall time in the event's zone, like start; every date), else closeBefore
-  // minutes before each date's start, else when the date ends.
+  // minutes before each date's start, else when the date ends. notifyStaff:
+  // the hosts (else the church's contact email) hear about each new RSVP and
+  // each one the person cancels (lib/booking/service.ts rsvpStaff). waitlist:
+  // a full date takes places in line, and freed seats are offered in turn
+  // (lib/booking/service.ts offerWaitlist); only with a capacity.
   rsvp: z.object({
     enabled: z.boolean().default(false),
     capacity: z.number().int().default(0),
@@ -425,6 +429,8 @@ export const CalEvent = z.object({
     maxSeats: z.number().int().default(4),
     closesAt: z.string().nullable().default(null),
     closeBefore: z.number().int().default(0),
+    notifyStaff: z.boolean().default(true),
+    waitlist: z.boolean().default(false),
     form: FormDefinition.optional(),
   }).default({}),
   // rooms/people this event uses: they can't be booked while it happens (or
@@ -650,7 +656,10 @@ export const BookingLink = z.object({
 });
 export type BookingLink = z.infer<typeof BookingLink>;
 
-export const BookingStatus = z.enum(['pending', 'confirmed', 'declined', 'cancelled']);
+// RSVPs only: waitlisted = in line for a full date (takes no seats); offered =
+// a freed spot held for them until holdUntil (takes its seats); expired = they
+// didn't confirm it in time
+export const BookingStatus = z.enum(['pending', 'confirmed', 'declined', 'cancelled', 'waitlisted', 'offered', 'expired']);
 export type BookingStatus = z.infer<typeof BookingStatus>;
 
 export const Booking = z.object({
@@ -682,6 +691,8 @@ export const Booking = z.object({
   // emails and links speak it. '' = the site's main language, as on page rows
   locale: z.string().default(''),
   reminderSentAt: z.number().nullable().default(null),
+  // an offered spot is theirs until then (ms)
+  holdUntil: z.number().nullable().default(null),
   notificationVersion: z.number().default(0),
   createdAt: z.number(),
   updatedAt: z.number(),