@acms-subir/core 0.3.44 → 0.3.46

package/src/components/calendar/RoomHolds.tsx

@@ -5,7 +5,8 @@ import { actions } from 'astro:actions';
 // they can't be booked while it happens (± setup/cleanup) or all day. Each
 // room shows whether it's free at the event's time; overlapping bookings show
 // right here, with Keep (share the room) or Cancel and email. The same check
-// runs again when you publish (RoomConflictDialog).
+// runs again when you publish (RoomConflictDialog). Other events holding the
+// room at the same time show as a warning: both keep it.
 
 export interface RoomHoldValue {
   resourceIds: string[];
@@ -28,7 +29,12 @@ export interface RoomTimes {
 }
 
 interface Conflict { id: string; name: string; when: string; status: string; block: boolean }
-interface RoomRow { id: string; name: string; kind: string; capacity: number | null; conflicts: Conflict[]; datesWithBookings: number; dates: number }
+interface EventClash { id: string; eventId: string; title: string; when: string }
+interface RoomRow {
+  id: string; name: string; kind: string; capacity: number | null; conflicts: Conflict[]; datesWithBookings: number; dates: number;
+  // other events holding it at the same time (eventCount: all of them, events: the first 20)
+  events: EventClash[]; eventCount: number; datesWithEvents: number; datesBusy: number;
+}
 interface Status { rooms: RoomRow[]; holds: string }
 
 export const NO_HOLD: RoomHoldValue = { resourceIds: [], span: 'event', before: 0, after: 0, whileDraft: false, keep: [] };
@@ -77,11 +83,13 @@ export default function RoomHolds({ times, hold, status, locationName, onChange,
     if (auto) onLocation(names(ids));
   };
   const label = (r: RoomRow) => {
-    if (!r.conflicts.length) return { text: 'Free', cls: 'free' };
-    if (r.dates > 1) return { text: `Busy on ${r.datesWithBookings} of ${r.dates} dates`, cls: 'busy' };
-    return { text: r.conflicts.length === 1 ? 'Busy' : `Busy · ${r.conflicts.length} bookings`, cls: 'busy' };
+    if (!r.conflicts.length && !r.eventCount) return { text: 'Free', cls: 'free' };
+    if (r.dates > 1) return { text: `Busy on ${r.datesBusy} of ${r.dates} dates`, cls: 'busy' };
+    if (!r.conflicts.length) return { text: r.eventCount === 1 ? 'Another event' : `${r.eventCount} other events`, cls: 'busy' };
+    return { text: r.conflicts.length === 1 && !r.eventCount ? 'Busy' : `Busy · ${r.conflicts.length + r.eventCount} bookings and events`, cls: 'busy' };
   };
   const conflicted = data.rooms.filter((r) => selected.has(r.id) && r.conflicts.length);
+  const shared = data.rooms.filter((r) => selected.has(r.id) && r.eventCount);
   const draft = status === 'draft';
 
   async function cancelBookings(ids: string[]) {
@@ -157,6 +165,16 @@ export default function RoomHolds({ times, hold, status, locationName, onChange,
               )}
             </div>
           ))}
+          {shared.map((r) => (
+            <div key={r.id} className="rh-conflict rh-clash" role="status">
+              <b>{r.name} is also held by {r.eventCount === 1 ? 'another event' : `other events on ${r.eventCount} dates`}</b>
+              {r.events.slice(0, 5).map((c) => (
+                <div key={c.id} className="rh-bk"><a href={`/admin/calendar/events/${c.eventId}`} target="_blank" rel="noopener">{c.title}</a><small>{c.when}</small></div>
+              ))}
+              {r.eventCount > 5 && <small className="rh-more">+{r.eventCount - 5} more</small>}
+              <small className="rh-more">Both events keep the room. Change a time or pick another room if they can’t share it.</small>
+            </div>
+          ))}
           {note && <p className="pe-ev-note rh-done">{note}</p>}
           {data.holds && <p className="pe-ev-note">{data.holds}{draft && !hold.whileDraft ? ' once published.' : '.'}</p>}
         </>

package/src/lib/booking/holds.ts

@@ -4,6 +4,8 @@
 // moving, repeating, skipping a date, cancelling the event or one of its
 // dates, or deleting it frees or moves the room automatically. availabilityContext() adds these to its
 // busy list, so every booking path (pages, embeds, app, API, agent) obeys.
+// Two events may hold the same room at once: eventClashes() finds those for
+// staff, and roomBusy() answers "is this room taken then?" for one span.
 import type { ContentRepository } from '../repo/types';
 import type { Booking, CalEvent, Resource, Settings } from '../schema';
 import { expandEvents } from '../calendar/events';
@@ -13,6 +15,8 @@ import { resourceZone } from './availability';
 export interface Hold {
   resourceId: string;
   eventId: string;
+  // the occurrence key of the date that holds it (lib/calendar/events.ts)
+  key: string;
   title: string;
   start: number; // incl. setup
   end: number; // incl. cleanup
@@ -58,7 +62,8 @@ export function holdsFromEvents(
     // a cancelled date frees the room for that slot only
     if (o.cancelled) continue;
     const h = o.event.roomHold;
-    for (const resourceId of h.resourceIds) {
+    // the rooms this date holds
+    for (const resourceId of o.roomIds) {
       if (opts.resourceId && resourceId !== opts.resourceId) continue;
       const r = resources.get(resourceId);
       if (!r) continue;
@@ -73,7 +78,7 @@ export function holdsFromEvents(
         end = o.end + h.after * 60_000;
       }
       if (end <= from || start >= to) continue;
-      out.push({ resourceId, eventId: o.event.id, title: o.event.title || 'Event', start, end, eventStart: o.start, eventEnd: o.end });
+      out.push({ resourceId, eventId: o.event.id, key: o.key, title: o.event.title || 'Event', start, end, eventStart: o.start, eventEnd: o.end });
     }
   }
   return out.sort((a, b) => a.start - b.start);
@@ -120,3 +125,94 @@ export async function holdConflicts(
   }
   return { conflicts: conflicts.sort((a, b) => a.booking.start - b.booking.start), holds };
 }
+
+// ---- events against events ------------------------------------------------
+
+export interface EventClash {
+  /** one date of the event being checked, in one room */
+  hold: Hold;
+  /** another event's date holding that room at an overlapping time */
+  other: Hold;
+}
+
+/**
+ * Other events holding the same rooms at overlapping times (setup and cleanup
+ * included), soonest first. Like holdConflicts, `event` may be unsaved and is
+ * checked as if published; the others count only while they hold rooms
+ * (published or scheduled, drafts with "Hold now", not cancelled). These are
+ * warnings for staff: both events keep the room.
+ */
+export async function eventClashes(
+  repo: ContentRepository,
+  settings: Pick<Settings, 'timezone'>,
+  event: CalEvent,
+  opts: { now?: number; horizonDays?: number } = {}
+): Promise<{ clashes: EventClash[]; holds: Hold[] }> {
+  const now = opts.now ?? Date.now();
+  const to = now + (opts.horizonDays ?? 366) * DAY;
+  const [events, resources] = await Promise.all([repo.listEvents(), repo.listResources()]);
+  const byId = new Map(resources.map((r) => [r.id, r]));
+  const holds = holdsFromEvents([event], byId, settings, now, to, { force: true });
+  if (!holds.length) return { clashes: [], holds };
+  const rooms = new Set(holds.map((h) => h.resourceId));
+  const others = events.filter((e) => e.id !== event.id && e.roomHold.resourceIds.some((id) => rooms.has(id)));
+  const from = Math.min(...holds.map((h) => h.start)), until = Math.max(...holds.map((h) => h.end));
+  const theirs = holdsFromEvents(others, byId, settings, from, until);
+  const clashes: EventClash[] = [];
+  for (const hold of holds) {
+    for (const other of theirs) {
+      if (other.resourceId === hold.resourceId && other.start < hold.end && other.end > hold.start) clashes.push({ hold, other });
+    }
+  }
+  return { clashes, holds };
+}
+
+export interface BusySlot {
+  resourceId: string;
+  start: number;
+  end: number;
+  /** an event holding it, a booking, a staff block, or one of its busy calendars */
+  kind: 'event' | 'booking' | 'block' | 'calendar';
+  /** the event's title, the booker's name or the block's note; '' for busy calendars. Staff only. */
+  title: string;
+  eventId?: string;
+  /** the event date's occurrence key */
+  key?: string;
+  bookingId?: string;
+}
+
+/**
+ * Everything that takes these rooms in [from, to): event holds (setup and
+ * cleanup included), pending and confirmed bookings and blocks, and the rooms'
+ * busy calendars. `ignore` leaves out one event, or one date of it (its key):
+ * the date being moved doesn't block its own new time. Names are for staff;
+ * the public free/busy check (GET /api/v1/rooms/free) only reports the times.
+ */
+export async function roomBusy(
+  repo: ContentRepository,
+  settings: Pick<Settings, 'timezone'>,
+  q: { resourceIds: string[]; from: number; to: number; ignore?: { eventId: string; key?: string }; now?: number }
+): Promise<BusySlot[]> {
+  const ids = new Set(q.resourceIds);
+  if (!ids.size || q.to <= q.from) return [];
+  const [events, resources] = await Promise.all([repo.listEvents(), repo.listResources()]);
+  const rooms = resources.filter((r) => ids.has(r.id));
+  const byId = new Map(rooms.map((r) => [r.id, r]));
+  const out: BusySlot[] = [];
+  const holding = events.filter((e) => e.roomHold.resourceIds.some((id) => ids.has(id)) && !(q.ignore && e.id === q.ignore.eventId && !q.ignore.key));
+  for (const h of holdsFromEvents(holding, byId, settings, q.from, q.to)) {
+    if (q.ignore?.key && h.eventId === q.ignore.eventId && h.key === q.ignore.key) continue;
+    out.push({ resourceId: h.resourceId, start: h.start, end: h.end, kind: 'event', title: h.title, eventId: h.eventId, key: h.key });
+  }
+  // dynamic: service.ts imports this module
+  const { busyIntervals } = await import('./service');
+  await Promise.all(rooms.map(async (r) => {
+    const bookings = await repo.listBookings({ resourceId: r.id, from: q.from, to: q.to, statuses: ['pending', 'confirmed'], kinds: ['booking', 'block'] });
+    // a booking's real time, as holdConflicts compares it
+    for (const b of bookings) out.push({ resourceId: r.id, start: b.start, end: b.end, kind: b.kind === 'block' ? 'block' : 'booking', title: b.kind === 'block' ? b.notes : b.name, bookingId: b.id });
+    for (const i of await busyIntervals(r, q.from, q.to, q.now ?? Date.now())) {
+      if (i.end > q.from && i.start < q.to) out.push({ resourceId: r.id, start: i.start, end: i.end, kind: 'calendar', title: '' });
+    }
+  }));
+  return out.sort((a, b) => a.start - b.start || a.end - b.end);
+}

package/src/lib/booking/service.ts

@@ -50,7 +50,8 @@ export const WAITLIST_HOLD = 24 * 3_600_000;
 
 const busyCache = new Map<string, { at: number; intervals: Interval[] }>();
 
-async function busyIntervals(resource: Resource, from: number, to: number, now: number): Promise<Interval[]> {
+/** a resource's busy calendars (Resource.busyFeeds) in [from, to), cached for 5 minutes */
+export async function busyIntervals(resource: Resource, from: number, to: number, now: number): Promise<Interval[]> {
   if (!resource.busyFeeds.length) return [];
   const key = `${resource.id}:${resource.busyFeeds.join('|')}:${Math.floor(from / 86_400_000)}`;
   const hit = busyCache.get(key);

package/src/lib/calendar/agent.ts

@@ -11,7 +11,7 @@ import { CALENDAR } from './config';
 import { EventToolInputs } from './agent-schema';
 import { featuredOccurrence, formatOccurrence, isValidTimeZone, normalizeEventTimes } from './events';
 import { mergeEventDraft } from '../drafts';
-import { eventChanged } from './hooks';
+import { flushEventChanges } from './hooks';
 import { eventToJson } from './api';
 import { siteLocale } from '../dates';
 import { EventLocation } from '../schema';
@@ -110,7 +110,8 @@ export async function runEventTool(repo: ContentRepository, input: EventToolInpu
     case 'get_event': {
       const e = await repo.getEvent(input.arguments.id);
       if (!e) throw new ApiError(404, 'Event not found.');
-      return { ...eventToJson(mergeEventDraft(e), ctx.origin, calMap, settings.timezone, { includePrivate: true }), bodyHtml: mergeEventDraft(e).bodyHtml, hasPendingDraft: Boolean(e.draft), editUrl: editUrl(e.id) };
+      const rooms = new Map((await repo.listResources()).map((r) => [r.id, r]));
+      return { ...eventToJson(mergeEventDraft(e), ctx.origin, calMap, settings.timezone, { includePrivate: true, resources: rooms }), bodyHtml: mergeEventDraft(e).bodyHtml, hasPendingDraft: Boolean(e.draft), editUrl: editUrl(e.id) };
     }
     case 'create_event': {
       const a = input.arguments;
@@ -168,9 +169,8 @@ export async function runEventTool(repo: ContentRepository, input: EventToolInpu
       if (!before) throw new ApiError(404, 'Event not found.');
       if (before.draft) await repo.applyEventDraft(before.id);
       await repo.updateEvent(before.id, { status: 'published', scheduledAt: null });
-      const after = (await repo.getEvent(before.id))!;
-      await eventChanged(repo, before, after, { origin: ctx.origin, waitUntil: ctx.waitUntil, applied: Boolean(before.draft) });
-      return { ...summary(after) };
+      await flushEventChanges(repo, { origin: ctx.origin, waitUntil: ctx.waitUntil });
+      return { ...summary((await repo.getEvent(before.id))!) };
     }
   }
 }

package/src/lib/calendar/api.ts

@@ -2,8 +2,8 @@
 // webhook payloads and agent tools, so integrations see the same fields
 // everywhere. Drafts, internal ids of private calendars, staging data and
 // private custom fields (unless a staff caller asks for them) never appear
-// here.
-import type { CalEvent, Calendar } from '../schema';
+// here. Rooms are named only when set to show on public events (or for staff).
+import { roomColor, type CalEvent, type Calendar, type Resource } from '../schema';
 import { calendarFeedUrl, eventIcsUrl, eventUrl, publicEventFields } from './config';
 import { describeRepeat } from './rrule';
 
@@ -33,13 +33,25 @@ export interface EventJson {
   imageAlt: string;
   tags: string[];
   calendars: { id: string; slug: string; name: string; color: string }[];
+  // the rooms it holds (roomHold.resourceIds); color null = the room has none
+  rooms: RoomJson[];
   fields: Record<string, string>;
   updatedAt: string;
 }
 
+export interface RoomJson { slug: string; name: string; color: string | null }
+
+/** Rooms as public data: only those set to show on public events, unless `includePrivate` (staff). Unknown ids are skipped. */
+export function roomsToJson(ids: string[], resources: Map<string, Resource> | undefined, includePrivate = false): RoomJson[] {
+  if (!resources) return [];
+  return ids.map((id) => resources.get(id)).filter((r): r is Resource => Boolean(r) && (includePrivate || r!.showOnEvents))
+    .map((r) => ({ slug: r.slug, name: r.name, color: roomColor(r) || null }));
+}
+
 const abs = (origin: string, path: string) => (/^https?:\/\//.test(path) ? path : origin + path);
 
-export function eventToJson(e: CalEvent, origin: string, calendars: Map<string, Calendar>, siteTz = '', opts: { includePrivate?: boolean } = {}): EventJson {
+// resources: every room by id (rooms stay [] without it)
+export function eventToJson(e: CalEvent, origin: string, calendars: Map<string, Calendar>, siteTz = '', opts: { includePrivate?: boolean; resources?: Map<string, Resource> } = {}): EventJson {
   return {
     id: e.id,
     slug: e.slug,
@@ -68,6 +80,7 @@ export function eventToJson(e: CalEvent, origin: string, calendars: Map<string,
       .map((id) => calendars.get(id))
       .filter((c): c is Calendar => Boolean(c) && c!.visibility !== 'private')
       .map((c) => ({ id: c.id, slug: c.slug, name: c.name, color: c.color })),
+    rooms: roomsToJson(e.roomHold.resourceIds, opts.resources, opts.includePrivate),
     fields: opts.includePrivate ? e.fields : publicEventFields(e.fields),
     updatedAt: new Date(e.updatedAt).toISOString(),
   };

package/src/lib/calendar/change-migration.ts

@@ -0,0 +1,65 @@
+// v65: every write that touches a published event (editor, Schedule, agent,
+// REST, scheduled publishing, place refresh, environment sync, any raw SQL)
+// leaves a row in event_changes, written by triggers in the same transaction:
+// the event as it was and as written. lib/calendar/hooks.ts drains it into the
+// side effects (webhook, "event changed" push, slug redirect), so no caller
+// has to remember to. Its own table, not a shared "last change" column, so
+// other features can keep their own queues from their own triggers on events.
+//
+// Only changes a visitor can see are recorded (CHANGED): hosts, members'
+// requests, staged drafts and bookkeeping never are. Restores run
+// with webhook_control.suppressed=1 and record nothing. Environment sync sets
+// push_control.quiet=1 for its transaction: its changes still send webhooks,
+// but never member pushes (its first publishes are recorded as skipped, like
+// restores). Posts keep their v37 triggers.
+//
+// Frozen with v65: a later events column joins by a new migration that
+// recreates these triggers (the test that sorts every column fails until then).
+const now = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+
+/** the columns copied into each snapshot (what the webhook payload and push rules read) */
+export const EVENT_CHANGE_SNAPSHOT = ['id', 'slug', 'title', 'excerpt', 'cover', 'cover_alt', 'status', 'featured', 'tags',
+  'starts', 'ends', 'all_day', 'timezone', 'rrule', 'exdates', 'cancelled', 'cancelled_dates', 'location', 'cta', 'calendar_ids',
+  'fields', 'rsvp', 'room_hold', 'start_at', 'end_at', 'published_at', 'scheduled_at', 'created_at', 'updated_at'];
+/** the columns whose change counts (published_at and scheduled_at follow status; room_hold names the rooms public data shows) */
+export const EVENT_CHANGE_COLUMNS = ['slug', 'title', 'body_json', 'body_html', 'excerpt', 'cover', 'cover_alt', 'seo_title', 'seo_desc',
+  'status', 'featured', 'tags', 'template', 'starts', 'ends', 'all_day', 'timezone', 'rrule', 'exdates', 'cancelled', 'cancelled_dates',
+  'location', 'cta', 'calendar_ids', 'fields', 'rsvp', 'translations', 'room_hold', 'start_at', 'end_at'];
+/** columns no change is recorded for */
+export const EVENT_CHANGE_IGNORED = ['id', 'draft', 'host_ids', 'request', 'source_uid', 'published_at', 'scheduled_at', 'created_at', 'updated_at'];
+
+const snapshot = (row: 'OLD' | 'NEW') => `json_object(${EVENT_CHANGE_SNAPSHOT.map((c) => `'${c}',${row}.${c}`).join(',')})`;
+const live = '(SELECT suppressed FROM webhook_control WHERE id=1)=0';
+const quiet = 'COALESCE((SELECT quiet FROM push_control WHERE id=1),0)';
+const record = (id: string, before: string, after: string) => `INSERT INTO event_changes (event_id,old_row,new_row,quiet,created_at)
+  VALUES (${id},${before},${after},${quiet},${now});`;
+const changed = EVENT_CHANGE_COLUMNS.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(' OR ');
+
+// v37's first-publish ledger rows, now also skipped while push_control.quiet is set
+const skipped = `CASE WHEN (SELECT suppressed FROM webhook_control WHERE id=1)=1 OR ${quiet}=1 THEN 'skipped' ELSE 'pending' END`;
+const ledger = `INSERT INTO push_queue (key,kind,doc_id,occurrence,status,notification_id,created_at,updated_at)
+    SELECT 'event:'||NEW.id,'event',NEW.id,NULL,${skipped},NULL,${now},${now}
+    WHERE NOT EXISTS (SELECT 1 FROM push_queue WHERE key='event:'||NEW.id);`;
+
+export const EVENT_CHANGES_MIGRATION = { version: 65, statements: [
+  `CREATE TABLE event_changes (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT, event_id TEXT NOT NULL, old_row TEXT, new_row TEXT,
+    quiet INTEGER NOT NULL DEFAULT 0, attempts INTEGER NOT NULL DEFAULT 0, claimed_until INTEGER NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL
+  )`,
+  `CREATE INDEX event_changes_event ON event_changes (event_id, claimed_until)`,
+  `CREATE TABLE push_control (id INTEGER PRIMARY KEY CHECK(id=1), quiet INTEGER NOT NULL DEFAULT 0)`,
+  `INSERT INTO push_control (id,quiet) VALUES (1,0)`,
+  `CREATE TRIGGER event_changes_insert AFTER INSERT ON events WHEN NEW.status='published' AND ${live}
+    BEGIN ${record('NEW.id', 'NULL', snapshot('NEW'))} END`,
+  `CREATE TRIGGER event_changes_update AFTER UPDATE ON events
+    WHEN (OLD.status='published' OR NEW.status='published') AND (${changed}) AND ${live}
+    BEGIN ${record('NEW.id', snapshot('OLD'), snapshot('NEW'))} END`,
+  `CREATE TRIGGER event_changes_delete AFTER DELETE ON events WHEN OLD.status='published' AND ${live}
+    BEGIN ${record('OLD.id', snapshot('OLD'), 'NULL')} END`,
+  `DROP TRIGGER push_event_insert`,
+  `DROP TRIGGER push_event_publish`,
+  `CREATE TRIGGER push_event_insert AFTER INSERT ON events WHEN NEW.status='published' BEGIN ${ledger} END`,
+  `CREATE TRIGGER push_event_publish AFTER UPDATE OF status ON events
+      WHEN NEW.status='published' AND OLD.status IS NOT 'published' BEGIN ${ledger} END`,
+] };

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

@@ -1,42 +1,87 @@
-// Side effects when an event changes live: a 301 when a published event's
-// slug moves, a queued "event changed" app notice when its schedule or place
-// moves, and the matching webhook (event.published / event.updated /
-// event.unpublished). Shared by the editor actions, the list's bulk actions
-// and the agent tools so every path behaves the same.
-import type { ContentRepository } from '../repo/types';
-import type { CalEvent } from '../schema';
+// Side effects when a published event changes: a 301 when its slug moves, a
+// queued "event changed" app notice when its schedule or place moves, and the
+// matching webhook (event.published / event.updated / event.unpublished /
+// event.deleted). Every write path records its changes in event_changes
+// (triggers, ./change-migration.ts) in the same transaction, so this is the
+// one place they become side effects, whoever made them. Editor paths flush
+// at once (the redirect works on the very next request); the flush after
+// every mutating request and the scheduler catch the rest, raw SQL included
+// (scheduled publishing, environment sync, place refreshes).
+import type { ContentRepository, EventChange } from '../repo/types';
+import type { Calendar, Resource, Settings } from '../schema';
 import { emitWebhook } from '../webhooks';
-import { queueEventChange } from '../push/service';
+import { queueEventChange, siteOriginOf } from '../push/service';
 import { eventToJson } from './api';
 import { eventUrl } from './config';
 
-export async function eventChanged(
-  repo: ContentRepository,
-  before: CalEvent,
-  after: CalEvent,
-  opts: { origin: string; waitUntil?: (p: Promise<unknown>) => void; applied?: boolean; onRedirect?: () => void }
-): Promise<void> {
-  if (before.status === 'published' && after.status === 'published' && before.slug !== after.slug) {
+export interface FlushOptions {
+  /** this request's origin, for webhook links while the site URL isn't set */
+  origin?: string;
+  waitUntil?: (p: Promise<unknown>) => void;
+  /** called when a slug redirect was added (the middleware drops its cached rules) */
+  onRedirect?: () => void;
+  now?: number;
+}
+
+const BATCH = 50;
+const ROUNDS = 20;
+/** how long a claim holds its changes; one that failed is retried after it */
+const LEASE = 5 * 60_000;
+/** a change that failed this many times is dropped */
+const MAX_ATTEMPTS = 3;
+
+interface Site { origin: string; settings: Settings; calendars: Map<string, Calendar>; resources: Map<string, Resource> }
+
+// One write, as webhooks for posts report them: several writes in one save
+// send one webhook each. The push queue keeps what people last knew, so
+// several changes close together still send one notice.
+async function apply(repo: ContentRepository, change: EventChange, now: number, site: () => Promise<Site>, opts: FlushOptions) {
+  const { before, after } = change;
+  const was = before?.status === 'published';
+  if (was && after?.status === 'published' && before.slug !== after.slug) {
     await repo.createRedirect({ fromPath: eventUrl(before.slug), toPath: eventUrl(after.slug) }).catch(() => {});
     opts.onRedirect?.();
   }
-  // the scheduler sends it once the edits settle, if the rule still applies
-  await queueEventChange(repo, before, after).catch((e) => console.error('acms push: event change not queued', e));
-  let type: 'event.published' | 'event.updated' | 'event.unpublished' | null = null;
-  if (before.status !== 'published' && after.status === 'published') type = 'event.published';
-  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';
+  // the scheduler sends it once the edits settle, if the rule still applies;
+  // a bulk copy (quiet) sends webhooks and redirects, never pushes
+  if (before && after && !change.quiet) await queueEventChange(repo, before, after, now).catch((e) => console.error('acms push: event change not queued', e));
+  if (!after) {
+    if (was) await emitWebhook(repo, 'event.deleted', { event: { id: before.id, slug: before.slug, title: before.title } }, { waitUntil: opts.waitUntil }).catch(() => {});
+    return;
+  }
+  const type = was ? (after.status === 'published' ? 'event.updated' : 'event.unpublished') : after.status === 'published' ? 'event.published' : null;
   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);
-  await emitWebhook(repo, type, { event: data }, { waitUntil: opts.waitUntil }).catch(() => {});
+  const { origin, settings, calendars, resources } = await site();
+  await emitWebhook(repo, type, { event: eventToJson(after, origin, calendars, settings.timezone, { resources }) }, { waitUntil: opts.waitUntil }).catch(() => {});
 }
 
-export async function eventDeleted(
-  repo: ContentRepository,
-  before: CalEvent | null,
-  opts: { waitUntil?: (p: Promise<unknown>) => void }
-): Promise<void> {
-  if (before?.status !== 'published') return;
-  await emitWebhook(repo, 'event.deleted', { event: { id: before.id, slug: before.slug, title: before.title } }, opts).catch(() => {});
+/** Runs the side effects of every recorded change to a published event, oldest first. Returns how many changes it handled. */
+export async function flushEventChanges(repo: ContentRepository, opts: FlushOptions = {}): Promise<number> {
+  let site: Promise<Site> | null = null;
+  const load = () => (site ??= Promise.all([repo.getSettings(), repo.listCalendars(), repo.listResources()]).then(([settings, calendars, rooms]) => ({
+    origin: siteOriginOf(settings, opts.origin), settings, calendars: new Map(calendars.map((c) => [c.id, c])), resources: new Map(rooms.map((r) => [r.id, r])) })));
+  let handled = 0;
+  for (let round = 0; round < ROUNDS; round++) {
+    const now = opts.now ?? Date.now();
+    const claimed = await repo.claimEventChanges(now, BATCH, LEASE);
+    if (!claimed.length) break;
+    const done: number[] = [];
+    const failed = new Set<string>();
+    for (const change of claimed) {
+      // a later change to an event whose earlier one failed waits with it, in order
+      if (failed.has(change.eventId)) continue;
+      try {
+        // a snapshot that no longer parses has nothing to report
+        if (change.before || change.after) await apply(repo, change, now, load, opts);
+      } catch (e) {
+        console.error('acms calendar: event change side effects failed', e);
+        if (change.attempts < MAX_ATTEMPTS) { failed.add(change.eventId); continue; }
+      }
+      done.push(change.seq);
+    }
+    await repo.finishEventChanges(done);
+    handled += done.length;
+    if (claimed.length < BATCH) break;
+  }
+  return handled;
 }

package/src/lib/calendar/requests.ts

@@ -2,10 +2,9 @@ import type { ContentRepository } from '../repo/types';
 import type { CalEvent, EventRequest } from '../schema';
 import { EventLocation } from '../schema';
 import { ApiError } from '../api';
-import { applyEventUpdate, saveEvent, type SaveHooks } from '../content-service';
+import { applyEventUpdate, flushEventHooks, saveEvent, type SaveHooks } from '../content-service';
 import { CALENDAR } from './config';
 import { cancelOccurrence, restoreOccurrence, uniqueSlug } from './schedule';
-import { eventDeleted } from './hooks';
 import { waitUntilFrom } from '../webhooks';
 import { kickEmail } from '../email/service';
 
@@ -191,7 +190,7 @@ export async function withdrawEventRequest(repo: ContentRepository, who: Actor |
   // only an event the member's own request made is deleted; a draft staff wrote stays
   if (e.request.kind === 'new' && e.request.created && !live(e) && !e.publishedAt) {
     await repo.deleteEvent(id);
-    await eventDeleted(repo, e, { waitUntil: waitUntilFrom(hooks.locals) });
+    await flushEventHooks(repo, hooks);
     return { deleted: true };
   }
   if (e.request.kind === 'changes') await repo.discardEventDraft(id);

package/src/lib/calendar/schedule.ts

@@ -10,10 +10,9 @@ import type { CalEvent } from '../schema';
 import { EventLocation, slugify } from '../schema';
 import { defaultPlaceLocation } from '../maps/places';
 import { ApiError } from '../api';
-import { applyEventUpdate, eventSideEffects, saveEvent, type SaveHooks } from '../content-service';
+import { applyEventUpdate, eventSideEffects, flushEventHooks, saveEvent, type SaveHooks } from '../content-service';
 import { addWallDays, findOccurrence, formatWall, parseWall } from './events';
 import { rruleMap, WEEKDAY_CODES, weekdayOf } from './rrule';
-import { eventDeleted } from './hooks';
 import { waitUntilFrom } from '../webhooks';
 import { kickEmail } from '../email/service';
 
@@ -114,6 +113,7 @@ export async function moveSeries(repo: ContentRepository, id: string, days: numb
   // cancelled dates move with the series, like skipped ones
   if (e.rrule && e.cancelledDates.length) {
     await repo.setEventCancelledDates(id, e.cancelledDates.map((x) => shift(x, days)));
+    await flushEventHooks(repo, hooks);
     event = (await repo.getEvent(id))!;
   }
   return { event, undo: { kind: 'series', id, days: -days } };
@@ -177,7 +177,7 @@ export async function undoMove(repo: ContentRepository, undo: MoveUndo, hooks: S
       await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals));
     }
     await repo.deleteEvent(copy.id);
-    await eventDeleted(repo, copy, { waitUntil: waitUntilFrom(hooks.locals) });
+    await flushEventHooks(repo, hooks);
   }
 }
 
@@ -202,7 +202,7 @@ async function setOccurrenceCancelled(repo: ContentRepository, id: string, key:
   await repo.setEventCancelledDates(id, cancel ? [...e.cancelledDates, key].sort() : e.cancelledDates.filter((x) => x !== key));
   if (cancel && await repo.cancelOccurrenceRsvps(id, o.start)) await kickEmail(repo, hooks.locals, waitUntilFrom(hooks.locals));
   const after = (await repo.getEvent(id))!;
-  await eventSideEffects(repo, hooks, e, after);
+  await eventSideEffects(repo, hooks, after);
   return after;
 }