@acms-subir/core 0.3.44 → 0.3.45

package/src/lib/calendar/data.ts

@@ -3,7 +3,7 @@
 // agenda. Native events are expanded from the DB; feed calendars are fetched
 // live through the cached ICS loader. Visibility rules live in events.ts.
 import type { ContentRepository } from '../repo/types';
-import type { CalEvent, Calendar, Settings } from '../schema';
+import { roomColor, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
 import { eventIsListed, eventIsPublic, expandEvents, safeColor } from './events';
 import { expandVEvents, loadFeed, tzParts, type CalendarEvent, type CalendarWindow } from './ics';
 import { CALENDAR, eventUrl, resourceUrl, withoutPrivateFields } from './config';
@@ -16,8 +16,14 @@ export interface ViewEvent extends CalendarEvent {
   imageAlt?: string;
   calendarName?: string;
   event?: CalEvent;
+  // native events: the rooms this date holds; public views name only rooms
+  // set to show on public events (Resource.showOnEvents)
+  rooms?: ViewRoom[];
 }
 
+// color: '#rrggbb', or '' when the room has none
+export interface ViewRoom { id: string; slug: string; name: string; color: string }
+
 export interface ViewScope {
   audience: 'public' | 'admin';
   // limit to these calendars; omitted = every calendar the audience may see
@@ -70,6 +76,10 @@ export async function collectViewEvents(
     if (!shown.has(e.id)) shown.set(e.id, withoutPrivateFields(e));
     return shown.get(e.id)!;
   };
+  const resources = natives.some((e) => e.roomHold.resourceIds.length) ? new Map((await repo.listResources()).map((r) => [r.id, r])) : new Map<string, Resource>();
+  const rooms = (ids: string[]) => ids.map((id) => resources.get(id))
+    .filter((r): r is Resource => Boolean(r) && (scope.audience === 'admin' || r!.showOnEvents))
+    .map((r) => ({ id: r.id, slug: r.slug, name: r.name, color: roomColor(r) }));
   for (const o of expandEvents(natives, settings, win)) {
     const e = o.event;
     const cal = e.calendarIds.map((id) => byId.get(id)).find((c) => c && scoped.has(c.id));
@@ -89,6 +99,7 @@ export async function collectViewEvents(
       imageAlt: e.coverAlt || undefined,
       calendarName: cal?.name,
       event: view(e),
+      rooms: rooms(o.roomIds),
     });
   }
 

package/src/lib/calendar/events.ts

@@ -122,6 +122,8 @@ export interface Occurrence {
   key: string;
   // the whole event is cancelled, or just this date
   cancelled: boolean;
+  // the rooms this date holds (Resource ids; the event's roomHold.resourceIds)
+  roomIds: string[];
 }
 
 /**
@@ -148,7 +150,7 @@ export function expandEvents(events: CalEvent[], settings: Pick<Settings, 'timez
     const cancelledDates = new Set(e.cancelledDates ?? []);
     for (const o of expandVEvents([v], tz, win, 0)) {
       const key = occurrenceKey(e, o.start, settings, win.displayTz);
-      out.push({ event: e, start: o.start, end: o.end, allDay: o.allDay, days: o.days, key, cancelled: e.cancelled || cancelledDates.has(key) });
+      out.push({ event: e, start: o.start, end: o.end, allDay: o.allDay, days: o.days, key, cancelled: e.cancelled || cancelledDates.has(key), roomIds: e.roomHold?.resourceIds ?? [] });
     }
   }
   return out.sort((a, b) => a.start - b.start || a.event.title.localeCompare(b.event.title));
@@ -196,7 +198,7 @@ export function featuredOccurrence(e: CalEvent, settings: Pick<Settings, 'timezo
     const en = parseWall(e.end) ?? s;
     const days = e.allDay && s && en ? Math.round((wallMinutes(en) - wallMinutes(s)) / 1440) + 1 : 1;
     const key = occurrenceKey(e, startAt, settings, displayTz);
-    return { event: e, start: startAt, end: endAt, allDay: e.allDay, days, key, cancelled: e.cancelled || (e.cancelledDates ?? []).includes(key) };
+    return { event: e, start: startAt, end: endAt, allDay: e.allDay, days, key, cancelled: e.cancelled || (e.cancelledDates ?? []).includes(key), roomIds: e.roomHold?.resourceIds ?? [] };
   }
   const next = expandEvents([e], settings, { displayTz, now, windowStartMs: now, windowEndMs: now + 3 * 366 * DAY })[0];
   if (next) return next;

package/src/lib/calendar/hooks.ts

@@ -27,8 +27,8 @@ export async function eventChanged(
   else if (before.status === 'published' && after.status !== 'published') type = 'event.unpublished';
   else if (after.status === 'published' && (opts.applied || before.updatedAt !== after.updatedAt)) type = 'event.updated';
   if (!type) return;
-  const [settings, calendars] = await Promise.all([repo.getSettings(), repo.listCalendars()]);
-  const data = eventToJson(after, opts.origin, new Map(calendars.map((c) => [c.id, c])), settings.timezone);
+  const [settings, calendars, rooms] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listResources()]);
+  const data = eventToJson(after, opts.origin, new Map(calendars.map((c) => [c.id, c])), settings.timezone, { resources: new Map(rooms.map((r) => [r.id, r])) });
   await emitWebhook(repo, type, { event: data }, { waitUntil: opts.waitUntil }).catch(() => {});
 }
 

package/src/lib/editor/schedule.ts

@@ -174,6 +174,9 @@ export const ResourceInput = z.object({
   timezone: z.string().max(64).refine((t) => !t || isValidTimeZone(t), 'Unknown timezone.').optional(),
   hours: Hours.optional(), overrides: z.array(Override).max(200).optional(),
   visibility: z.enum(['public', 'unlisted']).optional(), showOnCalendar: z.boolean().optional(), placeId: z.string().max(100).optional(),
+  // '' = no colour; public event data names it only with showOnEvents; requestable answers GET /api/v1/rooms/free
+  color: z.union([z.literal(''), z.string().regex(/^#[0-9a-fA-F]{6}$/, 'Use a colour like #2f6fde.')]).optional(),
+  showOnEvents: z.boolean().optional(), requestable: z.boolean().optional(),
   // ICS / Google calendars whose events block this room (fetched like calendar feeds)
   busyFeeds: z.array(z.string().max(2000)).max(10).optional(),
   notifyEmails: z.array(z.string().trim().email().max(200)).max(10).optional(),

package/src/lib/mobile/calendar.ts

@@ -3,9 +3,12 @@ import type { ContentRepository } from '../repo/types';
 import { publicTags, tagFilter, 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 } from '../calendar/api';
-import { eventIsListed, eventIsPublic, expandEvents, featuredOccurrence } from '../calendar/events';
+import { calendarToJson, eventToJson, roomsToJson } from '../calendar/api';
+import { eventIsListed, eventIsPublic, expandEvents, featuredOccurrence, type Occurrence } from '../calendar/events';
 import { availabilityContext } from '../booking/service';
+import { roomBusy } from '../booking/holds';
+import { sha256Hex } from '../api-keys';
+import type { PublicContext } from './route';
 import { addDaysYmd, describeLink, linkLengths, localMidnight, slotsForDay, ymd } from '../booking/availability';
 import { siteOrigin } from '../seo';
 import { safeUrl } from './content';
@@ -32,7 +35,7 @@ export async function listEvents(repo: ContentRepository, url: URL) {
   const q = eventsQuery.parse(queryParams(url));
   const locale = mobileLocale(q.locale);
   const term = q.q?.trim() ?? '';
-  const [settings, calendars, events, indexed] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents(),
+  const [settings, calendars, events, resources, indexed] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents(), roomMap(repo),
     // the search index's matches (body text, word prefixes), so "more" from /search continues here
     term ? repo.searchPublished(term, { limit: 200, collections: [] }).then((r) => new Set(r.events.map(({ doc }) => doc.id))) : null]);
   // days are the site's calendar days (a New York site's "today" starts at midnight there, not UTC)
@@ -58,9 +61,8 @@ export async function listEvents(repo: ContentRepository, url: URL) {
   return {
     locale, timezone: settings.timezone || 'UTC', from: new Date(from).toISOString(), to: new Date(to).toISOString(),
     occurrences: occurrences.slice(start, start + q.limit).map(o => ({
-      id: `${o.event.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay,
-      cancelled: o.cancelled,
-      event: publicEventDto(o.event, origin, publicCalendars, settings, locale),
+      ...occurrenceDto(o, resources),
+      event: publicEventDto(o.event, origin, publicCalendars, settings, locale, resources),
     })),
     pagination: { page: q.page, limit: q.limit, nextPage: occurrences.length > start + q.limit ? q.page + 1 : null },
   };
@@ -74,7 +76,7 @@ export async function getEventDetail(repo: ContentRepository, url: URL, ref: str
   requireCalendar();
   const q = eventDetailQuery.parse(queryParams(url));
   const locale = mobileLocale(q.locale);
-  const [settings, calendars] = await Promise.all([repo.getSettings(), repo.listCalendars()]);
+  const [settings, calendars, resources] = await Promise.all([repo.getSettings(), repo.listCalendars(), roomMap(repo)]);
   const found = ref && ref.length <= 200 ? await repo.getEventBySlug(ref) ?? await repo.getEvent(ref) : null;
   const all = new Map(calendars.map(c => [c.id, c]));
   if (!found || !eventIsPublic(found, all)) throw new ApiError(404, 'Event not found.');
@@ -83,13 +85,20 @@ export async function getEventDetail(repo: ContentRepository, url: URL, ref: str
   const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public').map(c => [c.id, c]));
   return {
     locale,
-    occurrence: o ? { id: `${e.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay, cancelled: o.cancelled } : null,
-    event: publicEventDto(e, siteOrigin(settings, url), publicCalendars, settings, locale),
+    occurrence: o ? occurrenceDto(o, resources) : null,
+    event: publicEventDto(e, siteOrigin(settings, url), publicCalendars, settings, locale, resources),
   };
 }
+/** every room by id, for naming the public ones (Resource.showOnEvents) */
+export const roomMap = async (repo: ContentRepository) => new Map((await repo.listResources()).map((r) => [r.id, r]));
+// one date: its time, whether it's cancelled, and the public rooms it holds
+export function occurrenceDto(o: Occurrence, resources: Map<string, Resource>) {
+  return { id: `${o.event.id}:${o.start}`, start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(), allDay: o.allDay, cancelled: o.cancelled,
+    rooms: roomsToJson(o.roomIds, resources) };
+}
 // 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) {
-  const event = eventToJson(e, origin, publicCalendars, settings.timezone);
+export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, settings: Settings, locale: string | null, resources?: Map<string, Resource>) {
+  const event = eventToJson(e, origin, publicCalendars, settings.timezone, { resources });
   event.url = localizedUrl(event.url, origin, locale);
   // Only configured public event fields; no undeclared imported metadata, no private fields.
   event.fields = publicEventFields(e.fields);
@@ -137,3 +146,32 @@ export async function availabilityFor(repo: ContentRepository, resource: Resourc
     })),
   };
 }
+
+// Free or busy for one room over a span, for people asking before they
+// request a time (a request form, the app). Only rooms set as requestable
+// answer (others are "not found"), and only the busy times come back, never
+// what or who: event holds with their setup and cleanup, bookings, blocks and
+// the room's busy calendars, merged. A day is the site's midnight; a
+// date-time is that instant. 30 checks a minute per address.
+export const roomFreeQuery = z.object({ room: z.string().min(1).max(200), start: isoDayOrInstant, end: isoDayOrInstant }).strict();
+export async function roomFree(c: PublicContext) {
+  requireCalendar(true);
+  const q = roomFreeQuery.parse(queryParams(c.url));
+  if (!await c.repo.email.rateLimit(`rooms:free:${await sha256Hex(c.address)}`, 30, 60_000)) throw new ApiError(429, 'Too many checks. Try again in a minute.');
+  const settings = await c.repo.getSettings();
+  const tz = settings.timezone || 'UTC';
+  const at = (v: string) => (v.length === 10 ? localMidnight(v, tz) : Date.parse(v));
+  const start = at(q.start), end = at(q.end);
+  if (end <= start || end - start > 31 * 86_400_000 + 3_600_000) throw new ApiError(400, 'Use a span of up to 31 days that ends after it starts.');
+  const room = await c.repo.getResourceBySlug(q.room);
+  if (!room || !room.requestable) throw new ApiError(404, 'Room not found.');
+  const busy: { start: number; end: number }[] = [];
+  for (const b of await roomBusy(c.repo, settings, { resourceIds: [room.id], from: start, to: end })) {
+    const s = Math.max(b.start, start), e = Math.min(b.end, end);
+    const last = busy[busy.length - 1];
+    if (last && s <= last.end) last.end = Math.max(last.end, e);
+    else busy.push({ start: s, end: e });
+  }
+  const iso = (n: number) => new Date(n).toISOString();
+  return { room: { slug: room.slug, name: room.name }, start: iso(start), end: iso(end), free: !busy.length, busy: busy.map((b) => ({ start: iso(b.start), end: iso(b.end) })) };
+}

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 } from './calendar';
+import { eventsQuery, eventDetailQuery, availabilityQuery, roomFreeQuery } from './calendar';
 import { bookingInput } from './bookings';
 import { rsvpQuery } from './rsvp';
 import { pagesQuery } from './pages';
@@ -109,6 +109,8 @@ export async function getOpenApi(_repo: ContentRepository, url: URL) {
     description: `${manageNote} Past its holdUntil the spot was released (410) and goes to the next person in line; a booking with no held spot answers 409.` }), ...cors };
   paths['/api/v1/bookings/manage/availability'] = { get: priv('Open times for moving the booking (its own time counts as free)', ref('Availability'), { header: bookingToken, query: manageAvailabilityQuery, description: manageNote }), ...cors };
   paths['/api/v1/bookings/manage/reschedule'] = { post: priv('Move the booking to a new start (room bookings, not RSVPs)', ref('ManagedBooking'), { header: bookingToken, body: rescheduleInput, write: true, description: manageNote }), ...cors };
+  paths['/api/v1/rooms/free'] = { get: priv('Free or busy for one room over a span, without names; requires bookings', ref('RoomFree'), { query: roomFreeQuery,
+    description: 'Only rooms marked “Anyone can check if it’s free” answer; any other slug is 404. start and end are a site-local day (its midnight) or an ISO date-time with a zone; at most 31 days. busy lists the taken times inside the span, merged and clipped: events holding the room (with their setup and cleanup), bookings, staff blocks and the room’s busy calendars, never what or who. Never cached. 30 checks per minute per client address (429).' }), ...cors };
   paths['/api/v1/bookings/manage/ics'] = { get: { summary: 'Calendar file for the booking (text/calendar, no v1 envelope)', parameters: [bookingToken],
     responses: { ...errors, 200: { description: 'An iCalendar file.', content: { 'text/calendar': { schema: { type: 'string' } } } } } }, ...cors };
   paths['/api/v1/forms/{id}/responses'] = { post: { ...priv('Send a response to a published form', ref('FormReceipt'), { body: formResponseInput, write: true, status: 201,

package/src/lib/mobile/schemas.ts

@@ -27,23 +27,26 @@ export const Page = ContentSummary.extend({
   kind: z.literal('page'), body: Html, cover: str, seo: z.object({ title: str, description: str }),
   mode: z.enum(['content', 'sections']), sections: z.array(Section),
 });
+// a room an event (or one date) holds, named only when set to show on public events; color null = none
+export const EventRoom = z.object({ slug: str, name: str, color: str.nullable() });
 export const Event = CalEvent.pick({
   id: true, slug: true, title: true, excerpt: true, status: true, cancelled: true, featured: true, start: true, end: true,
   allDay: true, timezone: true, rrule: true, exdates: true, cancelledDates: true, location: true, cta: true, tags: true, fields: true,
 }).extend({ rsvp: CalEvent.shape.rsvp.removeDefault().omit({ notifyStaff: true }).default({}).optional(), url: str, icsUrl: str, repeats: str, image: str, imageAlt: str, updatedAt: date,
   calendars: z.array(z.object({ id: str, slug: str, name: str, color: str })),
+  rooms: z.array(EventRoom),
   // push topics told about date, time or place changes (Admin → Mobile app → When an event changes); [] = none
   notify: z.object({ changes: strings }),
 });
 export const Events = z.object({ locale, timezone: str, from: date, to: date, pagination: Pagination,
-  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, event: Event })),
+  occurrences: z.array(z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom), event: Event })),
 });
 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 });
-export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool }).nullable(), event: Event });
+export const EventDetail = z.object({ locale, occurrence: z.object({ id: str, start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom) }).nullable(), event: Event });
 export const SearchResults = z.object({ locale, query: str,
   posts: z.array(ContentHit), pages: z.array(ContentHit),
-  events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool }).nullable(), event: Event })),
+  events: z.array(z.object({ snippet: Snippet, occurrence: z.object({ start: date, end: date, allDay: bool, cancelled: bool, rooms: z.array(EventRoom) }).nullable(), event: Event })),
   more: z.object({ posts: bool, pages: bool, events: bool }),
 });
 const Icon = z.object({ type: z.enum(['svg', 'image', 'emoji']), value: str }).nullable();
@@ -114,6 +117,8 @@ export const Resources = z.object({ pagination: Pagination, resources: z.array(z
     askPhone: bool, autoConfirm: bool, url: str, questions: z.array(BookingQuestion.omit({ help: true })),
   })),
 })) });
+// GET /rooms/free: free = nothing takes the room in [start, end); busy = the taken times, no names
+export const RoomFree = z.object({ room: z.object({ slug: str, name: str }), start: date, end: date, free: bool, busy: z.array(z.object({ start: date, end: date })) });
 export const Availability = z.object({ timezone: str, mode: z.enum(['slots', 'day', 'range']), lengths: z.array(z.number()), autoConfirm: bool,
   days: z.array(z.object({ date: str, slots: z.array(z.object({ start: date, end: date, minutes: z.number() })) })),
 });

package/src/lib/mobile/search.ts

@@ -9,7 +9,7 @@ import { eventIsListed, featuredOccurrence } from '../calendar/events';
 import { localizeDoc } from '../translations';
 import { ApiError } from '../api';
 import { contentDto } from './content';
-import { publicEventDto } from './calendar';
+import { occurrenceDto, publicEventDto, roomMap } from './calendar';
 import { queryParams } from './http';
 import { localeQuery, mobileLocale } from './locale';
 
@@ -56,9 +56,9 @@ export async function search(repo: ContentRepository, url: URL) {
   const q = searchQuery.parse(queryParams(url));
   if (q.collection && !Object.hasOwn(CONTENT.collections, q.collection)) throw new ApiError(400, 'Unknown collection.');
   const locale = mobileLocale(q.locale);
-  const [found, settings, calendars] = await Promise.all([
+  const [found, settings, calendars, resources] = await Promise.all([
     repo.searchPublished(q.q, { locale: normalizePageLocale(locale ?? ''), limit: q.limit + 1, collections: q.collection ? [q.collection] : Object.keys(CONTENT.collections) }),
-    repo.getSettings(), repo.listCalendars(),
+    repo.getSettings(), repo.listCalendars(), roomMap(repo),
   ]);
   const origin = siteOrigin(settings, url);
   const want = new Set(q.types);
@@ -75,7 +75,6 @@ export async function search(repo: ContentRepository, url: URL) {
     events = deeper.events.filter(({ doc }) => eventIsListed(doc, all));
   }
   const now = Date.now();
-  const iso = (n: number) => new Date(n).toISOString();
   return {
     locale, query: q.q,
     posts: posts.slice(0, q.limit).map(({ doc, snippet }) => ({ ...contentDto(doc, 'post', origin, false, locale), snippet: plainSnippet(snippet) })),
@@ -86,8 +85,8 @@ export async function search(repo: ContentRepository, url: URL) {
       return {
         snippet: plainSnippet(snippet),
         // the next occurrence, or the latest one when the event is over
-        occurrence: o ? { start: iso(o.start), end: iso(o.end), allDay: o.allDay, cancelled: o.cancelled } : null,
-        event: publicEventDto(e, origin, listed, settings, locale),
+        occurrence: o ? (({ id: _, ...rest }) => rest)(occurrenceDto(o, resources)) : null,
+        event: publicEventDto(e, origin, listed, settings, locale, resources),
       };
     }),
     more: { posts: posts.length > q.limit, pages: pages.length > q.limit, events: events.length > q.limit },

package/src/lib/repo/migrations.ts

@@ -710,6 +710,16 @@ export const MIGRATIONS: Migration[] = [
   { version: 63, statements: [
     `ALTER TABLE forms ADD COLUMN alerts TEXT NOT NULL DEFAULT '{}'`,
   ] },
+  // rooms: a colour and whether public event data names them
+  // (Resource.color / .showOnEvents, both visible), and whether anyone may ask
+  // if they're free (Resource.requestable, never shown, so no cache bump)
+  { version: 64, statements: [
+    `ALTER TABLE resources ADD COLUMN color TEXT NOT NULL DEFAULT ''`,
+    `ALTER TABLE resources ADD COLUMN show_on_events INTEGER NOT NULL DEFAULT 0`,
+    `ALTER TABLE resources ADD COLUMN requestable INTEGER NOT NULL DEFAULT 0`,
+    `DROP TRIGGER content_version_resources_update`,
+    contentVersionTriggers('resources', [...CONTENT_VERSION_COLUMNS.resources, 'color', 'show_on_events'])[2],
+  ] },
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.
@@ -717,6 +727,7 @@ export const CURRENT_CONTENT_VERSION_COLUMNS = {
   ...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'],
+  resources: [...CONTENT_VERSION_COLUMNS.resources, 'color', 'show_on_events'],
   announcements: ANNOUNCEMENT_VISIBLE_COLUMNS,
 };
 

package/src/lib/repo/sql.ts

@@ -13,7 +13,7 @@ import { LiveConfig } from '../live/types';
 import { ApiError } from '../api';
 import { EmailStore, bookingJobs, rsvpStaffJobs } from '../email/store';
 import type { ContentRepository, DesignVersion, EventUpdate, ImportRecord, ImportRecordKind, ImportRun, SearchResults, Stats } from './types';
-import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, Place, EventLocation, EventRequest, isInternalTag, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
+import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, Place, EventLocation, EventRequest, isInternalTag, roomColor, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
 import { designSnapshot, draftNavItems, pickDesignDraft, pickEventDraft, pickPageDraft, pickPostDraft } from '../drafts';
 import { eventInstants, eventTimeZone, normalizeEventTimes } from '../calendar/events';
 import { cleanRrule } from '../calendar/rrule';
@@ -172,6 +172,7 @@ function rowToResource(r: Row): Resource {
     amenities: json(r.amenities, []), timezone: r.timezone ?? '', hours: json(r.hours, {}), overrides: json(r.overrides, []),
     busyFeeds: json(r.busy_feeds, []), notifyEmails: json(r.notify_emails, []), visibility: r.visibility ?? 'public',
     showOnCalendar: Boolean(r.show_on_calendar), feedToken: r.feed_token ?? '', placeId: r.place_id ?? '', order: Number(r.ord ?? 0),
+    color: r.color ?? '', showOnEvents: Boolean(r.show_on_events), requestable: Boolean(r.requestable),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
 }
@@ -1083,10 +1084,10 @@ export class SqlRepository implements ContentRepository {
   private resourceInsert(r: Resource): SqlStatement {
     return {
       sql: `INSERT INTO resources (id, slug, name, kind, description, photo, capacity, amenities, timezone, hours, overrides, busy_feeds,
-        notify_emails, visibility, show_on_calendar, feed_token, ord, created_at, updated_at, place_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        notify_emails, visibility, show_on_calendar, feed_token, ord, created_at, updated_at, place_id, color, show_on_events, requestable) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [r.id, r.slug, r.name, r.kind, r.description, r.photo, r.capacity, JSON.stringify(r.amenities), r.timezone, JSON.stringify(r.hours),
         JSON.stringify(r.overrides), JSON.stringify(r.busyFeeds), JSON.stringify(r.notifyEmails), r.visibility, r.showOnCalendar ? 1 : 0,
-        r.feedToken || randomToken(), r.order, r.createdAt, r.updatedAt, r.placeId],
+        r.feedToken || randomToken(), r.order, r.createdAt, r.updatedAt, r.placeId, roomColor(r), r.showOnEvents ? 1 : 0, r.requestable ? 1 : 0],
     };
   }
   private linkInsert(l: BookingLink): SqlStatement {
@@ -1137,10 +1138,11 @@ export class SqlRepository implements ContentRepository {
     const r = Resource.parse({ ...cur, ...data, id, updatedAt: Date.now() });
     await this.driver.run(
       `UPDATE resources SET slug = ?, name = ?, kind = ?, description = ?, photo = ?, capacity = ?, amenities = ?, timezone = ?, hours = ?,
-        overrides = ?, busy_feeds = ?, notify_emails = ?, visibility = ?, show_on_calendar = ?, feed_token = ?, place_id = ?, updated_at = ? WHERE id = ?`,
+        overrides = ?, busy_feeds = ?, notify_emails = ?, visibility = ?, show_on_calendar = ?, feed_token = ?, place_id = ?,
+        color = ?, show_on_events = ?, requestable = ?, updated_at = ? WHERE id = ?`,
       [r.slug, r.name, r.kind, r.description, r.photo, r.capacity, JSON.stringify(r.amenities), r.timezone, JSON.stringify(r.hours),
         JSON.stringify(r.overrides), JSON.stringify(r.busyFeeds), JSON.stringify(r.notifyEmails), r.visibility, r.showOnCalendar ? 1 : 0,
-        r.feedToken, r.placeId, r.updatedAt, id]
+        r.feedToken, r.placeId, roomColor(r), r.showOnEvents ? 1 : 0, r.requestable ? 1 : 0, r.updatedAt, id]
     );
   }
   async reorderResources(ids: string[]) {

package/src/lib/schema.ts

@@ -509,6 +509,14 @@ export const Resource = z.object({
   visibility: z.enum(['public', 'unlisted']).default('public'),
   // confirmed bookings show on the public calendar as "Reserved" blocks
   showOnCalendar: z.boolean().default(false),
+  // a #rrggbb colour for it on calendars and screens ('' = none; roomColor() reads it)
+  color: z.string().default(''),
+  // named in public event data (event pages, /calendar, the app API's rooms);
+  // off = only staff see that an event uses it
+  showOnEvents: z.boolean().default(false),
+  // anyone may ask whether it's free at a time (GET /api/v1/rooms/free: free or
+  // busy, never what or who)
+  requestable: z.boolean().default(false),
   // secret for the staff feed /book/<slug>.ics?t=… (bookings with names)
   feedToken: z.string().default(''),
   // the saved place this room is in ('' = none)
@@ -518,6 +526,8 @@ export const Resource = z.object({
   updatedAt: z.number(),
 });
 export type Resource = z.infer<typeof Resource>;
+/** A room's colour as #rrggbb, or '' when it has none (anything else stored reads as none). */
+export const roomColor = (r: Pick<Resource, 'color'>) => (/^#[0-9a-f]{6}$/i.test(r.color) ? r.color.toLowerCase() : '');
 
 // A saved place (HQ, the park pavilion…): picked in an event's Where field,
 // it copies its details into the event. Rooms can belong to one (resource.placeId).

package/src/lib/sync/catalog.ts

@@ -147,6 +147,8 @@ const boolFields = new Set([
   "allDay",
   "cancelled",
   "showOnCalendar",
+  "showOnEvents",
+  "requestable",
   "isDefault",
   "autoConfirm",
   "askPhone",

package/src/pages/admin/calendar/resources/[id].astro

@@ -2,7 +2,7 @@
 import Admin from '../../../../layouts/Admin.astro';
 import HoursEditor from '../../../../components/booking/HoursEditor.astro';
 import { getRepo } from '../../../../lib/repo';
-import { slugify } from '../../../../lib/schema';
+import { roomColor, slugify } from '../../../../lib/schema';
 import { bookingLinkUrl, bookingsEnabled, CALENDAR, resourceFeedUrl, resourceUrl } from '../../../../lib/calendar/config';
 import { hoursFromForm, int, list, overridesFromForm } from '../../../../lib/booking/forms';
 import { describeLink } from '../../../../lib/booking/availability';
@@ -53,6 +53,9 @@ if (Astro.request.method === 'POST') {
       timezone: tz && isValidTimeZone(tz) ? tz : '',
       visibility: form.get('visibility') === 'unlisted' ? 'unlisted' : 'public',
       showOnCalendar: Boolean(form.get('showOnCalendar')),
+      color: form.get('noColor') ? '' : roomColor({ color: String(form.get('color') || '') }),
+      showOnEvents: Boolean(form.get('showOnEvents')),
+      requestable: Boolean(form.get('requestable')),
       placeId: places.some((p) => p.id === form.get('placeId')) ? String(form.get('placeId')) : '',
       hours: hoursFromForm(form), overrides: overridesFromForm(form), busyFeeds, notifyEmails: emails,
     });
@@ -182,6 +185,15 @@ const ovRows = [...resource.overrides, { date: '', endDate: '', ranges: [], labe
           </select>
         </label>
         <label class="check-row"><input type="checkbox" name="showOnCalendar" checked={resource.showOnCalendar} /> Show confirmed bookings on the public calendar as “Reserved”</label>
+        <div class="field">
+          <span>Colour <em class="hint">for events in it, on calendars and screens</em></span>
+          <span class="res-color">
+            <input type="color" name="color" value={roomColor(resource) || '#4f46e5'} aria-label="Colour" />
+            <label class="check-row"><input type="checkbox" name="noColor" checked={!roomColor(resource)} /> No colour</label>
+          </span>
+        </div>
+        <label class="check-row"><input type="checkbox" name="showOnEvents" checked={resource.showOnEvents} /> Name it on public events (event pages, the calendar and the app)</label>
+        <label class="check-row"><input type="checkbox" name="requestable" checked={resource.requestable} /> Anyone can check if it’s free (only free or busy, never what’s on)</label>
       </section>
       <section class="card card-pad">
         <div class="card-head"><b>Busy calendars</b></div>

package/src/pages/api/calendar/events/[id].ts

@@ -27,12 +27,12 @@ export const GET: APIRoute = async ({ request, locals, url, params }) => {
   try {
     if (!CALENDAR.enabled) throw new ApiError(404, 'The calendar module is disabled.');
     const repo = await getRepo(locals);
-    const [e, settings, calendars, who] = await Promise.all([find(repo, params.id!), repo.getSettings(), repo.listCalendars(), authenticate(request, repo)]);
+    const [e, settings, calendars, who, rooms] = await Promise.all([find(repo, params.id!), repo.getSettings(), repo.listCalendars(), authenticate(request, repo), repo.listResources()]);
     const map = new Map(calendars.map((c) => [c.id, c]));
     const full = who ? hasScope(who, 'events:read') : false;
     if (!e || (!full && !eventIsPublic(e, map))) throw new ApiError(404, 'Event not found.');
     const view = full ? mergeEventDraft(e) : e;
-    return withCors(json({ event: { ...eventToJson(view, siteOrigin(settings, url), map, settings.timezone, { includePrivate: full }), ...(full ? { hasPendingDraft: Boolean(e.draft), bodyHtml: view.bodyHtml } : {}) } }));
+    return withCors(json({ event: { ...eventToJson(view, siteOrigin(settings, url), map, settings.timezone, { includePrivate: full, resources: new Map(rooms.map((r) => [r.id, r])) }), ...(full ? { hasPendingDraft: Boolean(e.draft), bodyHtml: view.bodyHtml } : {}) } }));
   } catch (err) { return fail(err); }
 };
 

package/src/pages/api/calendar/events/index.ts

@@ -5,7 +5,7 @@ import { authenticate, hasScope } from '../../../../lib/api-keys';
 import { siteOrigin } from '../../../../lib/seo';
 import { CALENDAR } from '../../../../lib/calendar/config';
 import { eventIsListed, eventIsPublic, expandEvents, parseWall } from '../../../../lib/calendar/events';
-import { eventToJson } from '../../../../lib/calendar/api';
+import { eventToJson, roomsToJson } from '../../../../lib/calendar/api';
 import { zonedToUtc } from '../../../../lib/calendar/ics';
 import { isoWithOffset } from '../../../../lib/calendar/seo';
 import { eventTimeZone } from '../../../../lib/calendar/events';
@@ -43,9 +43,10 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     const principal = await authenticate(request, repo);
     if (request.headers.get('authorization') && !principal) throw new ApiError(401, 'Invalid API key.');
     const full = principal ? hasScope(principal, 'events:read') : false;
-    const [settings, calendars, published] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents()]);
+    const [settings, calendars, published, rooms] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents(), repo.listResources()]);
     const tz = settings.timezone || 'UTC';
     const map = new Map(calendars.map((c) => [c.id, c]));
+    const resources = new Map(rooms.map((r) => [r.id, r]));
     const origin = siteOrigin(settings, url);
 
     const slug = url.searchParams.get('calendar');
@@ -64,7 +65,7 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     }
 
     if (url.searchParams.get('expand') === '0') {
-      return withCors(json({ timezone: tz, events: events.map((e) => eventToJson(e, origin, map, settings.timezone, { includePrivate: full })) }));
+      return withCors(json({ timezone: tz, events: events.map((e) => eventToJson(e, origin, map, settings.timezone, { includePrivate: full, resources })) }));
     }
     const day = (param: string, fallback: number) => {
       const w = parseWall(url.searchParams.get(param) ?? '');
@@ -78,7 +79,7 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     const occ = expandEvents(events, settings, { displayTz: tz, now, windowStartMs: from, windowEndMs: to }).slice(0, limit);
     const cache = new Map<string, ReturnType<typeof eventToJson>>();
     const toJson = (id: string) => {
-      if (!cache.has(id)) cache.set(id, eventToJson(events.find((e) => e.id === id)!, origin, map, settings.timezone, { includePrivate: full }));
+      if (!cache.has(id)) cache.set(id, eventToJson(events.find((e) => e.id === id)!, origin, map, settings.timezone, { includePrivate: full, resources }));
       return cache.get(id)!;
     };
     return withCors(json({
@@ -93,6 +94,8 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
           end: o.allDay ? isoWithOffset(o.end - 86_400_000, etz).slice(0, 10) : isoWithOffset(o.end, etz),
           allDay: o.allDay,
           cancelled: o.cancelled,
+          // that date's rooms
+          rooms: roomsToJson(o.roomIds, resources, full),
           event: toJson(o.event.id),
         };
       }),

package/src/pages/api/v1/rooms/free.ts

@@ -0,0 +1,7 @@
+import { roomFree } from '../../../../lib/mobile/calendar';
+import { privateRoute } from '../../../../lib/mobile/route';
+import { methodNotAllowed } from '../../../../lib/mobile/http';
+export { preflight as OPTIONS } from '../../../../lib/mobile/http';
+// never cached: a room taken a minute ago must not read as free
+export const GET = privateRoute(roomFree);
+export const ALL = () => methodNotAllowed('GET, OPTIONS');

package/src/server/index.ts

@@ -36,6 +36,7 @@ export interface ServerUser {
 
 export type { CalEvent, Occurrence };
 export type { EventRequestInput } from '../lib/calendar/requests';
+export type { EventClash, BusySlot, Hold } from '../lib/booking/holds';
 
 export interface ListEventsOptions {
   /** only published events (default: every event except archived ones) */
@@ -171,6 +172,42 @@ export async function restoreOccurrence(repo: Repo, eventId: string, occurrenceK
   return restore(internal(repo), eventId, occurrenceKey, { url: context.url, locals: context.locals });
 }
 
+// ---- rooms -----------------------------------------------------------------
+// Events hold rooms (CalEvent.roomHold) while they happen. These find where
+// two things want the same room. They don't check permissions, and their
+// results carry names: show them to staff only.
+
+/**
+ * Other events holding the same rooms as this one at overlapping times, setup
+ * and cleanup included, soonest first. Pass an event id, or a CalEvent with
+ * unsaved values (it's checked as if published). Looks `horizonDays` ahead
+ * (default 366) from `now`. Clashes are warnings: both events keep the room.
+ * Throws an Error with `status` 404 for an unknown event id.
+ */
+export async function eventRoomClashes(repo: Repo, event: string | CalEvent, opts: { horizonDays?: number; now?: Date | number } = {}): Promise<import('../lib/booking/holds').EventClash[]> {
+  const r = internal(repo);
+  const e = typeof event === 'string' ? await r.getEvent(event) : event;
+  if (!e) throw Object.assign(new Error('Event not found.'), { status: 404 });
+  const { eventClashes } = await import('../lib/booking/holds');
+  return (await eventClashes(r, await r.getSettings(), e, { horizonDays: opts.horizonDays, now: opts.now === undefined ? undefined : +opts.now })).clashes;
+}
+
+/**
+ * Everything that takes these rooms (Resource ids) in [from, to), soonest
+ * first: events holding them (setup and cleanup included), pending and
+ * confirmed bookings, staff blocks and the rooms' busy calendars. `ignore`
+ * leaves out one event, or one date of it by occurrence key, such as the date
+ * you're about to move. An empty list means they're all free.
+ */
+export async function roomBusy(repo: Repo, q: { roomIds: string[]; from: Date | number; to: Date | number; ignore?: { eventId: string; key?: string } }): Promise<import('../lib/booking/holds').BusySlot[]> {
+  const from = +q.from, to = +q.to;
+  if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) throw new RangeError('roomBusy needs a "to" after "from".');
+  if (to - from > MAX_WINDOW) throw new RangeError('roomBusy windows are at most 400 days.');
+  const r = internal(repo);
+  const { roomBusy: busy } = await import('../lib/booking/holds');
+  return busy(r, await r.getSettings(), { resourceIds: q.roomIds, from, to, ignore: q.ignore });
+}
+
 // ---- members' event requests ------------------------------------------
 // The rules behind the built-in "My events" pages (acms({ members })), for a
 // site that builds its own. Each takes the person acting (currentUser()) and

package/src/styles/admin.css

@@ -1392,6 +1392,9 @@ em.manual { color: var(--amber); }
 .res-grid > div > .card + .card, .res-side > .card + .card { margin-top: 16px; }
 .res-side { display: flex; flex-direction: column; gap: 0; }
 .res-side > .btn { margin-top: 14px; align-self: flex-start; }
+.res-color { display: flex; align-items: center; gap: 12px; margin-top: 4px; }
+.res-color input[type='color'] { width: 44px; height: 30px; padding: 2px; border: 1px solid var(--line); border-radius: var(--r-sm); background: var(--panel); cursor: pointer; }
+.res-color .check-row { margin: 0; }
 .card-pad { padding: 16px 18px; }
 .card-head { display: flex; justify-content: space-between; align-items: baseline; gap: 10px; margin-bottom: 12px; }
 .card-head b { font-size: 14.5px; }

package/src/styles/editor.css

@@ -1039,6 +1039,8 @@
 .rh-conflict > b { display: block; margin-bottom: 4px; }
 .rh-bk { display: flex; flex-direction: column; padding: 5px 0; border-top: 1px solid color-mix(in srgb, var(--amber) 25%, transparent); }
 .rh-bk small, .rh-more { color: var(--text-2); font-size: 11.5px; }
+.rh-clash .rh-bk a { color: inherit; font-weight: 600; }
+.rh-clash > .rh-more:last-child { display: block; margin-top: 6px; }
 .rh-acts { display: flex; gap: 6px; flex-wrap: wrap; margin-top: 8px; }
 .rh-acts.end { justify-content: flex-end; }
 .rh-cancel textarea, .rh-msg { width: 100%; margin-top: 8px; padding: 7px 9px; border: 1px solid var(--line-strong); border-radius: 8px; background: var(--bg); color: var(--text); font: inherit; font-size: 12.5px; resize: vertical; }