@acms-subir/core 0.3.44 → 0.3.46

package/src/lib/content-service.ts

@@ -7,7 +7,7 @@ import { deniedMessage } from './permissions/catalog';
 import { CONTENT, collectionUrl } from './content';
 import { CALENDAR } from './calendar/config';
 import { formatWall, isValidTimeZone, normalizeEventTimes, parseWall } from './calendar/events';
-import { eventChanged } from './calendar/hooks';
+import { flushEventChanges } from './calendar/hooks';
 import { offerEventWaitlist } from './booking/service';
 import { normalizePageLocale } from './i18n';
 import { siteOrigin } from './seo';
@@ -219,14 +219,18 @@ export async function cleanEventInput(repo: ContentRepository, data: EventSave,
   return out;
 }
 
-export async function eventSideEffects(repo: ContentRepository, hooks: SaveHooks, before: CalEvent, after: CalEvent, applied = false) {
-  const settings = await repo.getSettings();
-  const origin = siteOrigin(settings, hooks.url);
-  await eventChanged(repo, before, after, {
-    origin, waitUntil: waitUntilFrom(hooks.locals), applied, onRedirect: hooks.onRedirect,
-  });
+/** the side effects of event writes made so far (calendar/hooks.ts), at once rather than after the response */
+export function flushEventHooks(repo: ContentRepository, hooks: SaveHooks): Promise<number> {
+  return flushEventChanges(repo, { origin: hooks.url.origin, waitUntil: waitUntilFrom(hooks.locals), onRedirect: hooks.onRedirect });
+}
+
+export async function eventSideEffects(repo: ContentRepository, hooks: SaveHooks, after: CalEvent) {
+  await flushEventHooks(repo, hooks);
   // seats an edit freed (a higher capacity) go to those in line now, not at the next sweep
-  if (after.rsvp.waitlist) await offerEventWaitlist(repo, after.id, { origin, locals: hooks.locals, waitUntil: waitUntilFrom(hooks.locals) });
+  if (after.rsvp.waitlist) {
+    const origin = siteOrigin(await repo.getSettings(), hooks.url);
+    await offerEventWaitlist(repo, after.id, { origin, locals: hooks.locals, waitUntil: waitUntilFrom(hooks.locals) });
+  }
 }
 
 export async function saveEvent(repo: ContentRepository, id: string, data: EventSave, hooks: SaveHooks): Promise<CalEvent> {
@@ -249,17 +253,16 @@ export async function saveEvent(repo: ContentRepository, id: string, data: Event
   await repo.updateEvent(id, clean);
   if (clean.tags !== undefined) await repo.ensureTags(clean.tags);
   const event = (await repo.getEvent(id))!;
-  await eventSideEffects(repo, hooks, before, event);
+  await eventSideEffects(repo, hooks, event);
   return event;
 }
 
 export async function applyEventUpdate(repo: ContentRepository, id: string, hooks: SaveHooks): Promise<CalEvent> {
   assertCanPublish(hooks);
-  const before = await repo.getEvent(id);
-  if (!before) throw new ApiError(404, 'Event not found.');
+  if (!(await repo.getEvent(id))) throw new ApiError(404, 'Event not found.');
   await repo.applyEventDraft(id);
   const event = (await repo.getEvent(id))!;
   if (event.tags.length) await repo.ensureTags(event.tags);
-  await eventSideEffects(repo, hooks, before, event, true);
+  await eventSideEffects(repo, hooks, event);
   return event;
 }

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/push/service.ts

@@ -356,7 +356,7 @@ export function eventChange(was: EventSnapshot, e: CalEvent, settings: Pick<Sett
   return starts.length ? { ...out, at: Math.min(...starts) } : null;
 }
 
-/** Called by eventChanged on every path: queues (or postpones) a change notice when a published event's schedule or place differs. */
+/** Called for every recorded change to a published event (calendar/hooks.ts): queues (or postpones) a change notice when its schedule or place differs. */
 export async function queueEventChange(repo: ContentRepository, before: CalEvent, after: CalEvent, now = Date.now()): Promise<boolean> {
   // publishing is the "new event" notice; unpublishing says nothing
   if (!PUSH.enabled || !CALENDAR.enabled || before.status !== 'published' || after.status !== 'published') return false;

package/src/lib/repo/migrations.ts

@@ -5,6 +5,7 @@ import { WEBHOOK_MIGRATION } from '../webhook-sql';
 import { PUSH_MIGRATION } from '../push/migration';
 import { EDITOR_MIGRATION, EDITOR_GRACE_MIGRATION } from '../editor/migration';
 import { CALENDAR_SETTINGS_MIGRATION, ROOM_HOLD_MIGRATION } from '../calendar/migration';
+import { EVENT_CHANGES_MIGRATION } from '../calendar/change-migration';
 import { PLACES_MIGRATION } from '../maps/migration';
 import { ROLES_MIGRATION } from '../permissions/migration';
 import { SYNC_MIGRATION } from '../sync/migration';
@@ -710,6 +711,19 @@ 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],
+  ] },
+  // every change to a published event, from any write path, queued for its
+  // side effects (webhooks, "event changed" pushes, slug redirects)
+  EVENT_CHANGES_MIGRATION,
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.
@@ -717,6 +731,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),
   });
 }
@@ -1029,6 +1030,33 @@ export class SqlRepository implements ContentRepository {
     if (patch.live) await this.syncEventIndex(id);
   }
 
+  async claimEventChanges(now: number, limit: number, leaseMs: number) {
+    await this.ready;
+    const rows = await this.driver.all(
+      `UPDATE event_changes SET claimed_until=?, attempts=attempts+1 WHERE seq IN (
+        SELECT seq FROM event_changes WHERE claimed_until<=?
+          AND event_id NOT IN (SELECT event_id FROM event_changes WHERE claimed_until>?)
+        ORDER BY seq LIMIT ?) RETURNING *`,
+      [now + leaseMs, now, now, limit]
+    );
+    return rows.map((r) => {
+      // a snapshot that no longer parses drops the whole change (never a fake insert or delete)
+      let before: CalEvent | null = null, after: CalEvent | null = null;
+      try {
+        before = r.old_row ? rowToEvent(JSON.parse(String(r.old_row))) : null;
+        after = r.new_row ? rowToEvent(JSON.parse(String(r.new_row))) : null;
+      } catch { before = after = null; }
+      return { seq: Number(r.seq), eventId: String(r.event_id), before, after, quiet: Boolean(r.quiet), attempts: Number(r.attempts), createdAt: Number(r.created_at) };
+    }).sort((a, b) => a.seq - b.seq);
+  }
+  async finishEventChanges(seqs: number[]) {
+    await this.ready;
+    for (let i = 0; i < seqs.length; i += 200) {
+      const chunk = seqs.slice(i, i + 200);
+      await this.driver.run(`DELETE FROM event_changes WHERE seq IN (${chunk.map(() => '?').join(', ')})`, chunk);
+    }
+  }
+
   // ---- places ----
   private placeInsert(p: Place): SqlStatement {
     return {
@@ -1083,10 +1111,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 +1165,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[]) {
@@ -1864,6 +1893,8 @@ export class SqlRepository implements ContentRepository {
       // Suppression and re-enabling share the restore transaction. A failed
       // restore cannot leave notifications disabled or emit phantom deletes.
       { sql: 'UPDATE webhook_control SET suppressed=1 WHERE id=1' },
+      // changes made before the restore describe content it replaces
+      { sql: 'DELETE FROM event_changes' },
       { sql: "UPDATE auth_invitations SET state='revoked' WHERE state<>'accepted'" },
       ...['email_jobs', 'email_attempts', 'email_delivery_events', 'email_tokens', 'posts', 'pages', 'media', 'links', 'tags', 'nav_items', 'users', 'post_authors', 'redirects', 'calendars', 'events', 'resources', 'booking_links', 'bookings', 'mobile_booking_requests', 'import_runs', 'import_records', 'places', 'forms', 'form_submissions'].map((t) => ({
         sql: `DELETE FROM ${t}`,

package/src/lib/repo/types.ts

@@ -54,6 +54,21 @@ export type EventUpdate = Partial<
   >
 >;
 
+/** One recorded change to a published event (the event_changes outbox, written by triggers). */
+export interface EventChange {
+  seq: number;
+  eventId: string;
+  /** the event as it was: null when it was inserted */
+  before: CalEvent | null;
+  /** the event as written: null when it was deleted */
+  after: CalEvent | null;
+  /** written by a bulk copy (environment sync): no member pushes */
+  quiet: boolean;
+  /** times it was claimed, this one included */
+  attempts: number;
+  createdAt: number;
+}
+
 // The single contract both backends implement. The app only ever imports
 // this — never a concrete adapter.
 export interface ContentRepository {
@@ -168,6 +183,12 @@ export interface ContentRepository {
   // draft itself — alone. notify = RSVP guests of a published event get an
   // "event updated" email (the address changed).
   setEventLocation(id: string, patch: { live?: EventLocation; draft?: EventLocation; notify?: boolean }): Promise<void>;
+  // changes to published events waiting for their side effects
+  // (lib/calendar/hooks.ts), oldest first. A claim holds the rows for
+  // `leaseMs` and skips events another claim still holds, so two runners
+  // never handle one event's changes out of order. finish removes them.
+  claimEventChanges(now: number, limit: number, leaseMs: number): Promise<EventChange[]>;
+  finishEventChanges(seqs: number[]): Promise<void>;
 
   // saved places. Only one can be the default (saving one as default clears
   // the others). Deleting a place unlinks its rooms; events keep their copy.

package/src/lib/scheduler.ts

@@ -1,6 +1,7 @@
 import { syncDueLive } from './live/service';
 import type { ContentRepository } from './repo/types';
 import { processDueDeliveries } from './webhooks';
+import { flushEventChanges } from './calendar/hooks';
 import { dispatchEmail } from './email/service';
 import { decideOverdue, sendDueReminders, sweepWaitlist } from './booking/service';
 import { runPushJobs } from './push/service';
@@ -17,6 +18,8 @@ export async function runScheduledTasks(repo: ContentRepository, locals?: unknow
   const settings = await repo.getSettings();
   const jobs = {
     publish: () => repo.publishDuePosts(startedAt),
+    // changes to published events (scheduled publishing above included): webhooks, change pushes, redirects
+    events: () => flushEventChanges(repo),
     webhooks: () => processDueDeliveries(repo),
     reminders: () => sendDueReminders(repo, { origin: settings.siteUrl, locals, now: startedAt }),
     // pending bookings past their approval deadline (Calendar settings → Bookings)

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/lib/sync/store.ts

@@ -327,7 +327,11 @@ export class SyncStore {
           sql: "INSERT INTO revision_checks(expected,actual) SELECT 1,CASE WHEN result IS NULL THEN 1 ELSE 0 END FROM sync_plans WHERE id=?",
           args: [planId],
         },
+        // a transfer is a bulk copy: its event changes send webhooks but
+        // never member pushes (the flag shares this transaction)
+        { sql: "UPDATE push_control SET quiet=1 WHERE id=1" },
         ...statements,
+        { sql: "UPDATE push_control SET quiet=0 WHERE id=1" },
         {
           sql: "UPDATE sync_plans SET result=json_set(?,'$.versions',json((SELECT json_group_object(entity,revision) FROM sync_versions WHERE entity IN (SELECT value FROM json_each(?))))) WHERE id=?",
           args: [JSON.stringify(result), JSON.stringify(versionKeys), planId],

package/src/middleware.ts

@@ -7,6 +7,7 @@ import { AUTH } from './lib/auth/config';
 import { getRepo } from './lib/repo';
 import { CONTENT, legacyBases, localizesRedirectsTo } from './lib/content';
 import { processDueDeliveries, waitUntilFrom } from './lib/webhooks';
+import { flushEventChanges } from './lib/calendar/hooks';
 import { dispatchEmail } from './lib/email/service';
 import { decideOverdue, sendDueReminders } from './lib/booking/service';
 import { PUSH } from './lib/push/config';
@@ -151,10 +152,14 @@ async function handle(context: APIContext, next: MiddlewareNext): Promise<Respon
     try {
       const repo = await getRepo(context.locals);
       await repo.publishDuePosts(now);
+      const wait = waitUntilFrom(context.locals);
+      // scheduled events that just went live get their webhooks (calendar/hooks.ts)
+      const changes = flushEventChanges(repo, { origin: context.url.origin, waitUntil: wait, onRedirect: invalidateRedirectCache })
+        .catch((e) => console.error('acms calendar: event changes not flushed', e));
+      if (wait) wait(changes); else await changes;
       // webhook retries ride the same once-a-minute sweep (Node has no
       // cron) — in the background, never holding up this request
       const emails = dispatchEmail(repo, context.locals, 2).catch(() => 0);
-      const wait = waitUntilFrom(context.locals);
       if (wait) wait(emails); else await emails;
       const retries = processDueDeliveries(repo).catch(() => {});
       if (wait) wait(retries); else await retries;
@@ -186,8 +191,14 @@ async function handle(context: APIContext, next: MiddlewareNext): Promise<Respon
   // Flush after mutations (including Astro actions), once their transaction
   // has committed. The scheduler remains the durable fallback on failure.
   if (!['GET', 'HEAD', 'OPTIONS'].includes(context.request.method)) {
-    const deliveries = getRepo(context.locals).then(repo => processDueDeliveries(repo, { limit: 5 })).catch(() => 0);
     const wait = waitUntilFrom(context.locals);
+    // whatever this request changed on published events, by any path: its
+    // webhooks, "event changed" pushes and slug redirects (calendar/hooks.ts)
+    const changes = getRepo(context.locals)
+      .then(repo => flushEventChanges(repo, { origin: context.url.origin, waitUntil: wait, onRedirect: invalidateRedirectCache }))
+      .catch((e) => console.error('acms calendar: event changes not flushed', e));
+    if (wait) wait(changes); else await changes;
+    const deliveries = getRepo(context.locals).then(repo => processDueDeliveries(repo, { limit: 5 })).catch(() => 0);
     if (wait) wait(deliveries); else await deliveries;
     // first-publish push notices: background only, never delaying the response
     if (PUSH.enabled) {

package/src/pages/admin/calendar/events/index.astro

@@ -14,7 +14,7 @@ import { describeRepeat } from '../../../../lib/calendar/rrule';
 import { expandVEvents, loadFeed, tzParts } from '../../../../lib/calendar/ics';
 import { normalizeCalendarSrc } from '../../../../lib/calendar/src';
 import { eventsFromCsv, eventsFromIcs, eventsFromVEvents } from '../../../../lib/calendar/import';
-import { eventChanged, eventDeleted } from '../../../../lib/calendar/hooks';
+import { flushEventChanges } from '../../../../lib/calendar/hooks';
 import { siteOrigin } from '../../../../lib/seo';
 import { siteLocale } from '../../../../lib/dates';
 import { waitUntilFrom } from '../../../../lib/webhooks';
@@ -69,7 +69,6 @@ async function saveImported(list: ReturnType<typeof eventsFromIcs>['events'], ca
 if (Astro.request.method === 'POST') {
   const form = await Astro.request.formData();
   const op = String(form.get('op'));
-  const hookOpts = { origin: siteOrigin(settings, Astro.url), waitUntil: waitUntilFrom(Astro.locals), onRedirect: invalidateRedirectCache };
   // create, copy and import make drafts; bulk status changes that touch live events need Publish
   let needs: Permission = 'content.edit';
   // answering members' event requests needs Publish (approving puts them live)
@@ -126,16 +125,12 @@ if (Astro.request.method === 'POST') {
   if (op === 'bulk') {
     const to = String(form.get('to'));
     for (const id of form.getAll('ids').map(String).filter(Boolean)) {
-      const before = await repo.getEvent(id);
-      if (!before) continue;
-      if (to === 'delete') {
-        await repo.deleteEvent(id);
-        await eventDeleted(repo, before, hookOpts);
-      } else if (to === 'published' || to === 'draft' || to === 'archived') {
+      if (to === 'delete') await repo.deleteEvent(id);
+      else if (to === 'published' || to === 'draft' || to === 'archived') {
         await repo.updateEvent(id, { status: to as Status, ...(to === 'published' ? { scheduledAt: null } : {}) });
-        await eventChanged(repo, before, (await repo.getEvent(id))!, hookOpts);
       }
     }
+    await flushEventChanges(repo, { origin: siteOrigin(settings, Astro.url), waitUntil: waitUntilFrom(Astro.locals), onRedirect: invalidateRedirectCache });
     return back();
   }
 

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>