@acms-subir/core 0.3.62 → 0.3.63

package/src/lib/booking/service.ts

@@ -6,6 +6,7 @@ import { collectResponse, displayAnswers, staffAnswers } from '../forms/service'
 import type { ContentRepository } from '../repo/types';
 import type { Booking, BookingLink, BookingStatus, CalEvent, Resource, Settings } from '../schema';
 import { roomName } from '../schema';
+import { bookingTitle } from './view';
 import { loadFeed, expandVEvents } from '../calendar/ics';
 import { emitWebhook } from '../webhooks';
 import { parseFrom } from '../email/config';
@@ -109,8 +110,8 @@ async function describe(repo: ContentRepository, b: Booking, settings: Settings,
   const tz = resource ? resourceZone(resource, settings.timezone) : settings.timezone || 'UTC';
   return {
     resource, link, event: null as CalEvent | null, tz,
-    // the room in the booking's language (its main name without one)
-    title: [resource && roomName(resource, locale), link?.name].filter(Boolean).join(' · ') || 'Booking',
+    // the room and its booking link in the booking's language (their main names without one)
+    title: bookingTitle(resource, link, locale) || 'Booking',
     location: resource ? roomName(resource, locale) : '',
     when: whenText(b, tz, settings, link?.mode === 'day'),
   };
@@ -304,8 +305,11 @@ export async function createResourceBooking(
   const ctx = await availabilityContext(repo, resource, link, settings, opts.now ?? Date.now());
   if (args.source !== 'admin' && !isBookable(ctx, args.start, args.end)) throw new BookingError(409, 'That time was just taken or isn’t available. Please pick another.');
   const approval = linkApproval(link, settings);
+  // "the first booking from that email": only a confirmed booking (staff approved it, or it
+  // confirmed by itself) makes them returning; one still waiting, declined or cancelled doesn't.
+  // The address is all a booking without an account has to go on.
   const returning = approval.mode === 'rules' && approval.rules.firstTime
-    ? (await repo.listBookings({ email: booker.email, statuses: ['pending', 'confirmed'], kinds: ['booking'] })).length > 0
+    ? (await repo.listBookings({ email: booker.email, statuses: ['confirmed'], kinds: ['booking'], limit: 1 })).length > 0
     : true;
   const status: BookingStatus = args.status ?? decideStatus(approval, { start: args.start, end: args.end, seats: 1, returning });
   const b = await repo.createBooking({

package/src/lib/booking/view.ts

@@ -1,5 +1,6 @@
 // Display helpers for the public booking pages.
 import type { BookingLink, Resource, Settings } from '../schema';
+import { linkWords, roomName } from '../schema';
 import { siteLocale } from '../dates';
 import { addDaysYmd, localMidnight, resourceZone, ymd, type Slot } from './availability';
 
@@ -52,3 +53,8 @@ export function todayIn(resource: Resource, settings: Settings, now: number) {
   const tz = resourceZone(resource, settings.timezone);
   return { tz, today: ymd(now, tz), midnight: localMidnight(ymd(now, tz), tz) };
 }
+
+/** "Sanctuary · Rehearsal": the room and booking link in `locale` (each its main name without one); '' when both are gone. */
+export function bookingTitle(resource: Resource | null | undefined, link: BookingLink | null | undefined, locale?: string | null): string {
+  return [resource && roomName(resource, locale), link && linkWords(link, locale).name].filter(Boolean).join(' · ');
+}

package/src/lib/calendar/data.ts

@@ -7,7 +7,8 @@
 // details, lib/display: published events only, private calendars when it
 // names them, bookings with the booker's name, never emails, phones or notes).
 import type { ContentRepository } from '../repo/types';
-import { roomColor, roomName, type BookingLink, type CalEvent, type Calendar, type EventLocation, type Resource, type Settings } from '../schema';
+import { linkWords, roomColor, roomName, type CalEvent, type Calendar, type EventLocation, type Resource, type Settings } from '../schema';
+import { bookingAllDay, publicBookingTitle, scheduleBookings } from '../booking/public';
 import { eventIsListed, eventIsPublic, eventRoomIds, expandEvents, locationLine, safeColor, type OccurrenceMove } from './events';
 import { expandVEvents, loadFeed, tzParts, type CalendarEvent, type CalendarWindow } from './ics';
 import { CALENDAR, eventUrl, resourceUrl, withoutPrivateFields } from './config';
@@ -48,13 +49,14 @@ export interface ViewScope {
   includeUncategorized?: boolean;
   // feeds are network calls — views that don't need them can skip
   includeFeeds?: boolean;
-  // "Reserved" blocks from resources set to show on the calendar
+  // confirmed bookings of rooms set to show on the calendar (named by their
+  // booking link; with the booker's name for staff and private screens)
   includeBookings?: boolean;
   // the address's cal/tag/notag/room (filter.ts); its calendars narrow
   // calendarIds when both are given
   filter?: ResolvedEventFilter;
-  // the request's language (requestLocale): translated titles, event links
-  // under its /<locale> prefix, and "Reserved" in its words
+  // the request's language (requestLocale): translated titles, room and
+  // booking link names, event links under its /<locale> prefix
   locale?: string;
 }
 
@@ -158,36 +160,28 @@ export async function collectViewEvents(
     events.push(...results.flat());
   }
 
-  // resources marked "show on calendar": confirmed bookings appear as
-  // Reserved blocks (no guest names on public views) — only on unscoped views.
-  // A screen also shows the bookings of the rooms it names, as "<booking
-  // type> · <booker>" (the name only: never their email, phone or notes).
+  // rooms marked "show on calendar": their confirmed bookings appear named by
+  // their booking link in the view's language ("Rehearsal", "Ensayo"; "Reserved"
+  // when the link is gone), never who booked, on views that name no calendar
+  // (a booking belongs to none): unfiltered, or by room (each in its own room),
+  // never with a tag. A screen also shows the bookings of the rooms it names, as
+  // "<booking link> · <booker>" (the name only: never their email, phone or notes).
   if (!requested && (scope.includeBookings ?? true) && CALENDAR.bookings) {
     const named = scope.audience === 'screen' ? f?.roomIds ?? [] : [];
     const resources = (await repo.listResources()).filter((r) => (r.showOnCalendar || named.includes(r.id)) && (!f || untaggedMatches(f, { roomId: r.id })));
-    if (resources.length) {
-      const [booked, links] = await Promise.all([
-        repo.listBookings({ from: win.windowStartMs, to: win.windowEndMs, statuses: ['confirmed'], kinds: ['booking'] }),
-        scope.audience === 'screen' ? repo.listBookingLinks() : Promise.resolve([] as BookingLink[]),
-      ]);
-      const byId = new Map(resources.map((r) => [r.id, r]));
-      const linkName = new Map(links.map((l): [string, string] => [l.id, l.name]));
-      for (const b of booked) {
-        const r = byId.get(b.resourceId);
-        if (!r) continue;
-        const allDay = b.end - b.start >= 86_400_000 - 3_600_000;
-        // the room in the view's language (its main name without one)
-        const room = roomName(r, scope.locale);
-        const title = scope.audience === 'admin' ? `${r.name} · ${b.name}`
-          : scope.audience === 'screen' ? [linkName.get(b.linkId) || room, b.name].filter(Boolean).join(' · ')
-          : `${words.reserved} · ${room}`;
-        events.push({
-          start: b.start, end: b.end, allDay, days: allDay ? Math.max(1, Math.round((b.end - b.start) / 86_400_000)) : 1,
-          title, location: room, description: '', cal: inScope.length, color: '#8e919a', calendarName: room,
-          url: scope.audience === 'public' ? resourceUrl(r.slug) : undefined,
-          rooms: [{ id: r.id, slug: r.slug, name: room, color: roomColor(r) }],
-        });
-      }
+    for (const { booking: b, resource: r, link } of await scheduleBookings(repo, resources, win.windowStartMs, win.windowEndMs)) {
+      const allDay = bookingAllDay(b, link);
+      // the room and link in the view's language (their main names without one)
+      const room = roomName(r, scope.locale);
+      const title = scope.audience === 'admin' ? `${r.name} · ${b.name}`
+        : scope.audience === 'screen' ? [link ? linkWords(link, scope.locale).name : room, b.name].filter(Boolean).join(' · ')
+        : publicBookingTitle(link, scope.locale, words.reserved);
+      events.push({
+        start: b.start, end: b.end, allDay, days: allDay ? Math.max(1, Math.round((b.end - b.start) / 86_400_000)) : 1,
+        title, location: room, description: '', cal: inScope.length, color: '#8e919a', calendarName: room,
+        url: scope.audience === 'public' ? localePath(resourceUrl(r.slug), scope.locale ?? '') : undefined,
+        rooms: [{ id: r.id, slug: r.slug, name: room, color: roomColor(r) }],
+      });
     }
   }
 

package/src/lib/display/board.ts

@@ -1,7 +1,9 @@
 // One TV board, ready to render: which days it covers, which events it may
 // show, and when it goes stale. Quick links (/display/calendar?…) and saved
 // screens without private details show what calendar.ics shows: published
-// events in public calendars (or an unlisted one named in cal=). A saved
+// events in public calendars (or an unlisted one named in cal=), plus, as
+// /calendar shows them, the bookings of rooms set to show on the calendar,
+// named by their booking link (never who booked). A saved
 // screen with private details on also shows private calendars it names, the
 // bookings of its rooms with the booker's name, the rooms and hosts of every
 // event. Never emails, phone numbers, notes or RSVP lists.
@@ -108,9 +110,9 @@ export async function loadDisplayBoard(repo: ContentRepository, site: Settings,
   const { events, calendars: shownCalendars } = await collectViewEvents(repo, site, win, {
     audience: req.privateDetails ? 'screen' : 'public',
     filter,
-    // quick links show what calendar.ics shows: no subscribed feeds, no bookings
+    // quick links show what calendar.ics shows (no subscribed feeds), and
+    // bookings as /calendar shows them: named by their link, never who booked
     includeFeeds: req.privateDetails,
-    includeBookings: req.privateDetails,
     // translated titles in the display's language
     locale: lang,
   });

package/src/lib/editor/schedule.ts

@@ -263,6 +263,8 @@ export const LinkInput = z.object({
   confirmMessage: z.string().max(1000).optional(), redirectUrl: z.string().max(1000).refine((v) => !v || /^https?:\/\//.test(v), 'Use an http(s) URL.').optional(),
   active: z.boolean().optional(),
   changeCutoff: z.number().int().min(0).max(8760).optional(),
+  // its name and description in the site's other languages: { es: { name: 'Ensayo' } } ('' = the main one)
+  translations: z.record(z.string().regex(/^[a-z]{2,3}(-[a-z0-9]{2,8})?$/), z.object({ name: z.string().trim().max(120).default(''), description: z.string().max(2000).default('') })).optional(),
 }).strict();
 export const LinkPatch = LinkInput.partial();
 

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

@@ -748,6 +748,13 @@ 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],
+  ] },
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.
@@ -756,6 +763,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>