@acms-subir/core 0.3.62 → 0.3.64

package/src/lib/mobile/calendar.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { ContentRepository } from '../repo/types';
-import { type BookingLink, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
+import { linkWords, roomName, type BookingLink, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
 import { ApiError } from '../api';
 import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl, publicEventFields } from '../calendar/config';
 import { calendarToJson, eventToJson, roomsToJson } from '../calendar/api';
@@ -19,6 +19,8 @@ import { localeQuery, mobileLocale, localizedUrl } from './locale';
 import { confirmsInstantly, linkApproval } from '../booking/approval';
 import { changeTopics } from '../push/service';
 import { occurrenceMatches, readEventFilter, resolveEventFilter, tagsMatch } from '../calendar/filter';
+import { bookingAllDay, publicBookingKey, publicBookingTitle, scheduleBookings } from '../booking/public';
+import { eventStrings } from '../calendar/event-words';
 
 export function requireCalendar(bookings = false) {
   if (!CALENDAR.enabled || (bookings && !bookingsEnabled())) throw new ApiError(404, 'This feature is disabled.');
@@ -40,6 +42,7 @@ export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: i
   calendar: filterList('Only events in these calendars (slugs).'), cal: filterList('Alias of calendar.'),
   tag: filterList('Only events with one of these tags (a name in any case, or a slug).'), excludeTag: filterList('Leave out events with any of these tags.'), notag: filterList('Alias of excludeTag.'),
   room: filterList('Only events held in one of these rooms (slugs of rooms shown on public events).'),
+  bookings: z.enum(['1', 'true']).optional().describe('Also the confirmed bookings of rooms set to “Show on the calendar”, as `bookings` (with the first page): the booking link’s name in the requested language, the time and the room, never who booked. Only `room` narrows them; `calendar`, `tag` and `excludeTag` don’t (a booking belongs to no calendar and has no tags).'),
   q: z.string().max(100).optional().describe('Search: the events /search finds (unlisted calendars too, never Google booking-page appointments), listed by date. Without it, only public calendars and the ones named in calendar.') }).strict();
 export async function listEvents(repo: ContentRepository, url: URL) {
   requireCalendar();
@@ -82,9 +85,27 @@ export async function listEvents(repo: ContentRepository, url: URL) {
       ...occurrenceDto(o, resources, locale || siteLang(settings)),
       event: publicEventDto(o.event, origin, publicCalendars, all, settings, locale, resources),
     })),
+    // the whole window's bookings come with the first page, so paging never repeats them
+    ...(q.bookings ? { bookings: q.page === 1 && bookingsEnabled() ? await publicBookingsDto(repo, [...resources.values()], f.roomIds, from, to, term, locale || siteLang(settings)) : [] } : {}),
     pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
   };
 }
+/**
+ * Confirmed bookings of rooms set to show on the calendar (in `roomIds` when
+ * the address names rooms; `term` matches their title), as the public sees
+ * them on /calendar: the booking link's name in `locale`, the time and the
+ * room. Never who booked, and not the booking's id (`id` is an opaque key).
+ */
+async function publicBookingsDto(repo: ContentRepository, rooms: Resource[], roomIds: string[] | null, from: number, to: number, term: string, locale: string) {
+  const shown = rooms.filter(r => r.showOnCalendar && (!roomIds || roomIds.includes(r.id)));
+  const reserved = eventStrings(locale).calendar.reserved;
+  const iso = (n: number) => new Date(n).toISOString();
+  const items = (await scheduleBookings(repo, shown, from, to, 500)).map(({ booking: b, resource: r, link }) => ({ b, r, title: publicBookingTitle(link, locale, reserved), allDay: bookingAllDay(b, link) }))
+    .filter(x => !term || x.title.toLowerCase().includes(term.toLowerCase()));
+  return Promise.all(items.map(async ({ b, r, title, allDay }) => ({
+    id: await publicBookingKey(b), title, start: iso(b.start), end: iso(b.end), allDay, rooms: roomsToJson([r.id], new Map([[r.id, r]]), true, locale),
+  })));
+}
 // 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
@@ -131,18 +152,21 @@ export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map
   // which push topics hear about date, time or place changes ([] = none do)
   return { ...event, notify: { changes: changeTopics(e, settings, all) } };
 }
+export const resourcesQuery = z.object({ ...pageQuery, locale: localeQuery }).strict();
 export async function listResources(repo: ContentRepository, url: URL) {
   requireCalendar(true);
-  const q = z.object(pageQuery).strict().parse(queryParams(url));
+  const q = resourcesQuery.parse(queryParams(url));
+  // rooms and booking links named in the request's language (their main words without one)
+  const locale = mobileLocale(q.locale);
   const [settings, resources, links] = await Promise.all([repo.getSettings(), repo.listResources(), repo.listBookingLinks()]);
   const origin = siteOrigin(settings, url), start = (q.page - 1) * q.limit;
   const visible = resources.filter(r => r.visibility === 'public');
   return { resources: visible.slice(start, start + q.limit).map(r => ({
-    id: r.id, slug: r.slug, name: r.name, kind: r.kind, description: r.description, capacity: r.capacity, amenities: r.amenities,
-    photo: safeUrl(r.photo, origin), timezone: r.timezone || settings.timezone || 'UTC', url: origin + resourceUrl(r.slug),
+    id: r.id, slug: r.slug, name: roomName(r, locale), kind: r.kind, description: r.description, capacity: r.capacity, amenities: r.amenities,
+    photo: safeUrl(r.photo, origin), timezone: r.timezone || settings.timezone || 'UTC', url: localizedUrl(origin + resourceUrl(r.slug), origin, locale),
     links: links.filter(l => l.resourceId === r.id && l.active && l.visibility === 'public').map(l => ({
-      id: l.id, slug: l.slug, name: l.name, description: l.description, mode: l.mode, lengths: linkLengths(l), rules: describeLink(l),
-      askPhone: l.askPhone, autoConfirm: confirmsInstantly(linkApproval(l, settings)), url: origin + bookingLinkUrl(r.slug, l.slug),
+      id: l.id, slug: l.slug, ...linkWords(l, locale), mode: l.mode, lengths: linkLengths(l), rules: describeLink(l),
+      askPhone: l.askPhone, autoConfirm: confirmsInstantly(linkApproval(l, settings)), url: localizedUrl(origin + bookingLinkUrl(r.slug, l.slug), origin, locale),
       questions: l.questions.map(({ id, label, type, required, options }) => ({ id, label, type, required, options })),
     })),
   })), pagination: { page: q.page, limit: q.limit, nextPage: visible.length > start + q.limit ? q.page + 1 : null } };

package/src/lib/mobile/guest.ts

@@ -5,7 +5,8 @@ import { ApiError, readJson } from '../api';
 import { sha256Hex } from '../api-keys';
 import { randomToken, safeEqual } from '../editor/auth';
 import { CALENDAR, bookingsEnabled } from '../calendar/config';
-import { bookingManagePath } from '../booking/emails';
+import { bookingLanguage, bookingManagePath } from '../booking/emails';
+import { bookingTitle } from '../booking/view';
 import { encrypt, encryptionAvailable, resolveConfig, validAddress } from '../email/config';
 import { kickEmail } from '../email/service';
 import { guestChanges } from '../booking/service';
@@ -144,7 +145,8 @@ export async function myBookings(c: PublicContext) {
       return {
         id: b.id, reference: b.id.slice(0, 8).toUpperCase(), kind: b.kind as 'booking' | 'rsvp', status: b.status,
         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',
+        // a room booking in the language it was booked in, as its emails name it
+        title: event ? event.title : bookingTitle(resource, link, bookingLanguage(b, settings).locale) || 'Booking',
         // use with the Booking-Token header on /bookings/manage/*
         manageToken: b.manageToken, manageUrl: origin + bookingManagePath(b),
         can: guestChanges(b, link, now),

package/src/lib/mobile/manage.ts

@@ -5,6 +5,8 @@ import { bookingsEnabled, eventUrl } from '../calendar/config';
 import { eventTimeZone, locationLine } from '../calendar/events';
 import { resourceZone, linkLengths } from '../booking/availability';
 import { bookingIcs, bookingLanguage, bookingManagePath } from '../booking/emails';
+import { bookingTitle } from '../booking/view';
+import { linkWords, roomName } from '../schema';
 import { localePath } from '../i18n';
 import { confirmOffer, guestCancel, guestChanges, guestMoveLink, guestReschedule, waitlistPosition } from '../booking/service';
 import { siteOrigin } from '../seo';
@@ -48,6 +50,8 @@ async function managed(c: PublicContext): Promise<Managed> {
 function view(m: Managed, booking = m.booking, position: number | null = null) {
   const { resource, link, event, settings, origin } = m;
   const can = guestChanges(booking, link);
+  // the room and booking link named in the language it was booked in, as its emails name them
+  const { locale } = bookingLanguage(booking, settings);
   return {
     booking: {
       id: booking.id, reference: booking.id.slice(0, 8).toUpperCase(), kind: booking.kind as 'booking' | 'rsvp', status: booking.status,
@@ -59,10 +63,10 @@ function view(m: Managed, booking = m.booking, position: number | null = null) {
       // 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 ?? '',
-    resource: resource ? { slug: resource.slug, name: resource.name } : null,
-    link: link ? { slug: link.slug, name: link.name, mode: link.mode, lengths: linkLengths(link) } : null,
+    title: event ? event.title : bookingTitle(resource, link, locale) || 'Booking',
+    location: event ? locationLine(event.location) : resource ? roomName(resource, locale) : '',
+    resource: resource ? { slug: resource.slug, name: roomName(resource, locale) } : null,
+    link: link ? { slug: link.slug, name: linkWords(link, locale).name, mode: link.mode, lengths: linkLengths(link) } : 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)

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, eventDetailQuery, availabilityQuery, roomFreeQuery } from './calendar';
+import { eventsQuery, eventDetailQuery, availabilityQuery, roomFreeQuery, resourcesQuery } from './calendar';
 import { bookingInput } from './bookings';
 import { rsvpQuery } from './rsvp';
 import { pagesQuery } from './pages';
@@ -15,7 +15,7 @@ import { codeInput, tokenInput, myBookingsQuery } from './guest';
 import { deviceInput, deviceUpdate, staffLinkInput } from '../push/api';
 import { announcementsQuery } from '../announcements/api';
 import { localeOnlyQuery } from './locale';
-import { pageQuery, queryParams } from './http';
+import { queryParams } from './http';
 import * as schemas from './schemas';
 import { editorPaths, editorSchemas, editorSecuritySchemes } from '../editor/openapi';
 
@@ -52,11 +52,11 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
     ['/content', 'Published content in the requested language; q (requires search) returns ranked matches, posts before pages, up to 200 per kind', contentQuery, jsonSchema(z.object({ locale: z.string().nullable(), items: z.array(schemas.ContentSummary), pagination: schemas.Pagination }))],
     ['/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', 'Public event occurrences; bookings=1 adds the confirmed bookings of rooms shown on the calendar (link name, time, room; never who booked); 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')],
+    ['/resources', 'Public resources and booking links, named in the requested language (locale: their translated names and descriptions); requires bookings', resourcesQuery, 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')],
     ['/announcements', 'Announcements up right now, newest first, in the requested language; pinned=true lists only the banners, urgent first; requires announcements', announcementsQuery, ref('Announcements')],

package/src/lib/mobile/schemas.ts

@@ -50,8 +50,13 @@ export const Event = CalEvent.pick({
   // push topics told about date, time or place changes (Admin → Mobile app → When an event changes); [] = none
   notify: z.object({ changes: strings }),
 });
+// a confirmed room booking as the public sees it (bookings=1): its booking link's name in the requested
+// language ("Reserved" without one), the time and the room; never who booked. id: an opaque key, not the booking's
+export const ScheduleBooking = z.object({ id: str, title: str, start: date, end: date, allDay: bool, rooms: z.array(EventRoom) });
 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, moved: OccurrenceMoved, location: OccurrencePlace, rooms: z.array(EventRoom), event: Event })),
+  // only with bookings=1: the window's bookings, on the first page ([] on later pages)
+  bookings: z.array(ScheduleBooking).optional(),
 });
 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 });
@@ -125,7 +130,7 @@ export const GuestBookings = z.object({ email: str, pagination: Pagination, item
 export const GuestSignedOut = z.object({ signedOut: z.literal(true) });
 export const Calendars = z.object({ calendars: z.array(Calendar.pick({ id: true, slug: true, name: true, color: true, description: true, kind: true, visibility: true }).extend({ feedUrl: str })) });
 export const Resources = z.object({ pagination: Pagination, resources: z.array(z.object({
-  id: str, slug: str, name: str, kind: str, description: str, capacity: z.number(), amenities: strings, photo: str, timezone: str, url: str,
+  id: str, slug: str, name: str, kind: str, description: str, capacity: z.number().nullable(), amenities: strings, photo: str, timezone: str, url: str,
   links: z.array(z.object({ id: str, slug: str, name: str, description: str, mode: z.enum(['slots', 'day', 'range']), lengths: z.array(z.number()), rules: str,
     askPhone: bool, autoConfirm: bool, url: str, questions: z.array(BookingQuestion.omit({ help: true })),
   })),

package/src/lib/repo/migrations.ts

@@ -12,7 +12,7 @@ import { SYNC_MIGRATION } from '../sync/migration';
 import { ANNOUNCEMENT_TABLE, ANNOUNCEMENT_VISIBLE_COLUMNS } from '../announcements/migration';
 import { SCREENS_MIGRATION } from '../display/store';
 import { REQUEST_TABLE } from '../calendar/request-migration';
-import { GCAL_MIGRATION } from '../calendar/google/migration';
+import { GCAL_BOOKINGS_MIGRATION, GCAL_MIGRATION } from '../calendar/google/migration';
 // Versioned schema migrations shared by the two SQLite-dialect adapters
 // (D1 and libSQL). Applied versions are recorded in the `migrations` table;
 // each adapter's runner applies whatever is newer, in order, at startup.
@@ -748,6 +748,17 @@ export const MIGRATIONS: Migration[] = [
     `DROP TRIGGER content_version_resources_update`,
     contentVersionTriggers('resources', [...CONTENT_VERSION_COLUMNS.resources, 'color', 'show_on_events', 'translations'])[2],
   ] },
+  // a booking link's name and description in other languages
+  // (BookingLink.translations): public, so a change refreshes cached pages and API answers
+  { version: 72, statements: [
+    `ALTER TABLE booking_links ADD COLUMN translations TEXT NOT NULL DEFAULT '{}'`,
+    `DROP TRIGGER content_version_booking_links_update`,
+    contentVersionTriggers('booking_links', [...CONTENT_VERSION_COLUMNS.booking_links, 'translations'])[2],
+  ] },
+  // copies of confirmed room bookings in Google (lib/calendar/google/bookings.ts):
+  // their pairs, and triggers on bookings and booking links feeding gcal_queue.
+  // Not public, so no cache trigger.
+  GCAL_BOOKINGS_MIGRATION,
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.
@@ -756,6 +767,7 @@ export const CURRENT_CONTENT_VERSION_COLUMNS = {
   settings: [...CONTENT_VERSION_COLUMNS.settings, 'links_verified', 'links_avatar_shape', 'links_avatar_fit', 'links_avatar_scale', 'legal'],
   events: [...CONTENT_VERSION_COLUMNS.events, 'cancelled_dates', 'moved_dates', 'segments'],
   resources: [...CONTENT_VERSION_COLUMNS.resources, 'color', 'show_on_events', 'translations'],
+  booking_links: [...CONTENT_VERSION_COLUMNS.booking_links, 'translations'],
   announcements: ANNOUNCEMENT_VISIBLE_COLUMNS,
 };
 

package/src/lib/repo/sql.ts

@@ -230,10 +230,15 @@ function rowToLink2(r: Row): BookingLink {
     hours: r.hours ? json(r.hours, null) : null, autoConfirm: Boolean(r.auto_confirm), visibility: r.visibility ?? 'public',
     approval: r.approval ?? 'default', approvalRules: json(r.approval_rules, {}),
     askPhone: Boolean(r.ask_phone), questions: json(r.questions, []), confirmMessage: r.confirm_message ?? '',
-    redirectUrl: r.redirect_url ?? '', active: Boolean(r.active), order: Number(r.ord ?? 0),
+    redirectUrl: r.redirect_url ?? '', active: Boolean(r.active), order: Number(r.ord ?? 0), translations: linkTranslations(r.translations),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
 }
+// a booking link's words in other languages; a bad entry (or a broken column) reads as untranslated
+function linkTranslations(raw: unknown): BookingLink['translations'] {
+  const parsed = BookingLink.shape.translations.safeParse(json(raw, {}));
+  return parsed.success ? parsed.data : {};
+}
 function rowToBooking(r: Row): Booking {
   return Booking.parse({
     id: r.id, kind: r.kind ?? 'booking', resourceId: r.resource_id ?? '', linkId: r.link_id ?? '', eventId: r.event_id ?? '',
@@ -1175,11 +1180,11 @@ export class SqlRepository implements ContentRepository {
     return {
       sql: `INSERT INTO booking_links (id, resource_id, slug, name, description, mode, duration, lengths, min_days, max_days, step, buffer_before,
         buffer_after, min_notice, max_advance, per_day_cap, hours, auto_confirm, visibility, ask_phone, questions, confirm_message, redirect_url,
-        active, ord, created_at, updated_at, approval, approval_rules, change_cutoff) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        active, ord, created_at, updated_at, approval, approval_rules, change_cutoff, translations) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [l.id, l.resourceId, l.slug, l.name, l.description, l.mode, l.duration, JSON.stringify(l.lengths), l.minDays, l.maxDays, l.step,
         l.bufferBefore, l.bufferAfter, l.minNotice, l.maxAdvance, l.perDayCap, l.hours ? JSON.stringify(l.hours) : null, l.autoConfirm ? 1 : 0,
         l.visibility, l.askPhone ? 1 : 0, JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.createdAt, l.updatedAt,
-        l.approval, JSON.stringify(l.approvalRules), l.changeCutoff],
+        l.approval, JSON.stringify(l.approvalRules), l.changeCutoff, JSON.stringify(l.translations)],
     };
   }
   private bookingInsert(b: Booking): SqlStatement {
@@ -1271,10 +1276,10 @@ export class SqlRepository implements ContentRepository {
     await this.driver.run(
       `UPDATE booking_links SET slug = ?, name = ?, description = ?, mode = ?, duration = ?, lengths = ?, min_days = ?, max_days = ?, step = ?,
         buffer_before = ?, buffer_after = ?, min_notice = ?, max_advance = ?, per_day_cap = ?, hours = ?, auto_confirm = ?, visibility = ?,
-        ask_phone = ?, questions = ?, confirm_message = ?, redirect_url = ?, active = ?, ord = ?, updated_at = ?, approval = ?, approval_rules = ?, change_cutoff = ? WHERE id = ?`,
+        ask_phone = ?, questions = ?, confirm_message = ?, redirect_url = ?, active = ?, ord = ?, updated_at = ?, approval = ?, approval_rules = ?, change_cutoff = ?, translations = ? WHERE id = ?`,
       [l.slug, l.name, l.description, l.mode, l.duration, JSON.stringify(l.lengths), l.minDays, l.maxDays, l.step, l.bufferBefore, l.bufferAfter,
         l.minNotice, l.maxAdvance, l.perDayCap, l.hours ? JSON.stringify(l.hours) : null, l.autoConfirm ? 1 : 0, l.visibility, l.askPhone ? 1 : 0,
-        JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.updatedAt, l.approval, JSON.stringify(l.approvalRules), l.changeCutoff, id]
+        JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.updatedAt, l.approval, JSON.stringify(l.approvalRules), l.changeCutoff, JSON.stringify(l.translations), id]
     );
   }
   async deleteBookingLink(id: string) {

package/src/lib/schema.ts

@@ -584,6 +584,15 @@ export const DateOverride = z.object({
 });
 export type DateOverride = z.infer<typeof DateOverride>;
 
+// a language a room or booking link has its own words in ('es', 'es-MX')
+const LocaleKey = z.string().regex(/^[a-z]{2,3}(-[a-z0-9]{2,8})?$/);
+// an entry for `locale` ('es-MX' → 'es' when it has no entry of its own)
+const forLocale = <T>(all: Record<string, T> | undefined, locale?: string | null): T | undefined => {
+  if (!locale || !all) return undefined;
+  const want = locale.toLowerCase();
+  return all[want] ?? all[want.split('-')[0]];
+};
+
 export const Resource = z.object({
   id: z.string(),
   slug: z.string(),
@@ -614,7 +623,7 @@ export const Resource = z.object({
   requestable: z.boolean().default(false),
   // its name in the site's other languages ({ es: { name: 'Salón de jóvenes' } });
   // roomName() picks one, else `name`. The slug stays the same in every language.
-  translations: z.record(z.string().regex(/^[a-z]{2,3}(-[a-z0-9]{2,8})?$/), z.object({ name: z.string().max(120).default('') })).default({}),
+  translations: z.record(LocaleKey, z.object({ name: z.string().max(120).default('') })).default({}),
   // secret for the staff feed /book/<slug>.ics?t=… (bookings with names)
   feedToken: z.string().default(''),
   // the saved place this room is in ('' = none)
@@ -628,10 +637,7 @@ export type Resource = z.infer<typeof Resource>;
 export const roomColor = (r: Pick<Resource, 'color'>) => (/^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : '');
 /** A room's name in `locale` ('es', 'es-MX' → its 'es' name), else its main name. */
 export function roomName(r: Pick<Resource, 'name'> & { translations?: Resource['translations'] }, locale?: string | null): string {
-  if (!locale || !r.translations) return r.name;
-  const want = locale.toLowerCase();
-  const t = r.translations[want] ?? r.translations[want.split('-')[0]];
-  return t?.name.trim() || r.name;
+  return forLocale(r.translations, locale)?.name.trim() || r.name;
 }
 
 // A saved place (HQ, the park pavilion…): picked in an event's Where field,
@@ -804,11 +810,19 @@ export const BookingLink = z.object({
   confirmMessage: z.string().default(''),
   redirectUrl: z.string().default(''),
   active: z.boolean().default(true),
+  // its name and description in the site's other languages ({ es: { name: 'Ensayo' } });
+  // linkWords() picks them, each falling back to the main one. The slug stays the same.
+  translations: z.record(LocaleKey, z.object({ name: z.string().max(120).default(''), description: z.string().max(2000).default('') })).default({}),
   order: z.number().default(0),
   createdAt: z.number(),
   updatedAt: z.number(),
 });
 export type BookingLink = z.infer<typeof BookingLink>;
+/** A booking link's name and description in `locale` ('es-MX' → its 'es' words), each falling back to the main one. */
+export function linkWords(l: Pick<BookingLink, 'name' | 'description'> & { translations?: BookingLink['translations'] }, locale?: string | null): { name: string; description: string } {
+  const t = forLocale(l.translations, locale);
+  return { name: t?.name.trim() || l.name, description: t?.description.trim() || l.description };
+}
 
 // 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

package/src/lib/sections.ts

@@ -1,7 +1,7 @@
 import sanitizeHtml from 'sanitize-html';
 import type { z } from 'zod';
 import type { ContentRepository } from './repo/types';
-import { authorSlug, tagFilter, type Settings, type User } from './schema';
+import { authorSlug, linkWords, roomName, tagFilter, type Settings, type User } from './schema';
 import { htmlToPlaintext } from './plaintext';
 import type { SectionInstance as SectionInstanceSchema, SectionDefinition } from '../theme-sdk/contract.mjs';
 import { normalizeData, safeUrl, SOURCE_LIMIT_MAX, isEmptyValue, safeFocus, focusKey } from '../theme-sdk/fields.mjs';
@@ -165,7 +165,9 @@ async function resolveSource(field: Extract<FieldDef, { type: 'source' }>, value
   const links = (await repo.listBookingLinks()).filter((l) => l.active && l.visibility === 'public' && byId.has(l.resourceId));
   return links.slice(0, limit).map((l): BookingItem => {
     const r = byId.get(l.resourceId)!;
-    return { title: l.name, url: bookingLinkUrl(r.slug, l.slug), description: l.description, resource: r.name, minutes: l.duration };
+    // the link and room in the page's language (their main words without one)
+    const words = linkWords(l, lang);
+    return { title: words.name, url: lp(bookingLinkUrl(r.slug, l.slug)), description: words.description, resource: roomName(r, lang), minutes: l.duration };
   });
 }
 

package/src/pages/admin/calendar/resources/link.astro

@@ -11,6 +11,7 @@ import { siteOrigin } from '../../../../lib/seo';
 import { APPROVAL_LABEL, linkApproval, siteApproval } from '../../../../lib/booking/approval';
 import { ApprovalRules } from '../../../../lib/schema';
 import { forbiddenUnless } from '../../../../lib/permissions/access';
+import { extraLocales, localeName } from '../../../../lib/i18n';
 
 // One booking link: how people book, how bookings get approved (follow the
 // site setting, or its own mode + rules), when it's open (within the room or
@@ -69,8 +70,14 @@ if (Astro.request.method === 'POST') {
     deadlineHours: form.has('deadline') ? int(form.get('deadlineHours'), 1, 24 * 60, 48) : 0,
     deadlineAction: form.get('deadlineAction') === 'decline' ? 'decline' : 'approve',
   });
+  // its name and description in each of the site's other languages ('' = the main one); languages no longer configured keep theirs
+  const translations = { ...link.translations };
+  for (const l of extraLocales()) {
+    const words = { name: String(form.get('name_' + l) || '').trim().slice(0, 120), description: String(form.get('description_' + l) || '').trim().slice(0, 1000) };
+    if (words.name || words.description) translations[l] = words; else delete translations[l];
+  }
   const patch: Partial<BookingLink> = {
-    name, slug, mode: mode as BookingMode,
+    name, slug, mode: mode as BookingMode, translations,
     description: String(form.get('description') || '').slice(0, 1000),
     duration,
     lengths,
@@ -221,8 +228,14 @@ const effective = linkApproval(view, settings).mode;
       <section class="card card-pad">
         <div class="card-head"><b>Link</b></div>
         <label class="field"><span>Name</span><input type="text" name="name" value={view.name} required /></label>
+        {extraLocales().map((l) => (
+          <label class="field"><span>Name in {localeName(l)} <em class="hint">optional; shown on {localeName(l)} pages, in the app and in emails</em></span><input type="text" name={'name_' + l} lang={l} maxlength="120" value={view.translations[l]?.name ?? ''} placeholder={view.name} /></label>
+        ))}
         <label class="field"><span>URL name</span><input type="text" class="mono" name="slug" value={view.slug} /></label>
         <label class="field"><span>Description</span><textarea name="description" rows="3" placeholder="What this booking is for">{view.description}</textarea></label>
+        {extraLocales().map((l) => (
+          <label class="field"><span>Description in {localeName(l)} <em class="hint">optional</em></span><textarea name={'description_' + l} lang={l} rows="3" maxlength="1000" placeholder={view.description}>{view.translations[l]?.description ?? ''}</textarea></label>
+        ))}
         <label class="field">
           <span>Who can find it</span>
           <select name="visibility">

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

@@ -7,11 +7,13 @@ import { availabilityContext, createResourceBooking, guestMoveLink, guestResched
 import { siteOrigin } from '../../../lib/seo';
 import { waitUntilFrom } from '../../../lib/webhooks';
 import { localePath, requestLocale } from '../../../lib/i18n';
+import { linkWords, roomName } from '../../../lib/schema';
 
 // One booking link: pick → answer → done. POSTs create the booking (or move
 // 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.
+// in English, but the link and room are named in the page's language (their
+// translations), every step stays under /es/…, and a booking made there 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 ?? '');
@@ -64,11 +66,14 @@ if (Astro.request.method === 'POST') {
   }
 }
 const ctx = await availabilityContext(repo, resource, reschedule ? guestMoveLink(link) : link, settings, Date.now(), reschedule?.id);
+// the link and room named in the page's language
+const words = linkWords(link, locale);
+const room = roomName(resource, locale);
 ---
 
-<Site title={`${link.name} · ${resource.name}`} description={link.description || `Book ${resource.name}.`} noindex={link.visibility === 'unlisted' || resource.visibility === 'unlisted'}>
+<Site title={`${words.name} · ${room}`} description={words.description || `Book ${room}.`} noindex={link.visibility === 'unlisted' || resource.visibility === 'unlisted'}>
   <div class="pc-bkpage">
-    <BookingFlow resource={resource} link={link} ctx={ctx} settings={settings} url={flowUrl} error={error} values={values} reschedule={reschedule} />
-    <p class="pc-bk-foot"><a href={resourceUrl(resource.slug)}>Other ways to book {resource.name}</a></p>
+    <BookingFlow resource={resource} link={link} ctx={ctx} settings={settings} url={flowUrl} error={error} values={values} reschedule={reschedule} locale={locale} />
+    <p class="pc-bk-foot"><a href={localePath(resourceUrl(resource.slug), locale)}>Other ways to book {room}</a></p>
   </div>
 </Site>

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

@@ -5,6 +5,8 @@ import { bookingLinkUrl, bookingsEnabled, CALENDAR } from '../../../lib/calendar
 import { availabilityContext } from '../../../lib/booking/service';
 import { describeLink, nextOpenings } from '../../../lib/booking/availability';
 import { fmt } from '../../../lib/booking/view';
+import { linkWords, roomName } from '../../../lib/schema';
+import { localePath, requestLocale } from '../../../lib/i18n';
 
 // A room (or person, or van) and its booking links (mockup C): each link is a
 // card with its rules, an Instant / Approval badge, and its next openings —
@@ -30,34 +32,38 @@ const chip = (start: number, link: (typeof links)[number]) => {
   return link.mode === 'slots' ? `${day} ${f.time.format(start)}` : day;
 };
 const facts = [resource.capacity ? `Up to ${resource.capacity}` : '', ...resource.amenities].filter(Boolean);
+// the room and its links named in the page's language, and links that stay in it
+const locale = requestLocale(Astro.url, Astro.locals);
+const room = roomName(resource, locale);
+const here = (path: string) => localePath(path, locale);
 ---
 
-<Site title={resource.name} description={resource.description || `Book ${resource.name}.`} image={resource.photo || undefined} noindex={resource.visibility === 'unlisted'}>
+<Site title={room} description={resource.description || `Book ${room}.`} image={resource.photo || undefined} noindex={resource.visibility === 'unlisted'}>
   <div class="pc-res">
     <div class="pc-res-about">
       {resource.photo ? <img class="pc-res-photo" src={resource.photo} alt="" /> : null}
       <span class="pc-res-kind">{resource.kind}</span>
-      <h1 class="pc-res-title">{resource.name}</h1>
+      <h1 class="pc-res-title">{room}</h1>
       {facts.length > 0 && <ul class="pc-res-facts">{facts.map((x) => <li>{x}</li>)}</ul>}
       {resource.description && <p class="pc-res-desc">{resource.description}</p>}
     </div>
     <div class="pc-res-links">
-      {cards.length === 0 && <p class="pc-bk-empty">Online booking isn’t open for {resource.name} right now.</p>}
+      {cards.length === 0 && <p class="pc-bk-empty">Online booking isn’t open for {room} right now.</p>}
       {cards.map(({ link, next }) => (
         <article class="pc-res-link">
           <div class="pc-res-linkhead">
-            <h2><a href={bookingLinkUrl(resource.slug, link.slug)}>{link.name}</a></h2>
+            <h2><a href={here(bookingLinkUrl(resource.slug, link.slug))}>{linkWords(link, locale).name}</a></h2>
             <span class={`pc-res-badge${link.autoConfirm ? ' is-instant' : ''}`}>{link.autoConfirm ? 'Instant' : 'Approval'}</span>
           </div>
-          <p>{[describeLink(link), link.description].filter(Boolean).join(' · ')}</p>
+          <p>{[describeLink(link), linkWords(link, locale).description].filter(Boolean).join(' · ')}</p>
           <div class="pc-res-next">
-            {next.map((s) => <a href={`${bookingLinkUrl(resource.slug, link.slug)}?date=${new Intl.DateTimeFormat('en-CA', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit' }).format(s.start)}&start=${s.start}&len=${s.minutes}`}>{chip(s.start, link)}</a>)}
+            {next.map((s) => <a href={`${here(bookingLinkUrl(resource.slug, link.slug))}?date=${new Intl.DateTimeFormat('en-CA', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit' }).format(s.start)}&start=${s.start}&len=${s.minutes}`}>{chip(s.start, link)}</a>)}
             {next.length === 0 && <span class="pc-res-none">No openings soon</span>}
-            <a class="pc-res-more" href={bookingLinkUrl(resource.slug, link.slug)}>{next.length ? 'More times ›' : 'See calendar ›'}</a>
+            <a class="pc-res-more" href={here(bookingLinkUrl(resource.slug, link.slug))}>{next.length ? 'More times ›' : 'See calendar ›'}</a>
           </div>
         </article>
       ))}
-      <p class="pc-bk-foot"><a href={CALENDAR.bookBase}>All rooms and people</a></p>
+      <p class="pc-bk-foot"><a href={here(CALENDAR.bookBase)}>All rooms and people</a></p>
     </div>
   </div>
 </Site>

package/src/pages/book/index.astro

@@ -2,6 +2,8 @@
 import Site from '../../layouts/Site.astro';
 import { getRepo } from '../../lib/repo';
 import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl } from '../../lib/calendar/config';
+import { linkWords, roomName } from '../../lib/schema';
+import { localePath, requestLocale } from '../../lib/i18n';
 
 // Directory of everything bookable: public resources grouped by kind, each
 // with its public booking links.
@@ -13,6 +15,9 @@ const byKind = new Map<string, typeof listed>();
 for (const r of listed) byKind.set(r.kind, [...(byKind.get(r.kind) ?? []), r]);
 const linksOf = (id: string) => links.filter((l) => l.resourceId === id && l.active && l.visibility === 'public');
 const plural = (k: string) => (k.endsWith('s') ? k : k.endsWith('y') ? `${k.slice(0, -1)}ies` : `${k}s`);
+// rooms and links named in the page's language, and links that stay in it
+const locale = requestLocale(Astro.url, Astro.locals);
+const here = (path: string) => localePath(path, locale);
 ---
 
 <Site title="Book" description={`Book rooms and time at ${settings.siteTitle}.`}>
@@ -32,11 +37,11 @@ const plural = (k: string) => (k.endsWith('s') ? k : k.endsWith('y') ? `${k.slic
         <div class="pc-dir-grid">
           {list.map((r) => (
             <article class="pc-dir-card">
-              <a class="pc-dir-media" href={resourceUrl(r.slug)} tabindex="-1" aria-hidden="true">{r.photo ? <img src={r.photo} alt="" loading="lazy" /> : <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M3 21V9l9-5 9 5v12M9 21v-6h6v6" /></svg>}</a>
+              <a class="pc-dir-media" href={here(resourceUrl(r.slug))} tabindex="-1" aria-hidden="true">{r.photo ? <img src={r.photo} alt="" loading="lazy" /> : <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M3 21V9l9-5 9 5v12M9 21v-6h6v6" /></svg>}</a>
               <div class="pc-dir-body">
-                <h3><a href={resourceUrl(r.slug)}>{r.name}</a></h3>
+                <h3><a href={here(resourceUrl(r.slug))}>{roomName(r, locale)}</a></h3>
                 <p>{[r.capacity ? `Up to ${r.capacity}` : '', ...r.amenities.slice(0, 3)].filter(Boolean).join(' · ')}</p>
-                <div class="pc-dir-links">{linksOf(r.id).map((l) => <a href={bookingLinkUrl(r.slug, l.slug)}>{l.name}</a>)}</div>
+                <div class="pc-dir-links">{linksOf(r.id).map((l) => <a href={here(bookingLinkUrl(r.slug, l.slug))}>{linkWords(l, locale).name}</a>)}</div>
               </div>
             </article>
           ))}

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

@@ -5,6 +5,8 @@ import { CALENDAR, bookingLinkUrl, bookingsEnabled, eventUrl, resourceUrl } from
 import { confirmOffer, guestCancel, guestChanges, waitlistPosition, BookingError, WAITLIST_HOLD } from '../../../lib/booking/service';
 import { bookingIcs, whenText } from '../../../lib/booking/emails';
 import { resourceZone } from '../../../lib/booking/availability';
+import { bookingTitle } from '../../../lib/booking/view';
+import { roomName } from '../../../lib/schema';
 import { eventTimeZone, locationLine } from '../../../lib/calendar/events';
 import { siteOrigin } from '../../../lib/seo';
 import { waitUntilFrom } from '../../../lib/webhooks';
@@ -43,8 +45,8 @@ const lang = locale || siteLang(settings);
 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 title = event ? event.title : bookingTitle(resource, link, locale) || bw.untitled;
+const location = event ? locationLine(event.location) : resource ? roomName(resource, locale) : '';
 // the address the visitor sees (/es/… is rewritten to this route)
 const url = origin + localePath(Astro.url.pathname, locale);
 
@@ -166,7 +168,7 @@ const googleUrl = `https://calendar.google.com/calendar/render?${new URLSearchPa
     )}
     {can.closed && <p class="pc-manage-note">{cutoff}</p>}
     <p class="pc-bk-foot">
-      {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}
+      {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: roomName(resource, locale) })}</a> : null}
     </p>
     <p class="pc-manage-note">{w.keepLink}</p>
   </div>

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

@@ -4,25 +4,33 @@ import BookingFlow from '../../../../components/booking/BookingFlow.astro';
 import { getRepo } from '../../../../lib/repo';
 import { bookingLinkUrl, bookingsEnabled } from '../../../../lib/calendar/config';
 import { availabilityContext } from '../../../../lib/booking/service';
+import { I18N, localePath } from '../../../../lib/i18n';
+import { linkWords } from '../../../../lib/schema';
 
 // Embeddable picker for other sites: day + time selection happens inside the
 // iframe; choosing a time opens the full booking page (top window) to finish.
+// ?lang=es (one of the site's languages; embeds are never under /es) names the
+// link and room in it and hands off to that language's page.
 if (!bookingsEnabled()) return new Response(null, { status: 404 });
 const repo = await getRepo(Astro.locals);
 const resource = await repo.getResourceBySlug(Astro.params.resource ?? '');
 const link = resource ? await repo.getBookingLinkBySlug(resource.id, Astro.params.link ?? '') : null;
 if (!resource || !link || !link.active) return new Response(null, { status: 404 });
 const settings = await repo.getSettings();
+const langParam = Astro.url.searchParams.get('lang') ?? '';
+const locale = I18N.enabled && I18N.locales.includes(langParam) ? langParam : '';
 // a chosen time hands off to the real page, where the form lives
 if (Astro.url.searchParams.get('start')) {
-  return Astro.redirect(`${bookingLinkUrl(resource.slug, link.slug)}${Astro.url.search}`);
+  const search = new URLSearchParams(Astro.url.search);
+  search.delete('lang');
+  return Astro.redirect(`${localePath(bookingLinkUrl(resource.slug, link.slug), locale)}?${search}`);
 }
 const ctx = await availabilityContext(repo, resource, link, settings);
 Astro.response.headers.set('Content-Security-Policy', 'frame-ancestors *');
 ---
 
-<Site title={link.name} bare noindex>
-  <BookingFlow resource={resource} link={link} ctx={ctx} settings={settings} url={Astro.url} embed />
+<Site title={linkWords(link, locale).name} bare noindex>
+  <BookingFlow resource={resource} link={link} ctx={ctx} settings={settings} url={Astro.url} embed locale={locale} />
   <script is:inline>
     (function () {
       var send = function () { parent.postMessage({ acmsBookingEmbed: true, height: document.documentElement.scrollHeight }, '*'); };