@acms-subir/core 0.3.36 → 0.3.38

package/src/lib/forms/events.ts

@@ -17,7 +17,8 @@ export async function prepareLegacyEventForm(event: CalEvent, start: number, dat
   }
 }
 
-export async function submitEventForm(repo: ContentRepository, event: CalEvent, occurrence: { start: number; end: number }, data: FormData, requestId: string, flow: Parameters<typeof createRsvp>[2]) {
+// locale: the page's language, so the RSVP's emails and links speak it
+export async function submitEventForm(repo: ContentRepository, event: CalEvent, occurrence: { start: number; end: number }, data: FormData, requestId: string, flow: Parameters<typeof createRsvp>[2], locale = '') {
   if (event.status !== 'published') throw new ApiError(404, 'Event not found.');
   if (Number(data.get('occurrence')) !== occurrence.start) throw new ApiError(409, 'The event time has changed. Review the date and try again.');
   const seats = Number(data.get('seats') || 1);
@@ -35,6 +36,7 @@ export async function submitEventForm(repo: ContentRepository, event: CalEvent,
   };
   const existing = await replay(); if (existing) return existing;
   await collectResponse(definition, booker.answers, booker.formVersion);
-  try { return await createRsvp(repo, { event, ...occurrence, seats, booker }, { ...flow, idempotency }); }
+  // the language isn't part of the retry check: it doesn't change what was asked for
+  try { return await createRsvp(repo, { event, ...occurrence, seats, booker: { ...booker, locale } }, { ...flow, idempotency }); }
   catch (e) { const existing = await replay(); if (existing) return existing; throw e; }
 }

package/src/lib/mobile/bookings.ts

@@ -9,12 +9,15 @@ import { waitUntilFrom } from '../webhooks';
 import { requireCalendar } from './calendar';
 import { appAnswers, joinAnswers } from './forms';
 import { rsvpClosed, rsvpOccurrence, rsvpQuestions } from './rsvp';
+import { localeQuery, mobileLocale } from './locale';
 
 const common = {
   start: z.string().datetime({ offset: true }),
   name: z.string().trim().min(1).max(120), email: z.string().trim().email().max(200).transform(v => v.toLowerCase()),
   phone: z.string().trim().max(40).default(''),
   answers: appAnswers.default({}),
+  // the app's language (one of the site's locales): the emails and links speak it
+  locale: localeQuery,
 };
 export const bookingInput = z.union([
   z.object({ ...common, resource: z.string().min(1).max(200), link: z.string().min(1).max(200),
@@ -36,7 +39,11 @@ export async function submitBooking(repo: ContentRepository, request: Request, l
   if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(key)) throw new ApiError(400, 'Send a random UUID v4 in Idempotency-Key and reuse it only for retries.');
   const body = bookingInput.parse(await readJson(request, 50000));
   if (!('event' in body)) requireCalendar(true);
-  const idempotency = { keyHash: await sha256Hex(key.toLowerCase()), requestHash: await sha256Hex(canonical(body)) };
+  const locale = mobileLocale(body.locale) ?? '';
+  // the language isn't a booking detail: a retry in another one replays the
+  // same booking, and keys saved before apps sent it still match
+  const { locale: _language, ...asked } = body;
+  const idempotency = { keyHash: await sha256Hex(key.toLowerCase()), requestHash: await sha256Hex(canonical(asked)) };
   const replay = async () => {
     const record = await repo.getBookingRequest(idempotency.keyHash);
     if (!record) return null;
@@ -51,7 +58,7 @@ export async function submitBooking(repo: ContentRepository, request: Request, l
     const settings = await repo.getSettings();
     const flow = { origin: siteOrigin(settings, new URL(request.url)), locals, waitUntil: waitUntilFrom(locals), idempotency };
     const start = Date.parse(body.start);
-    const booker = { ...body, answers: joinAnswers(body.answers) };
+    const booker = { ...body, answers: joinAnswers(body.answers), locale };
     let booking: Booking;
     if ('event' in body) {
       const occurrence = await rsvpOccurrence(repo, body.event, body.start);

package/src/lib/mobile/calendar.ts

@@ -13,6 +13,7 @@ import { pageQuery, isoDay, isoDayOrInstant, queryParams } from './http';
 import { localizeDoc } from '../translations';
 import { localeQuery, mobileLocale, localizedUrl } from './locale';
 import { confirmsInstantly, linkApproval } from '../booking/approval';
+import { changeTopics } from '../push/service';
 
 export function requireCalendar(bookings = false) {
   if (!CALENDAR.enabled || (bookings && !bookingsEnabled())) throw new ApiError(404, 'This feature is disabled.');
@@ -59,20 +60,21 @@ export async function listEvents(repo: ContentRepository, url: URL) {
     occurrences: occurrences.slice(start, start + q.limit).map(o => ({
       id: `${o.event.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay,
       cancelled: o.cancelled,
-      event: publicEventDto(o.event, origin, publicCalendars, settings.timezone, locale),
+      event: publicEventDto(o.event, origin, publicCalendars, settings, locale),
     })),
     pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
   };
 }
 // e is already localized; publicCalendars limits which calendars are named
-export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, siteTz: string, locale: string | null) {
-  const event = eventToJson(e, origin, publicCalendars, siteTz);
+export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, settings: Settings, locale: string | null) {
+  const event = eventToJson(e, origin, publicCalendars, settings.timezone);
   event.url = localizedUrl(event.url, origin, locale);
   // Only configured public event fields; no undeclared imported metadata, no private fields.
   event.fields = publicEventFields(e.fields);
   event.image = safeUrl(e.cover, origin);
   event.cta = { ...event.cta, href: localizedUrl(safeUrl(event.cta.href, origin, true), origin, locale) };
-  return event;
+  // which push topics hear about date, time or place changes ([] = none do)
+  return { ...event, notify: { changes: changeTopics(e, settings, publicCalendars) } };
 }
 export async function listResources(repo: ContentRepository, url: URL) {
   requireCalendar(true);

package/src/lib/mobile/guest.ts

@@ -4,7 +4,8 @@ import type { Booking } from '../schema';
 import { ApiError, readJson } from '../api';
 import { sha256Hex } from '../api-keys';
 import { randomToken, safeEqual } from '../editor/auth';
-import { CALENDAR, bookingsEnabled, manageUrl } from '../calendar/config';
+import { CALENDAR, bookingsEnabled } from '../calendar/config';
+import { bookingManagePath } from '../booking/emails';
 import { encrypt, encryptionAvailable, resolveConfig, validAddress } from '../email/config';
 import { kickEmail } from '../email/service';
 import { guestChanges } from '../booking/service';
@@ -144,7 +145,7 @@ export async function myBookings(c: PublicContext) {
         start: new Date(b.start).toISOString(), end: new Date(b.end).toISOString(), seats: b.seats,
         title: event ? event.title : [resource?.name, link?.name].filter(Boolean).join(' · ') || 'Booking',
         // use with the Booking-Token header on /bookings/manage/*
-        manageToken: b.manageToken, manageUrl: origin + manageUrl(b.manageToken),
+        manageToken: b.manageToken, manageUrl: origin + bookingManagePath(b),
         can: guestChanges(b, link, now),
       };
     }),

package/src/lib/mobile/manage.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import type { Booking, BookingLink, CalEvent, Resource, Settings } from '../schema';
 import { ApiError, readJson } from '../api';
-import { bookingsEnabled, eventUrl, manageUrl } from '../calendar/config';
+import { bookingsEnabled, eventUrl } from '../calendar/config';
 import { eventTimeZone, locationLine } from '../calendar/events';
 import { resourceZone, linkLengths } from '../booking/availability';
-import { bookingIcs } from '../booking/emails';
+import { bookingIcs, bookingLanguage, bookingManagePath } from '../booking/emails';
+import { localePath } from '../i18n';
 import { guestCancel, guestChanges, guestMoveLink, guestReschedule } from '../booking/service';
 import { siteOrigin } from '../seo';
 import { waitUntilFrom } from '../webhooks';
@@ -59,9 +60,10 @@ function view(m: Managed, booking = m.booking) {
     location: event ? locationLine(event.location) : resource?.name ?? '',
     resource: resource ? { slug: resource.slug, name: resource.name } : null,
     link: link ? { slug: link.slug, name: link.name, mode: link.mode, lengths: linkLengths(link) } : null,
-    event: event ? { slug: event.slug, title: event.title, url: origin + eventUrl(event.slug) } : null,
+    // the web pages in the language it was booked in, as the emails link them
+    event: event ? { slug: event.slug, title: event.title, url: origin + localePath(eventUrl(event.slug), bookingLanguage(booking, settings).locale) } : null,
     // the web page for this booking (the same private link the emails carry)
-    manageUrl: origin + manageUrl(booking.manageToken),
+    manageUrl: origin + bookingManagePath(booking),
     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,
@@ -106,7 +108,7 @@ export async function managedIcs(c: PublicContext) {
   z.object({}).strict().parse(queryParams(c.url));
   const m = await managed(c);
   const v = view(m);
-  const body = bookingIcs(m.booking, v.title, v.location, v.manageUrl, new URL(m.origin).host, m.booking.status === 'cancelled' ? 'CANCEL' : 'REQUEST', { allDay: v.booking.allDay });
+  const body = bookingIcs(m.booking, v.title, v.location, v.manageUrl, new URL(m.origin).host, m.booking.status === 'cancelled' ? 'CANCEL' : 'REQUEST', { allDay: v.booking.allDay, lang: bookingLanguage(m.booking, m.settings).lang });
   return new Response(body, { headers: {
     'Content-Type': 'text/calendar; charset=utf-8', 'Content-Disposition': 'attachment; filename="booking.ics"',
     'Cache-Control': 'no-store', 'Access-Control-Allow-Origin': '*', 'X-Content-Type-Options': 'nosniff',

package/src/lib/mobile/rsvp.ts

@@ -6,6 +6,8 @@ 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';
@@ -54,12 +56,18 @@ export async function getRsvpStatus(repo: ContentRepository, url: URL, slug: str
   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: form.submitLabel || (rsvp.autoConfirm ? 'Confirm my seat' : 'Request a seat') } : null,
+    form: form ? { ...await formJson(form), submitLabel } : null,
   };
 }

package/src/lib/mobile/schemas.ts

@@ -32,6 +32,8 @@ export const Event = CalEvent.pick({
   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,
   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 }),
 });
 export const Events = z.object({ locale, timezone: str, from: date, to: date, pagination: Pagination,
   occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, event: Event })),

package/src/lib/mobile/search.ts

@@ -87,7 +87,7 @@ export async function search(repo: ContentRepository, url: URL) {
         snippet: plainSnippet(snippet),
         // the next occurrence, or the latest one when the event is over
         occurrence: o ? { start: iso(o.start), end: iso(o.end), allDay: o.allDay, cancelled: o.cancelled } : null,
-        event: publicEventDto(e, origin, listed, settings.timezone, locale),
+        event: publicEventDto(e, origin, listed, settings, locale),
       };
     }),
     more: { posts: posts.length > q.limit, pages: pages.length > q.limit, events: events.length > q.limit },

package/src/lib/mobile/site.ts

@@ -13,6 +13,7 @@ import { queryParams } from './http';
 import { localeOnlyQuery, localizedUrl, mobileLocale } from './locale';
 import { guestSignInReady } from './guest';
 import { LEGAL } from '../legal/config';
+import { siteStrings } from '../site-words';
 
 export async function getSite(repo: ContentRepository, url: URL, _id = '', locals?: unknown) {
   // locale: the legal links point at that language's pages (/es/privacy)
@@ -23,16 +24,19 @@ export async function getSite(repo: ContentRepository, url: URL, _id = '', local
   const origin = siteOrigin(settings, url);
   const bases = new Set(Object.values(CONTENT.collections).map(c => c.base));
   const header = nav.filter(n => n.area === 'header').sort((a, b) => a.order - b.order);
+  // the same list the website's header shows in that language: the owner's
+  // menu as written, or the automatic one with its words translated
+  const words = siteStrings(locale || settings.locale || 'en');
   const menu = header.length ? header : [
-    { label: 'Home', url: '/' },
+    { label: words.home, url: '/' },
     ...pages.filter(p => p.status === 'published' && !p.isHome).map(p => ({ label: p.title, url: `/${p.slug}` })),
     ...Object.values(CONTENT.collections).map(c => ({ label: c.plural, url: c.base })),
-    { label: 'Links', url: '/links' },
+    { label: words.links, url: '/links' },
   ];
   return {
     name: settings.siteTitle, description: settings.tagline,
     logo: safeUrl(settings.siteLogo, origin), logoDark: safeUrl(settings.siteLogoDark, origin), icon: safeUrl(settings.siteFavicon, origin),
-    menu: menu.map(n => ({ label: n.label, href: safeUrl(n.url, origin, true) })),
+    menu: menu.map(n => ({ label: n.label, href: localizedUrl(safeUrl(n.url, origin, true), origin, locale) })),
     languages: { default: I18N.defaultLocale || null, locales: I18N.locales.map(code => ({ code, name: localeName(code, true) })) },
     features: {
       // redirectFrom: old addresses the website 301s to url, so apps can follow them too,

package/src/lib/push/service.ts

@@ -229,6 +229,16 @@ function inChangeRule(rule: PushAuto['eventChanges'], e: CalEvent) {
   const tags = new Set(rule.tags.map((t) => t.toLowerCase()));
   return inRule(rule.calendars, e) && (!tags.size || e.tags.some((t) => tags.has(t.toLowerCase())));
 }
+/**
+ * The topics this event's change notices go to (Admin → Mobile app → When an
+ * event changes), or [] while that rule doesn't cover it. Apps show it to
+ * promise "we'll let you know if it changes" only when it's true.
+ */
+export function changeTopics(e: CalEvent, settings: Settings, calendars: Map<string, Calendar>): string[] {
+  const rule = settings.push.auto.eventChanges;
+  if (!PUSH.enabled || !CALENDAR.enabled || !inChangeRule(rule, e)) return [];
+  return rule.topics.length ? [...rule.topics] : eventTopics(e, calendars);
+}
 function eventTopics(e: CalEvent, calendars: Map<string, Calendar>) {
   return ['events', ...e.calendarIds.map((id) => calendars.get(id)).filter((c): c is Calendar => c?.visibility === 'public').map((c) => `calendar:${c.slug}`)];
 }

package/src/lib/repo/migrations.ts

@@ -685,6 +685,11 @@ export const MIGRATIONS: Migration[] = [
     `ALTER TABLE push_queue ADD COLUMN payload TEXT`,
     `ALTER TABLE push_queue ADD COLUMN due_at INTEGER`,
   ] },
+  // the language a booking or RSVP was made in (Booking.locale), so its
+  // emails and links follow it; '' = the main language, so older rows need no backfill
+  { version: 60, statements: [
+    `ALTER TABLE bookings ADD COLUMN locale TEXT NOT NULL DEFAULT ''`,
+  ] },
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.

package/src/lib/repo/sql.ts

@@ -210,7 +210,7 @@ function rowToBooking(r: Row): Booking {
     status: r.status, start: Number(r.start_at), end: Number(r.end_at), holdStart: Number(r.hold_start), holdEnd: Number(r.hold_end),
     timezone: r.timezone ?? '', name: r.name ?? '', email: r.email ?? '', phone: r.phone ?? '', seats: Number(r.seats ?? 1),
     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',
+    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),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
@@ -446,7 +446,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','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','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 {
@@ -1078,9 +1078,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) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        seats, answers, notes, manage_token, source, reminder_sent_at, created_at, updated_at, notification_version, form_response, locale) 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.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],
     };
   }
   async listResources() {

package/src/lib/repo/types.ts

@@ -195,8 +195,9 @@ export interface ContentRepository {
   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
   createBooking(
-    data: Omit<Booking, 'id' | 'createdAt' | 'updatedAt' | 'reminderSentAt' | 'notificationVersion'>,
+    data: Omit<Booking, 'id' | 'createdAt' | 'updatedAt' | 'reminderSentAt' | 'notificationVersion' | 'locale'> & { locale?: string },
     guard?: { capacity?: number; idempotency?: { keyHash: string; requestHash: string } }
   ): Promise<Booking | null>;
   // moves a booking only if the new held range is free (reschedule)

package/src/lib/schema.ts

@@ -674,6 +674,9 @@ export const Booking = z.object({
   manageToken: z.string().default(''),
   // web: the website; app: the public app API (/api/v1/bookings)
   source: z.enum(['web', 'app', 'admin', 'api', 'agent']).default('web'),
+  // the language the booker used (an extra site locale, e.g. 'es'): their
+  // emails and links speak it. '' = the site's main language, as on page rows
+  locale: z.string().default(''),
   reminderSentAt: z.number().nullable().default(null),
   notificationVersion: z.number().default(0),
   createdAt: z.number(),

package/src/pages/book/[resource]/[link].astro

@@ -6,9 +6,12 @@ import { bookingsEnabled, manageUrl, resourceUrl } from '../../../lib/calendar/c
 import { availabilityContext, createResourceBooking, guestMoveLink, guestReschedule, BookingError } from '../../../lib/booking/service';
 import { siteOrigin } from '../../../lib/seo';
 import { waitUntilFrom } from '../../../lib/webhooks';
+import { localePath, requestLocale } from '../../../lib/i18n';
 
 // One booking link: pick → answer → done. POSTs create the booking (or move
-// one when ?reschedule=<token>) and land on the manage page.
+// one when ?reschedule=<token>) and land on the manage page. These pages are
+// in English, but a booking made from /es/… keeps the visitor's language for
+// its emails and its own page.
 if (!bookingsEnabled()) return new Response(null, { status: 404 });
 const repo = await getRepo(Astro.locals);
 const resource = await repo.getResourceBySlug(Astro.params.resource ?? '');
@@ -17,6 +20,7 @@ if (!resource || !link || !link.active) return new Response(null, { status: 404,
 const settings = await repo.getSettings();
 const origin = siteOrigin(settings, Astro.url);
 const flow = { origin, locals: Astro.locals, waitUntil: waitUntilFrom(Astro.locals) };
+const locale = requestLocale(Astro.url, Astro.locals);
 const rescheduleToken = Astro.url.searchParams.get('reschedule') ?? '';
 const reschedule = rescheduleToken ? await repo.getBookingByToken(rescheduleToken) : null;
 if (reschedule && reschedule.linkId !== link.id) return Astro.redirect(manageUrl(reschedule.manageToken));
@@ -37,16 +41,16 @@ if (Astro.request.method === 'POST') {
       const b = await repo.getBookingByToken(token);
       if (!b || b.linkId !== link.id) throw new BookingError(404, 'That booking can’t be found.');
       await guestReschedule(repo, b, start, end, flow);
-      return Astro.redirect(`${manageUrl(b.manageToken)}?moved=1`);
+      return Astro.redirect(`${localePath(manageUrl(b.manageToken), locale)}?moved=1`);
     }
     const answers: Record<string, string> = {};
     for (const qn of link.questions) answers[qn.id] = String(form.get(`q_${qn.id}`) ?? '');
     const b = await createResourceBooking(repo, {
       resource, link, start, end,
-      booker: { name: String(form.get('name') ?? ''), email: String(form.get('email') ?? ''), phone: String(form.get('phone') ?? ''), answers },
+      booker: { name: String(form.get('name') ?? ''), email: String(form.get('email') ?? ''), phone: String(form.get('phone') ?? ''), answers, locale },
     }, flow);
     if (link.redirectUrl && /^https?:\/\//.test(link.redirectUrl)) return Astro.redirect(link.redirectUrl);
-    return Astro.redirect(`${manageUrl(b.manageToken)}?new=1`);
+    return Astro.redirect(`${localePath(manageUrl(b.manageToken), locale)}?new=1`);
   } catch (err) {
     error = err instanceof BookingError ? err.message : 'Something went wrong. Please try again.';
     if (Number.isFinite(start)) {

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

@@ -8,27 +8,45 @@ 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 { bookingStrings } from '../../../lib/email/booking-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. It
+// speaks the request's language, for RSVPs and room bookings alike
+// (/es/book/manage/… in Spanish, as the emails of a booking made in Spanish
+// link it); opened without the prefix it shows the main language, with no
+// redirect. The room booking flow it links back to stays in English.
 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 title = event ? event.title : [resource?.name, link?.name].filter(Boolean).join(' · ') || 'Booking';
+const isRsvp = booking.kind === 'rsvp';
+const locale = I18N.enabled ? requestLocale(Astro.url, Astro.locals) : '';
+const lang = locale || siteLang(settings);
+// a room booking words a few things its own way ("Your booking", not "Your RSVP")
+const bw = bookingStrings(lang).page;
+const w = isRsvp ? rsvpStrings(lang) : { ...rsvpStrings(lang), ...bw };
+const event = rawEvent && localizeDoc(rawEvent, locale || undefined);
+const title = event ? event.title : [resource?.name, link?.name].filter(Boolean).join(' · ') || bw.untitled;
 const location = event ? locationLine(event.location) : resource?.name ?? '';
-const url = origin + Astro.url.pathname;
+// the address the visitor sees (/es/… is rewritten to this route)
+const url = origin + localePath(Astro.url.pathname, locale);
 
 if (Astro.url.searchParams.get('ics')) {
-  return new Response(bookingIcs(booking, title, location, url, new URL(origin).host), {
+  return new Response(bookingIcs(booking, title, location, url, new URL(origin).host, 'REQUEST', { lang }), {
     headers: { 'Content-Type': 'text/calendar; charset=utf-8', 'Content-Disposition': 'inline; filename="booking.ics"', 'Cache-Control': 'private, no-store' },
   });
 }
@@ -40,25 +58,26 @@ 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, 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 ? bw.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' ? w.declined
+  : w.cancelledText;
+const cutoff = fill(bw.cutoff, { hours: String(can.cutoffHours) });
 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,40 +92,40 @@ 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>
         )}
         {resource && link && can.reschedule && (
-          <a class="pc-manage-btn" href={`${bookingLinkUrl(resource.slug, link.slug)}?reschedule=${encodeURIComponent(current.manageToken)}`}>Reschedule</a>
+          <a class="pc-manage-btn" href={`${bookingLinkUrl(resource.slug, link.slug)}?reschedule=${encodeURIComponent(current.manageToken)}`}>{bw.reschedule}</a>
         )}
         {can.cancel && (
-          <form method="post" onsubmit="return confirm('Cancel this booking?')">
+          <form method="post" onsubmit={`return confirm(${JSON.stringify(w.cancelConfirm)})`}>
             <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">{w.cancel}</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>}
+    {can.closed && <p class="pc-manage-note">{cutoff}</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 (its emails speak it too)
 let rsvpError = '';
 let formValues: Record<string,string> = {};
 let coreValues = { name: '', email: '', seats: '1' };
@@ -60,10 +63,10 @@ if (Astro.request.method === 'POST' && event.rsvp.enabled) {
     requestId = await submissionGuard(repo, form, Astro.clientAddress, `event:${event.id}`);
     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);
+    const booking = await submitEventForm(repo, event, occurrence, form, requestId, { origin, locals: Astro.locals, waitUntil: waitUntilFrom(Astro.locals) }, locale);
+    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

@@ -24,6 +24,9 @@ export type { LinkValue, EventItem, PostItem, PostAuthor, BookingItem } from '..
 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';
+// the built-in event page's words and repeat line ("Weekly on Sunday"), for templates/event.astro
+export { eventStrings, type EventStrings } from '../lib/calendar/event-words';
+export { describeRepeat } from '../lib/calendar/rrule';
 import type { SiteChrome } from '../lib/site-chrome';
 export interface ChromeProps { site: SiteChrome }