@acms-subir/core 0.3.35 → 0.3.37

package/src/lib/mobile/forms.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { ContentRepository } from '../repo/types';
-import type { SavedForm } from '../forms/schema';
+import type { FormDefinition, SavedForm } from '../forms/schema';
 import { collectResponse, formVersion } from '../forms/service';
 import { ApiError, readJson } from '../api';
 import { sha256Hex } from '../api-keys';
@@ -24,14 +24,11 @@ async function publishedForm(repo: ContentRepository, id: string): Promise<Saved
   return form;
 }
 
-export async function getForm(repo: ContentRepository, url: URL, id: string) {
-  z.object({}).strict().parse(queryParams(url));
-  await requireAccess(repo, 'forms');
-  const form = await publishedForm(repo, id);
-  const d = form.definition;
+/** A form's questions for apps; `version` is the one collectResponse accepts (also for event RSVPs). */
+export async function formJson(d: FormDefinition) {
   return {
-    id: form.id, version: await formVersion(d),
-    title: d.title || form.name, intro: d.intro, submitLabel: d.submitLabel || 'Submit', confirmation: d.confirmation,
+    version: await formVersion(d),
+    title: d.title, intro: d.intro, submitLabel: d.submitLabel, confirmation: d.confirmation,
     fields: d.fields.map((f) => ({
       id: f.id, type: f.type, label: f.label, required: f.required, help: f.help, options: f.options,
       placeholder: f.placeholder ?? '', width: f.width ?? 'full', allowOther: f.allowOther ?? false,
@@ -39,9 +36,22 @@ export async function getForm(repo: ContentRepository, url: URL, id: string) {
   };
 }
 
+export async function getForm(repo: ContentRepository, url: URL, id: string) {
+  z.object({}).strict().parse(queryParams(url));
+  await requireAccess(repo, 'forms');
+  const form = await publishedForm(repo, id);
+  const d = form.definition;
+  return { id: form.id, ...await formJson(d), title: d.title || form.name, submitLabel: d.submitLabel || 'Submit' };
+}
+
+// field id → answer; checkbox groups send a list. "Other" answers send the typed text.
+export const appAnswers = z.record(z.union([z.string().max(2000), z.array(z.string().max(2000)).max(51)]));
+/** lists become the stored newline-joined form */
+export const joinAnswers = (answers: z.infer<typeof appAnswers>): Record<string, string> =>
+  Object.fromEntries(Object.entries(answers).map(([k, v]) => [k, Array.isArray(v) ? v.map((x) => x.trim()).filter(Boolean).join('\n') : v]));
+
 export const formResponseInput = z.object({
-  // field id → answer; checkbox groups send a list. "Other" answers send the typed text.
-  answers: z.record(z.union([z.string().max(2000), z.array(z.string().max(2000)).max(51)])).refine((a) => Object.keys(a).length <= 30, 'Too many answers.'),
+  answers: appAnswers.refine((a) => Object.keys(a).length <= 30, 'Too many answers.'),
   // the version from GET /forms/{id}; a changed form answers 409 instead of saving
   version: z.string().max(100).optional(),
   // spam trap: apps leave it out or empty
@@ -57,7 +67,7 @@ export async function submitFormResponse(c: PublicContext) {
   if (body.website) throw new ApiError(400, 'Could not submit this form.');
   const form = await publishedForm(c.repo, id);
   if (!await c.repo.email.rateLimit(`forms:app:${await sha256Hex(`${form.id}:${c.address}`)}`, 10, 60_000)) throw new ApiError(429, 'Too many responses. Please try again in a minute.');
-  const answers = Object.fromEntries(Object.entries(body.answers).map(([k, v]) => [k, Array.isArray(v) ? v.map((x) => x.trim()).filter(Boolean).join('\n') : v]));
+  const answers = joinAnswers(body.answers);
   // the key is the stored response id: a retry of a saved response answers
   // as before and costs nothing (also after the form changed); the same key
   // with different answers is a 409

package/src/lib/mobile/manage.ts

@@ -63,6 +63,8 @@ function view(m: Managed, booking = m.booking) {
     // the web page for this booking (the same private link the emails carry)
     manageUrl: origin + manageUrl(booking.manageToken),
     can,
+    // the RSVP form as it was when they sent it (like the web page), else the booking type's message
+    confirmation: booking.formResponse?.definition.confirmation || link?.confirmMessage || null,
   };
 }
 const flow = (m: Managed, c: PublicContext) => ({ origin: m.origin, locals: c.locals, waitUntil: waitUntilFrom(c.locals) });

package/src/lib/mobile/openapi.ts

@@ -4,6 +4,7 @@ import type { ContentRepository } from '../repo/types';
 import { contentQuery, contentDetailQuery } from './content';
 import { eventsQuery, availabilityQuery } from './calendar';
 import { bookingInput } from './bookings';
+import { rsvpQuery } from './rsvp';
 import { pagesQuery } from './pages';
 import { searchQuery } from './search';
 import { manageAvailabilityQuery, rescheduleInput } from './manage';
@@ -33,7 +34,10 @@ const errors = Object.fromEntries([400, 404, 405, 429, 500].map(status => [statu
   ...(status === 429 ? { headers: { 'Retry-After': { description: 'Seconds to wait: 60 for per-minute limits, longer for hourly, daily and lockout limits.', schema: { type: 'string' } } } } : {}),
 }]));
 function parameters(query: z.AnyZodObject) {
-  return Object.entries(query.shape).map(([name, schema]) => ({ name, in: 'query', required: !(schema as z.ZodTypeAny).isOptional(), schema: jsonSchema(schema as z.ZodTypeAny) }));
+  return Object.entries(query.shape).map(([name, schema]) => {
+    const s = schema as z.ZodTypeAny;
+    return { name, in: 'query', required: !s.isOptional(), ...(s.description ? { description: s.description } : {}), schema: jsonSchema(s) };
+  });
 }
 export async function getOpenApi(_repo: ContentRepository, url: URL) {
   empty.parse(queryParams(url));
@@ -48,6 +52,7 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
     ['/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')],
     ['/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')],
     ['/availability', 'Current availability; requires bookings', availabilityQuery, ref('Availability'), false],
     ['/push/topics', 'Topics an app can offer as notification toggles, named in the requested language; requires push', localeOnlyQuery, ref('PushTopics')],
@@ -73,8 +78,8 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
   }
   paths['/api/v1/bookings'] = {
     post: {
-      summary: 'Create a guest booking or replay an existing request; requires 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.',
+      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.',
       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,

package/src/lib/mobile/rsvp.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import type { CalEvent } from '../schema';
+import { ApiError } from '../api';
+import { answerFields } from '../forms/schema';
+import { eventIsPublic, expandEvents, type Occurrence } from '../calendar/events';
+import { seatsTaken } from '../booking/service';
+import { localizeDoc } from '../translations';
+import { siteLang } from '../dates';
+import { rsvpStrings } from '../calendar/rsvp-words';
+import { queryParams } from './http';
+import { requireCalendar } from './calendar';
+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 date ends, no deadline or waitlist.
+// 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> {
+  const event = await repo.getEventBySlug(ref) ?? await repo.getEvent(ref);
+  const calendars = new Map((await repo.listCalendars()).map(c => [c.id, c]));
+  if (!event || !eventIsPublic(event, calendars)) throw new ApiError(404, 'Event not found.');
+  const settings = await repo.getSettings();
+  const at = Date.parse(start);
+  const occurrence = expandEvents([event], settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: at, windowEndMs: at + 1 }).find(o => o.start === at);
+  if (!occurrence) throw new ApiError(400, 'Start must match an event occurrence exactly.');
+  return occurrence;
+}
+/** the RSVP form when it asks something; apps must then send its version */
+export const rsvpQuestions = (e: CalEvent) => e.rsvp.form && answerFields(e.rsvp.form).length ? e.rsvp.form : null;
+/** why this date takes no RSVPs (seats aside), or null */
+export function rsvpClosed(o: Occurrence, now = Date.now()) {
+  if (!o.event.rsvp.enabled) return 'disabled' as const;
+  if (o.cancelled) return 'cancelled' as const;
+  if (o.end <= now) return 'ended' as const;
+  return null;
+}
+
+export const rsvpQuery = z.object({
+  start: z.string().datetime({ offset: true }).describe('The occurrence’s start exactly as GET /events returns it, a UTC ISO date-time such as 2026-10-05T14:00:00.000Z. A start that isn’t one of the event’s dates answers 400.'),
+  locale: localeQuery,
+}).strict();
+export async function getRsvpStatus(repo: ContentRepository, url: URL, slug: string) {
+  requireCalendar();
+  const q = rsvpQuery.parse(queryParams(url));
+  const locale = mobileLocale(q.locale);
+  const o = await rsvpOccurrence(repo, slug, q.start);
+  const { rsvp } = o.event;
+  // pending and confirmed RSVPs hold seats, as in the capacity check
+  const going = rsvp.enabled ? await seatsTaken(repo, o.event.id, o.start) : 0;
+  const left = rsvp.capacity ? Math.max(0, rsvp.capacity - going) : null;
+  const closed = rsvpClosed(o);
+  const reason = closed ?? (left === 0 ? 'full' as const : null);
+  const form = rsvpQuestions(o.event);
+  const title = localizeDoc(o.event, locale ?? undefined).title;
+  // the built-in button speaks the app's language (the site's own without languages set up)
+  let submitLabel = form?.submitLabel ?? '';
+  if (form && !submitLabel) {
+    const words = rsvpStrings(locale ?? siteLang(await repo.getSettings()));
+    submitLabel = rsvp.autoConfirm ? words.confirmSeat : words.requestSeat;
+  }
+  return {
+    event: { id: o.event.id, slug: o.event.slug, title },
+    start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(),
+    open: !reason, reason, going, left, capacity: rsvp.capacity,
+    // seats one RSVP may take right now
+    maxSeats: Math.min(rsvp.maxSeats || 1, left ?? Infinity), autoConfirm: rsvp.autoConfirm,
+    form: form ? { ...await formJson(form), submitLabel } : null,
+  };
+}

package/src/lib/mobile/schemas.ts

@@ -8,7 +8,7 @@ const Palette = z.object({ bg: str, ink: str, muted: str, line: str, accent: str
 export const Site = z.object({
   name: str, description: str, logo: str, logoDark: str, icon: str, menu: z.array(z.object({ label: str, href: str })),
   languages: z.object({ default: locale, locales: z.array(z.object({ code: str, name: str })) }),
-  features: z.object({ blog: z.array(z.object({ key: str, name: str, url: str, redirectFrom: strings })), calendar: bool, bookings: bool, search: bool, bookingChanges: bool, guestSignIn: bool, forms: bool, links: bool, live: bool, announcements: bool }),
+  features: z.object({ blog: z.array(z.object({ key: str, name: str, url: str, redirectFrom: strings })), calendar: bool, bookings: bool, rsvp: bool, search: bool, bookingChanges: bool, guestSignIn: bool, forms: bool, links: bool, live: bool, announcements: bool }),
   legal: z.object({ privacy: str.nullable(), terms: str.nullable() }), apiVersion: z.literal(1),
 });
 export const Theme = z.object({
@@ -68,6 +68,12 @@ export const Form = z.object({
   })),
 });
 export const FormReceipt = z.object({ received: z.literal(true), confirmation: str });
+export const RsvpStatus = z.object({
+  event: z.object({ id: str, slug: str, title: str }), start: date, end: date,
+  open: bool, reason: z.enum(['disabled', 'ended', 'cancelled', 'full']).nullable(),
+  going: z.number().int(), left: z.number().int().nullable(), capacity: z.number().int(), maxSeats: z.number().int(), autoConfirm: bool,
+  form: Form.omit({ id: true }).nullable(),
+});
 const GuestChanges = z.object({ cancel: bool, reschedule: bool, cutoffHours: z.number().int(), closed: bool });
 export const ManagedBooking = z.object({
   booking: z.object({
@@ -79,6 +85,8 @@ export const ManagedBooking = z.object({
   link: z.object({ slug: str, name: str, mode: z.enum(['slots', 'range', 'day']), lengths: z.array(z.number()) }).nullable(),
   event: z.object({ slug: str, title: str, url: str }).nullable(),
   manageUrl: str, can: GuestChanges,
+  // what the web page says once it's confirmed: the RSVP form's or booking type's message
+  confirmation: str.nullable(),
 });
 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() });

package/src/lib/mobile/site.ts

@@ -37,7 +37,9 @@ export async function getSite(repo: ContentRepository, url: URL, _id = '', local
     features: {
       // redirectFrom: old addresses the website 301s to url, so apps can follow them too,
       // minus any another collection now lives at (the website serves that one first)
-      blog: Object.entries(CONTENT.collections).map(([key, c]) => ({ key, name: c.plural, url: safeUrl(c.base, origin), redirectFrom: legacyBases(key, c).filter(from => !bases.has(from)).map(from => safeUrl(from, origin)) })), calendar: CALENDAR.enabled, bookings: bookingsEnabled(), search: SEARCH.enabled,
+      blog: Object.entries(CONTENT.collections).map(([key, c]) => ({ key, name: c.plural, url: safeUrl(c.base, origin), redirectFrom: legacyBases(key, c).filter(from => !bases.has(from)).map(from => safeUrl(from, origin)) })), calendar: CALENDAR.enabled, bookings: bookingsEnabled(),
+      // RSVPs from apps (GET /events/{slug}/rsvp, POST /bookings) come with the calendar
+      rsvp: CALENDAR.enabled, search: SEARCH.enabled,
       // Admin → Mobile app → App access
       bookingChanges: CALENDAR.enabled && settings.mobileAccess.bookingChanges, guestSignIn: await guestSignInReady(repo, locals),
       forms: settings.mobileAccess.forms, links: settings.mobileAccess.links,

package/src/lib/schema.ts

@@ -672,7 +672,8 @@ export const Booking = z.object({
   formResponse: FormResponse.optional(),
   notes: z.string().default(''), // staff-only
   manageToken: z.string().default(''),
-  source: z.enum(['web', 'admin', 'api', 'agent']).default('web'),
+  // web: the website; app: the public app API (/api/v1/bookings)
+  source: z.enum(['web', 'app', 'admin', 'api', 'agent']).default('web'),
   reminderSentAt: z.number().nullable().default(null),
   notificationVersion: z.number().default(0),
   createdAt: z.number(),

package/src/lib/site-chrome.ts

@@ -8,6 +8,12 @@
 //   [data-scheme-toggle] flips light/dark (when site.schemeToggle is true)
 //   [data-menu-open]     opens the phone menu sheet (built from site.links)
 //   [data-live-header]   (hidden) becomes the "Live" link during a stream
+//
+// `words` are core's own labels in the page's language (skip link, menu and
+// dark-mode buttons, landmark and footer labels), so a custom header labels
+// its controls the same way the built-in one does.
+import type { SiteStrings } from './site-words';
+
 export interface ChromeLink {
   label: string;
   url: string;
@@ -32,4 +38,6 @@ export interface SiteChrome {
   liveHeader: boolean;
   headerStyle: string; // theme token `header`
   footerStyle: string; // theme token `footer`
+  lang: string; // the page's language, as on <html lang>
+  words: SiteStrings;
 }

package/src/pages/admin/calendar/bookings.astro

@@ -185,6 +185,8 @@ const emailNotice = !emailConfig.config.enabled || emailConfig.config.provider =
   : emailStatus.linkError;
 const TABS = [['upcoming', 'Upcoming'], ['unconfirmed', 'Needs approval'], ['past', 'Past'], ['cancelled', 'Cancelled']] as const;
 const statusLabel = (b: Booking) => (b.kind === 'block' ? 'Blocked' : b.status[0].toUpperCase() + b.status.slice(1));
+// where it was made: the website, an app (/api/v1/bookings), staff, an API key or the booking agent
+const SOURCES: Record<Booking['source'], string> = { web: 'Website', app: 'App', admin: 'Staff', api: 'API', agent: 'Agent' };
 const whenOf = (b: Booking) => (b.end - b.start >= 86_400_000 - 3_600_000 && ymd(b.start, tz) !== ymd(b.end - 1, tz)
   ? `${f.day.format(b.start)} – ${f.day.format(b.end - 1)}`
   : b.end - b.start >= 86_400_000 - 3_600_000 ? 'All day' : `${f.time.format(b.start)} – ${f.time.format(b.end)}`);
@@ -327,7 +329,7 @@ const activeLinks = links.filter((l) => l.active && resById.has(l.resourceId));
               <div><dt>{ev ? 'Event' : 'Where'}</dt><dd>{ev ? <a href={eventUrl(ev.slug)} target="_blank" rel="noopener">{ev.title}</a> : r?.name ?? '—'}{l ? ` · ${l.name}` : ''}</dd></div>
               {b.seats > 1 && <div><dt>Seats</dt><dd>{b.seats}</dd></div>}
               {Object.entries(b.answers).map(([k, v]) => <div><dt>{k}</dt><dd>{v}</dd></div>)}
-              <div><dt>Booked</dt><dd>{f.day.format(b.createdAt)} · {b.source}</dd></div>
+              <div><dt>Booked</dt><dd>{f.day.format(b.createdAt)} · {SOURCES[b.source] ?? b.source}</dd></div>
             </dl>
             <form method="post" class="bk-notes">
               <input type="hidden" name="op" value="notes" /><input type="hidden" name="id" value={b.id} />

package/src/pages/api/v1/events/[slug]/rsvp.ts

@@ -0,0 +1,8 @@
+import { getRsvpStatus } from '../../../../../lib/mobile/rsvp';
+import { readRoute } from '../../../../../lib/mobile/route';
+import { methodNotAllowed } from '../../../../../lib/mobile/http';
+export { preflight as OPTIONS } from '../../../../../lib/mobile/http';
+// no-store: live seats; a cached "3 left" would invite RSVPs that fail
+export const GET = readRoute(getRsvpStatus, false);
+export const HEAD = GET;
+export const ALL = () => methodNotAllowed();

package/src/pages/book/manage/[token].astro

@@ -8,21 +8,32 @@ import { resourceZone } from '../../../lib/booking/availability';
 import { eventTimeZone, locationLine } from '../../../lib/calendar/events';
 import { siteOrigin } from '../../../lib/seo';
 import { waitUntilFrom } from '../../../lib/webhooks';
+import { I18N, localePath, requestLocale } from '../../../lib/i18n';
+import { siteLang } from '../../../lib/dates';
+import { isExtraLocale, localizeDoc } from '../../../lib/translations';
+import { rsvpStrings } from '../../../lib/calendar/rsvp-words';
+import { fill } from '../../../lib/live/words';
 
 // The booker's own page, reached from the confirmation and every email: see
 // the status, add it to a calendar, move it or cancel it. The token in the
-// URL is the only credential — it's long and random, and never listed.
+// URL is the only credential — it's long and random, and never listed. An
+// RSVP's page speaks the page's language (/es/book/manage/… in Spanish);
+// room bookings stay in English like the rest of their pages.
 if (!CALENDAR.enabled) return new Response(null, { status: 404 });
 const repo = await getRepo(Astro.locals);
 const booking = await repo.getBookingByToken(Astro.params.token ?? '');
 if (!booking || (!bookingsEnabled() && booking.kind !== 'rsvp')) return new Response(null, { status: 404, statusText: 'Not found' });
 const settings = await repo.getSettings();
 const origin = siteOrigin(settings, Astro.url);
-const [resource, link, event] = await Promise.all([
+const [resource, link, rawEvent] = await Promise.all([
   booking.resourceId ? repo.getResource(booking.resourceId) : Promise.resolve(null),
   booking.linkId ? repo.getBookingLink(booking.linkId) : Promise.resolve(null),
   booking.eventId ? repo.getEvent(booking.eventId) : Promise.resolve(null),
 ]);
+const isRsvp = booking.kind === 'rsvp';
+const locale = I18N.enabled ? requestLocale(Astro.url, Astro.locals) : '';
+const w = rsvpStrings(isRsvp ? locale || siteLang(settings) : 'en');
+const event = rawEvent && localizeDoc(rawEvent, locale || undefined);
 const title = event ? event.title : [resource?.name, link?.name].filter(Boolean).join(' · ') || 'Booking';
 const location = event ? locationLine(event.location) : resource?.name ?? '';
 const url = origin + Astro.url.pathname;
@@ -40,25 +51,25 @@ if (Astro.request.method === 'POST') {
     try {
       current = await guestCancel(repo, booking, { origin, locals: Astro.locals, waitUntil: waitUntilFrom(Astro.locals) });
     } catch (err) {
-      error = err instanceof BookingError ? err.message : 'Couldn’t cancel — please try again.';
+      error = err instanceof BookingError ? err.message : w.cancelError;
     }
   }
 }
 const tz = event ? eventTimeZone(event, settings) : resource ? resourceZone(resource, settings.timezone) : settings.timezone || 'UTC';
-const when = whenText(current, tz, settings, link?.mode === 'day' || event?.allDay);
+const when = whenText(current, tz, isRsvp && isExtraLocale(locale) ? { ...settings, locale } : settings, link?.mode === 'day' || event?.allDay);
 const active = current.status === 'pending' || current.status === 'confirmed';
 const upcoming = current.end > Date.now();
 const can = guestChanges(current, link);
 const isNew = Astro.url.searchParams.has('new');
 const moved = Astro.url.searchParams.has('moved');
-const heading = current.status === 'cancelled' ? 'Booking cancelled'
-  : current.status === 'declined' ? 'Not available'
-  : current.status === 'pending' ? (isNew ? 'Request sent' : 'Waiting for approval')
-  : moved ? 'Booking moved' : isNew ? 'You’re booked' : 'Your booking';
-const lede = current.status === 'pending' ? `We’ll email ${current.email} once it’s approved.`
-  : current.status === 'confirmed' ? (current.formResponse?.definition.confirmation || link?.confirmMessage || `A confirmation is on its way to ${current.email}.`)
-  : current.status === 'declined' ? 'Sorry — this time couldn’t be confirmed. You’re welcome to pick another.'
-  : 'This booking is cancelled.';
+const heading = current.status === 'cancelled' ? w.cancelledTitle
+  : current.status === 'declined' ? w.notAvailable
+  : current.status === 'pending' ? (isNew ? w.requestSent : w.awaitingApproval)
+  : moved ? 'Booking moved' : isNew ? w.booked : w.yours;
+const lede = current.status === 'pending' ? fill(w.emailWhenApproved, { email: current.email })
+  : current.status === 'confirmed' ? (current.formResponse?.definition.confirmation || link?.confirmMessage || fill(w.confirmationOnItsWay, { email: current.email }))
+  : current.status === 'declined' ? (isRsvp ? w.declined : 'Sorry — this time couldn’t be confirmed. You’re welcome to pick another.')
+  : w.cancelledText;
 const googleUrl = `https://calendar.google.com/calendar/render?${new URLSearchParams({ action: 'TEMPLATE', text: title, dates: `${new Date(current.start).toISOString().replace(/[-:]|\.\d{3}/g, '')}/${new Date(current.end).toISOString().replace(/[-:]|\.\d{3}/g, '')}`, details: url, location })}`;
 ---
 
@@ -73,22 +84,22 @@ const googleUrl = `https://calendar.google.com/calendar/render?${new URLSearchPa
     <p class="pc-manage-lede">{lede}</p>
     {error && <p class="pc-bk-error">{error}</p>}
     <dl class="pc-manage-card">
-      <div><dt>What</dt><dd>{title}</dd></div>
-      <div><dt>When</dt><dd>{when}</dd></div>
-      {location && <div><dt>Where</dt><dd>{location}</dd></div>}
-      {current.seats > 1 && <div><dt>Seats</dt><dd>{current.seats}</dd></div>}
-      <div><dt>Status</dt><dd class={`pc-manage-status is-${current.status}`}>{current.status[0].toUpperCase() + current.status.slice(1)}</dd></div>
-      <div><dt>Reference</dt><dd class="mono">{current.id.slice(0, 8).toUpperCase()}</dd></div>
+      <div><dt>{w.what}</dt><dd>{title}</dd></div>
+      <div><dt>{w.when}</dt><dd>{when}</dd></div>
+      {location && <div><dt>{w.where}</dt><dd>{location}</dd></div>}
+      {current.seats > 1 && <div><dt>{w.seatsField}</dt><dd>{current.seats}</dd></div>}
+      <div><dt>{w.status}</dt><dd class={`pc-manage-status is-${current.status}`}>{w.statuses[current.status]}</dd></div>
+      <div><dt>{w.reference}</dt><dd class="mono">{current.id.slice(0, 8).toUpperCase()}</dd></div>
     </dl>
     {active && upcoming && (
       <div class="pc-manage-actions">
         {current.status === 'confirmed' && (
           <details class="pc-ev-add">
-            <summary>Add to calendar</summary>
+            <summary>{w.addToCalendar}</summary>
             <div class="pc-ev-add-menu">
               <a href={googleUrl} target="_blank" rel="noopener">Google Calendar</a>
               <a href="?ics=1">Apple Calendar</a>
-              <a href="?ics=1" download="booking.ics">Download .ics</a>
+              <a href="?ics=1" download="booking.ics">{w.downloadIcs}</a>
             </div>
           </details>
         )}
@@ -96,17 +107,17 @@ const googleUrl = `https://calendar.google.com/calendar/render?${new URLSearchPa
           <a class="pc-manage-btn" href={`${bookingLinkUrl(resource.slug, link.slug)}?reschedule=${encodeURIComponent(current.manageToken)}`}>Reschedule</a>
         )}
         {can.cancel && (
-          <form method="post" onsubmit="return confirm('Cancel this booking?')">
+          <form method="post" onsubmit={`return confirm(${JSON.stringify(isRsvp ? w.cancelConfirm : 'Cancel this booking?')})`}>
             <input type="hidden" name="op" value="cancel" />
-            <button class="pc-manage-btn is-danger" type="submit">Cancel {current.kind === 'rsvp' ? 'RSVP' : 'booking'}</button>
+            <button class="pc-manage-btn is-danger" type="submit">{isRsvp ? w.cancel : 'Cancel booking'}</button>
           </form>
         )}
       </div>
     )}
     {can.closed && <p class="pc-manage-note">Changes close {can.cutoffHours} hours before the start. Please contact us to change or cancel.</p>}
     <p class="pc-bk-foot">
-      {event ? <a href={eventUrl(event.slug)}>Back to {event.title}</a> : resource ? <a href={resourceUrl(resource.slug)}>Back to {resource.name}</a> : null}
+      {event ? <a href={localePath(eventUrl(event.slug), locale)}>{fill(w.backTo, { title: event.title })}</a> : resource ? <a href={resourceUrl(resource.slug)}>{fill(w.backTo, { title: resource.name })}</a> : null}
     </p>
-    <p class="pc-manage-note">Keep this link — anyone with it can change this booking.</p>
+    <p class="pc-manage-note">{w.keepLink}</p>
   </div>
 </Site>

package/src/pages/events/[slug].astro

@@ -5,7 +5,9 @@ import { formVersion } from '../../lib/forms/service';
 import { renderFields, hiddenFields } from '../../lib/forms/render';
 import { readForm, readAnswers, submissionGuard } from '../../lib/forms/http';
 import { submitEventForm, prepareLegacyEventForm } from '../../lib/forms/events';
-import { requestLocale } from '../../lib/i18n';
+import { I18N, localePath, requestLocale } from '../../lib/i18n';
+import { siteLang } from '../../lib/dates';
+import { rsvpStrings } from '../../lib/calendar/rsvp-words';
 import { localizeDoc, isExtraLocale } from '../../lib/translations';
 import Site from '../../layouts/Site.astro';
 import EventPage from '../../components/EventPage.astro';
@@ -45,7 +47,8 @@ const on = Astro.url.searchParams.get('on') ?? undefined;
 const occurrence = featuredOccurrence(event, settings, now, on && /^\d{4}-\d{2}-\d{2}$/.test(on) ? on : undefined);
 if (!occurrence) return new Response(null, { status: 404, statusText: 'Not found' });
 const origin = siteOrigin(settings, Astro.url);
-// RSVP: "Save my seat" posts back here and lands on the manage page
+// RSVP: "Save my seat" posts back here and lands on the manage page, in the
+// visitor's language
 let rsvpError = '';
 let formValues: Record<string,string> = {};
 let coreValues = { name: '', email: '', seats: '1' };
@@ -61,9 +64,9 @@ if (Astro.request.method === 'POST' && event.rsvp.enabled) {
     formValues = readAnswers(form, definition);
     coreValues = { name: String(form.get('name') || '').slice(0,120), email: String(form.get('email') || '').slice(0,200), seats: String(form.get('seats') || '1') };
     const booking = await submitEventForm(repo, event, occurrence, form, requestId, { origin, locals: Astro.locals, waitUntil: waitUntilFrom(Astro.locals) });
-    return Astro.redirect(`${manageUrl(booking.manageToken)}?new=1`, 303);
+    return Astro.redirect(`${localePath(manageUrl(booking.manageToken), locale)}?new=1`, 303);
   } catch (err) {
-    rsvpError = err instanceof BookingError || err instanceof ApiError ? err.message : 'Couldn’t save your RSVP. Please try again.';
+    rsvpError = err instanceof BookingError || err instanceof ApiError ? err.message : rsvpStrings((I18N.enabled ? locale : '') || siteLang(settings)).saveError;
   }
 }
 const formHtml = hiddenFields(await formVersion(definition), requestId) + `<input type="hidden" name="occurrence" value="${occurrence.start}">`;

package/src/theme-sdk/index.ts

@@ -22,6 +22,8 @@ export interface SectionProps<D = Record<string, unknown>> { data: D; variant: s
 export type { LinkValue, EventItem, PostItem, PostAuthor, BookingItem } from '../lib/sections';
 /** Props for templates/header.astro and templates/footer.astro. */
 export type { SiteChrome, ChromeLink } from '../lib/site-chrome';
+// core's chrome labels for any language (a template already gets them as site.words)
+export { siteStrings, type SiteStrings } from '../lib/site-words';
 import type { SiteChrome } from '../lib/site-chrome';
 export interface ChromeProps { site: SiteChrome }