@acms-subir/core 0.3.61 → 0.3.63

package/src/components/booking/BookingFlow.astro

@@ -4,7 +4,9 @@
 // is a plain link or form (?date=…&len=…&start=…), so it works without
 // JavaScript and each state is shareable. Used by the page and the embed.
 import type { Booking, BookingLink, Resource, Settings } from '../../lib/schema';
+import { linkWords, roomName } from '../../lib/schema';
 import { bookingLinkUrl, resourceUrl } from '../../lib/calendar/config';
+import { localePath } from '../../lib/i18n';
 import { describeLength, describeLink, linkLengths, openDays, slotsForDay, ymd, type AvailabilityContext } from '../../lib/booking/availability';
 import { addMonths, fmt, monthCells, slotLabel } from '../../lib/booking/view';
 import { confirmsInstantly, linkApproval } from '../../lib/booking/approval';
@@ -19,8 +21,13 @@ interface Props {
   values?: Record<string, string>;
   embed?: boolean;
   reschedule?: Booking | null;
+  /** the page's language: the link and room are named in it, and links stay in it ('' = the main one) */
+  locale?: string;
 }
-const { resource, link, ctx, settings, url, error = '', values = {}, embed = false, reschedule = null } = Astro.props;
+const { resource, link, ctx, settings, url, error = '', values = {}, embed = false, reschedule = null, locale = '' } = Astro.props;
+// the booking link and room in the page's language (the rest of the flow is in English)
+const words = linkWords(link, locale);
+const room = roomName(resource, locale);
 const tz = ctx.resource.timezone || settings.timezone || 'UTC';
 // "rules" links usually confirm at once, but may not — promise only what's certain
 const instant = confirmsInstantly(linkApproval(link, settings));
@@ -42,10 +49,11 @@ const startParam = Number(url.searchParams.get('start'));
 const chosen = slots.find((s) => s.start === startParam && (link.mode !== 'day' || s.minutes === Number(url.searchParams.get('len') || s.minutes)));
 const minMonth = today.slice(0, 7);
 const maxMonth = ymd(ctx.now + link.maxAdvance * 86_400_000, tz).slice(0, 7);
-const base = embed ? `/embed/book/${resource.slug}/${link.slug}` : bookingLinkUrl(resource.slug, link.slug);
+const base = embed ? `/embed/book/${resource.slug}/${link.slug}` : localePath(bookingLinkUrl(resource.slug, link.slug), locale);
 const q = (patch: Record<string, string | number | undefined>) => {
   const p = new URLSearchParams();
-  for (const k of ['len', 'm', 'date', 'start', 'reschedule']) {
+  // an embed keeps its ?lang= (embeds are never under /es)
+  for (const k of ['len', 'm', 'date', 'start', 'reschedule', ...(embed ? ['lang'] : [])]) {
     const v = k in patch ? patch[k] : url.searchParams.get(k) ?? undefined;
     if (v !== undefined && v !== '' && v !== null) p.set(k, String(v));
   }
@@ -62,10 +70,10 @@ const val = (k: string) => values[k] ?? '';
 
 <div class={`pc-bk${embed ? ' is-embed' : ''}`}>
   <aside class="pc-bk-info">
-    {!embed && <a class="pc-bk-back" href={resourceUrl(resource.slug)}>‹ {resource.name}</a>}
-    {embed && <span class="pc-bk-kicker">{resource.name}</span>}
-    <h1 class="pc-bk-title">{link.name}</h1>
-    {link.description && <p class="pc-bk-desc">{link.description}</p>}
+    {!embed && <a class="pc-bk-back" href={localePath(resourceUrl(resource.slug), locale)}>‹ {room}</a>}
+    {embed && <span class="pc-bk-kicker">{room}</span>}
+    <h1 class="pc-bk-title">{words.name}</h1>
+    {words.description && <p class="pc-bk-desc">{words.description}</p>}
     <ul class="pc-bk-rules">{rules.map((r) => <li>{r}</li>)}</ul>
     {link.mode === 'range' && lengths.length > 1 && (
       <div class="pc-bk-lens" role="group" aria-label="How long">
@@ -111,7 +119,7 @@ const val = (k: string) => values[k] ?? '';
   ) : (
     <section class="pc-bk-form">
       <div class="pc-bk-summary">
-        <b>{resource.name} · {link.name}</b>
+        <b>{room} · {words.name}</b>
         <span>{f.dayLong.format(chosen.start)} · {slotLabel(chosen, link, f)}</span>
         <a href={q({ start: undefined })}>Change</a>
       </div>

package/src/lib/booking/public.ts

@@ -0,0 +1,40 @@
+// Confirmed room bookings as schedule items: /calendar, embeds and TV boards
+// (lib/calendar/data.ts) and the app API's `bookings` (lib/mobile/calendar.ts).
+// Publicly a booking is named by its booking link in the reader's language
+// ("Rehearsal", "Ensayo"; the calendar's "Reserved" when the link is gone)
+// and never says who booked: no name, email, phone, notes, answers or manage
+// token, and not the booking's id (publicBookingKey stands in for it).
+import type { ContentRepository } from '../repo/types';
+import { linkWords, type Booking, type BookingLink, type Resource } from '../schema';
+import { sha256Hex } from '../api-keys';
+
+export interface ScheduleBooking { booking: Booking; resource: Resource; link: BookingLink | null }
+
+/** Confirmed bookings of these rooms overlapping [from, to), with their room and booking link, by start. */
+export async function scheduleBookings(repo: ContentRepository, rooms: Resource[], from: number, to: number, limit = 5000): Promise<ScheduleBooking[]> {
+  if (!rooms.length) return [];
+  const byId = new Map(rooms.map((r) => [r.id, r]));
+  const [booked, links] = await Promise.all([
+    repo.listBookings({ from, to, statuses: ['confirmed'], kinds: ['booking'] }),
+    repo.listBookingLinks(),
+  ]);
+  const linkById = new Map(links.map((l) => [l.id, l]));
+  const out: ScheduleBooking[] = [];
+  for (const b of booked) {
+    const resource = byId.get(b.resourceId);
+    if (resource) out.push({ booking: b, resource, link: linkById.get(b.linkId) ?? null });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+/** Whether a booking reads as all day: its link books whole days (without its link: a day long, give or take a clock change). */
+export const bookingAllDay = (b: Pick<Booking, 'start' | 'end'>, link: Pick<BookingLink, 'mode'> | null) =>
+  link ? link.mode === 'day' : b.end - b.start >= 86_400_000 - 3_600_000;
+
+/** A booking's public title: its link's name in `locale`, else `reserved` (the calendar's word in that language). */
+export const publicBookingTitle = (link: BookingLink | null, locale: string | null | undefined, reserved: string) =>
+  (link && linkWords(link, locale).name) || reserved;
+
+/** A stable key for a booking in public data that doesn't reveal its id. */
+export const publicBookingKey = async (b: Pick<Booking, 'id'>) => `b${(await sha256Hex(`public-booking:${b.id}`)).slice(0, 24)}`;

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/calendar/events.ts

@@ -398,8 +398,8 @@ export function featuredOccurrence(e: CalEvent, settings: Pick<Settings, 'timezo
 
 // ---- visibility ----------------------------------------------------------
 // An event with no calendars counts as public. Otherwise it follows its most
-// open calendar: any public/unlisted calendar makes the event page public;
-// only public calendars put it on the main calendar page and site feed.
+// open calendar: any public/unlisted calendar makes the event page public (and
+// searchable); only public calendars put it on the main calendar page and site feed.
 
 export function eventIsPublic(e: CalEvent, calendars: Map<string, Calendar>): boolean {
   if (e.status !== 'published') return false;
@@ -416,6 +416,16 @@ export function eventIsListed(e: CalEvent, calendars: Map<string, Calendar>): bo
   return e.calendarIds.some((id) => calendars.get(id)?.visibility === 'public');
 }
 
+/** The internal tag on appointments booked through a Google booking page (they come in titled "Booked"). */
+export const BOOKING_TAG = '#google-booking';
+/** A Google booking-page appointment: search never finds it and push never announces it. */
+export const isGoogleBooking = (e: Pick<CalEvent, 'tags'>) => e.tags.some((t) => t.trim().toLowerCase() === BOOKING_TAG);
+
+/** What search finds, on the website and in the app: events with a public page (unlisted calendars too), but no booking-page appointments. */
+export function eventIsSearchable(e: CalEvent, calendars: Map<string, Calendar>): boolean {
+  return eventIsPublic(e, calendars) && !isGoogleBooking(e);
+}
+
 // ---- formatting ----------------------------------------------------------
 
 export function formatOccurrence(

package/src/lib/calendar/google/map.ts

@@ -27,7 +27,7 @@ const DAY = 86_400_000;
 const pad = (n: number) => String(n).padStart(2, '0');
 
 /** The internal tag on booked appointments from Google booking pages (Q16): never shown publicly. */
-export const BOOKING_TAG = '#google-booking';
+export { BOOKING_TAG } from '../events';
 
 /** The few words the sync writes, in the site's main language (Q9). */
 export interface SyncWords { cancelled: string; details: string; link: string; booked: string; untitled: string }

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,10 +1,10 @@
 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';
-import { eventIsListed, eventIsPublic, expandEvents, featuredOccurrence, type Occurrence } from '../calendar/events';
+import { eventIsListed, eventIsPublic, eventIsSearchable, expandEvents, featuredOccurrence, type Occurrence } from '../calendar/events';
 import { availabilityContext } from '../booking/service';
 import { roomBusy } from '../booking/holds';
 import { sha256Hex } from '../api-keys';
@@ -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,7 +42,8 @@ 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).'),
-  q: z.string().max(100).optional() }).strict();
+  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();
   const q = eventsQuery.parse(queryParams(url, FILTER_LISTS));
@@ -65,7 +68,9 @@ export async function listEvents(repo: ContentRepository, url: URL) {
   if (f.roomIds && f.roomIds.length < filter.room.length) throw new ApiError(404, 'Room not found.');
   const picked = f.calendarIds;
   const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public' || picked?.includes(c.id)).map(c => [c.id, c]));
-  const visible = events.map(e => localizeDoc(e, locale ?? undefined)).filter(e => (picked ? e.calendarIds.some(id => picked.includes(id)) && eventIsPublic(e, all) : eventIsListed(e, all))
+  // q continues /search, so it finds what search finds (unlisted calendars too, no booking-page appointments)
+  const shown = (e: CalEvent) => (term ? eventIsSearchable(e, all) : picked ? eventIsPublic(e, all) : eventIsListed(e, all));
+  const visible = events.map(e => localizeDoc(e, locale ?? undefined)).filter(e => (!picked || e.calendarIds.some(id => picked.includes(id))) && shown(e)
     && tagsMatch(f, e.tags)
     && (!term || indexed!.has(e.id) || `${e.title} ${e.excerpt} ${e.location.name}`.toLowerCase().includes(term.toLowerCase())));
   const occurrences = expandEvents(visible, settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: from, windowEndMs: to })
@@ -78,11 +83,29 @@ export async function listEvents(repo: ContentRepository, url: URL) {
     locale, timezone: settings.timezone || 'UTC', from: new Date(from).toISOString(), to: new Date(to).toISOString(),
     occurrences: occurrences.slice(start, start + q.limit).map(o => ({
       ...occurrenceDto(o, resources, locale || siteLang(settings)),
-      event: publicEventDto(o.event, origin, publicCalendars, settings, locale, resources),
+      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
@@ -102,7 +125,7 @@ export async function getEventDetail(repo: ContentRepository, url: URL, ref: str
   return {
     locale,
     occurrence: o ? occurrenceDto(o, resources, locale || siteLang(settings)) : null,
-    event: publicEventDto(e, siteOrigin(settings, url), publicCalendars, settings, locale, resources),
+    event: publicEventDto(e, siteOrigin(settings, url), publicCalendars, all, settings, locale, resources),
   };
 }
 /** every room by id, for naming the public ones (Resource.showOnEvents) */
@@ -116,8 +139,9 @@ export function occurrenceDto(o: Occurrence, resources: Map<string, Resource>, l
     location: o.location ? { name: o.location.name, address: o.location.address, url: o.location.url } : null,
     rooms: roomsToJson(o.roomIds, resources, false, locale) };
 }
-// e is already localized; publicCalendars limits which calendars are named
-export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, settings: Settings, locale: string | null, resources?: Map<string, Resource>) {
+// e is already localized; publicCalendars limits which calendars are named,
+// `all` holds every calendar (their visibility decides which changes notify)
+export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, all: Map<string, Calendar>, settings: Settings, locale: string | null, resources?: Map<string, Resource>) {
   // the repeat line in the request's language, else the site's main one
   const event = eventToJson(e, origin, publicCalendars, settings.timezone, { resources, locale: locale || siteLang(settings) });
   event.url = localizedUrl(event.url, origin, locale);
@@ -126,20 +150,23 @@ export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map
   event.image = safeUrl(e.cover, origin);
   event.cta = { ...event.cta, href: localizedUrl(safeUrl(event.cta.href, origin, true), origin, locale) };
   // which push topics hear about date, time or place changes ([] = none do)
-  return { ...event, notify: { changes: changeTopics(e, settings, publicCalendars) } };
+  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/mobile/search.ts

@@ -6,7 +6,7 @@ import { siteOrigin } from '../seo';
 import { siteLang } from '../dates';
 import { SEARCH } from '../search-config';
 import { CALENDAR } from '../calendar/config';
-import { eventIsListed, featuredOccurrence } from '../calendar/events';
+import { eventIsSearchable, featuredOccurrence } from '../calendar/events';
 import { localizeDoc } from '../translations';
 import { ApiError } from '../api';
 import { contentDto } from './content';
@@ -68,12 +68,13 @@ export async function search(repo: ContentRepository, url: URL) {
   const pages = want.has('page') && !q.collection ? found.pages : [];
   const all = new Map(calendars.map((c) => [c.id, c]));
   const listed = new Map(calendars.filter((c) => c.visibility === 'public').map((c) => [c.id, c]));
-  let events = want.has('event') && CALENDAR.enabled && !q.collection ? found.events.filter(({ doc }) => eventIsListed(doc, all)) : [];
-  // the index ranks before visibility is known: if unlisted events filled the
-  // first batch, look deeper once (the repo's 200-row cap) for listed ones
+  // the website's rule: any calendar that isn't private, no booking-page appointments
+  let events = want.has('event') && CALENDAR.enabled && !q.collection ? found.events.filter(({ doc }) => eventIsSearchable(doc, all)) : [];
+  // the index ranks before visibility is known: if private events or bookings
+  // filled the first batch, look deeper once (the repo's 200-row cap)
   if (want.has('event') && CALENDAR.enabled && !q.collection && events.length <= q.limit && found.events.length >= q.limit + 1) {
     const deeper = await repo.searchPublished(q.q, { locale: normalizePageLocale(locale ?? ''), limit: 200, collections: [] });
-    events = deeper.events.filter(({ doc }) => eventIsListed(doc, all));
+    events = deeper.events.filter(({ doc }) => eventIsSearchable(doc, all));
   }
   const now = Date.now();
   return {
@@ -87,7 +88,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 ? (({ id: _, ...rest }) => rest)(occurrenceDto(o, resources, locale || siteLang(settings))) : null,
-        event: publicEventDto(e, origin, listed, settings, locale, resources),
+        event: publicEventDto(e, origin, listed, all, settings, locale, resources),
       };
     }),
     more: { posts: posts.length > q.limit, pages: pages.length > q.limit, events: events.length > q.limit },