@acms-subir/core 0.3.45 → 0.3.47

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;
 }
 

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { ContentRepository } from '../repo/types';
-import { publicTags, tagFilter, type BookingLink, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
+import { type BookingLink, type CalEvent, type Calendar, type Resource, type Settings } from '../schema';
 import { ApiError } from '../api';
 import { CALENDAR, bookingsEnabled, resourceUrl, bookingLinkUrl, publicEventFields } from '../calendar/config';
 import { calendarToJson, eventToJson, roomsToJson } from '../calendar/api';
@@ -17,6 +17,7 @@ import { localizeDoc } from '../translations';
 import { localeQuery, mobileLocale, localizedUrl } from './locale';
 import { confirmsInstantly, linkApproval } from '../booking/approval';
 import { changeTopics } from '../push/service';
+import { occurrenceMatches, readEventFilter, resolveEventFilter, tagsMatch } from '../calendar/filter';
 
 export function requireCalendar(bookings = false) {
   if (!CALENDAR.enabled || (bookings && !bookingsEnabled())) throw new ApiError(404, 'This feature is disabled.');
@@ -27,14 +28,24 @@ export async function listCalendars(repo: ContentRepository, url: URL) {
   const origin = siteOrigin(await repo.getSettings(), url);
   return { calendars: (await repo.listCalendars()).filter(c => c.visibility === 'public').map(c => calendarToJson(c, origin)) };
 }
-// tag/excludeTag: a public tag's name or slug (internal "#" tags are never matched, as they are never shown)
-export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: isoDayOrInstant.optional(), to: isoDayOrInstant.optional(), calendar: z.string().min(1).max(200).optional(),
-  tag: z.string().min(1).max(100).optional(), excludeTag: z.string().min(1).max(100).optional(), q: z.string().max(100).optional() }).strict();
+// The website calendar's filters (calendar/filter.ts). Each takes one or more
+// values, comma-separated or repeated. Tags are a public tag's name or slug
+// (internal "#" tags never match, as they are never shown).
+const FILTER_LISTS = ['calendar', 'cal', 'tag', 'excludeTag', 'notag', 'room'] as const;
+const filterList = (what: string) => z.string().min(1).max(2100)
+  .refine((v) => { const parts = v.split(','); return parts.length <= 20 && parts.every((p) => p.trim().length <= 100); }, 'Use up to 20 values of up to 100 characters each.')
+  .optional().describe(`${what} One or more, comma-separated (a,b) or repeated.`);
+export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: isoDayOrInstant.optional(), to: isoDayOrInstant.optional(),
+  calendar: filterList('Only events in these calendars (slugs).'), cal: filterList('Alias of calendar.'),
+  tag: filterList('Only events with one of these tags (a name in any case, or a slug).'), excludeTag: filterList('Leave out events with any of these tags.'), notag: filterList('Alias of excludeTag.'),
+  room: filterList('Only events held in one of these rooms (slugs of rooms shown on public events).'),
+  q: z.string().max(100).optional() }).strict();
 export async function listEvents(repo: ContentRepository, url: URL) {
   requireCalendar();
-  const q = eventsQuery.parse(queryParams(url));
+  const q = eventsQuery.parse(queryParams(url, FILTER_LISTS));
   const locale = mobileLocale(q.locale);
   const term = q.q?.trim() ?? '';
+  const filter = readEventFilter(url.searchParams);
   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]);
@@ -47,14 +58,18 @@ export async function listEvents(repo: ContentRepository, url: URL) {
   const to = q.to ? at(q.to) : fromDay.length === 10 ? localMidnight(addDaysYmd(fromDay, 30), tz) : from + 30 * 86400000;
   if (to <= from || to - from > 90 * 86400000 + 3600000) throw new ApiError(400, 'Use an event window of 1 to 90 days.');
   const all = new Map(calendars.map(c => [c.id, c]));
-  const cal = q.calendar ? calendars.find(c => c.slug === q.calendar && c.visibility !== 'private') : null;
-  if (q.calendar && !cal) throw new ApiError(404, 'Calendar not found.');
-  const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public' || c.id === cal?.id).map(c => [c.id, c]));
-  const tagged = tagFilter(q.tag, q.excludeTag);
-  const visible = events.map(e => localizeDoc(e, locale ?? undefined)).filter(e => (cal ? e.calendarIds.includes(cal.id) && eventIsPublic(e, all) : eventIsListed(e, all))
-    && tagged(publicTags(e.tags))
+  // private calendars and rooms not shown on public events answer like missing ones
+  const f = resolveEventFilter(filter, { calendars, resources: [...resources.values()] });
+  if (f.calendarIds && f.calendarIds.length < filter.cal.length) throw new ApiError(404, 'Calendar not found.');
+  if (f.roomIds && f.roomIds.length < filter.room.length) throw new ApiError(404, 'Room not found.');
+  const picked = f.calendarIds;
+  const publicCalendars = new Map(calendars.filter(c => c.visibility === 'public' || picked?.includes(c.id)).map(c => [c.id, c]));
+  const visible = events.map(e => localizeDoc(e, locale ?? undefined)).filter(e => (picked ? e.calendarIds.some(id => picked.includes(id)) && eventIsPublic(e, all) : eventIsListed(e, all))
+    && tagsMatch(f, e.tags)
     && (!term || indexed!.has(e.id) || `${e.title} ${e.excerpt} ${e.location.name}`.toLowerCase().includes(term.toLowerCase())));
-  const occurrences = expandEvents(visible, settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: from, windowEndMs: to });
+  const occurrences = expandEvents(visible, settings, { displayTz: settings.timezone || 'UTC', now: Date.now(), windowStartMs: from, windowEndMs: to })
+    // rooms are per date (a moved date can change them)
+    .filter(o => !f.roomIds || occurrenceMatches(f, o));
   occurrences.sort((a, b) => a.start - b.start || (a.event.id < b.event.id ? -1 : a.event.id > b.event.id ? 1 : 0));
   const start = (q.page - 1) * q.limit;
   const origin = siteOrigin(settings, url);

package/src/lib/mobile/http.ts

@@ -43,11 +43,13 @@ export async function limitRequest(repo: ContentRepository, address: string, wri
   const key = `mobile:${write ? 'write' : 'read'}:${await sha256Hex(address)}`;
   if (!await repo.email.rateLimit(key, write ? 20 : 300, 60_000)) throw new ApiError(429, 'Too many requests. Try again in a minute.');
 }
-export function queryParams(url: URL) {
+// lists: parameters that may repeat (tag=a&tag=b); their values are joined
+// with commas, the same as tag=a,b
+export function queryParams(url: URL, lists: readonly string[] = []) {
   const result: Record<string, string> = {};
   for (const [key, value] of url.searchParams) {
-    if (key in result) throw new ApiError(400, `Duplicate query parameter: ${key}.`);
-    result[key] = value;
+    if (key in result && !lists.includes(key)) throw new ApiError(400, `Duplicate query parameter: ${key}.`);
+    result[key] = key in result ? `${result[key]},${value}` : value;
   }
   return result;
 }

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';
@@ -720,6 +721,9 @@ export const MIGRATIONS: Migration[] = [
     `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.

package/src/lib/repo/sql.ts

@@ -1030,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 {
@@ -1866,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/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/api/calendar/docs.ts

@@ -59,6 +59,8 @@ Add endpoints in Team → API & webhooks. Events: event.published, event.updated
 Each POST has headers X-Acms-Event, X-Acms-Delivery, X-Acms-Timestamp and
 X-Acms-Signature: sha256=<hex HMAC-SHA256(secret, "<timestamp>.<raw body>")>.
 Body: { "id", "type", "createdAt", "data": { ... } }. Failed deliveries retry after 1, 10 and 60 minutes.
+event.* fire however an event changes: the editor, Schedule, this API, agent tools, scheduled
+publishing, a saved place's new address and environment sync. Restores send site.restored instead.
 
 ## MCP / agent tools
 

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

@@ -7,7 +7,7 @@ import { CALENDAR } from '../../../../lib/calendar/config';
 import { eventIsPublic } from '../../../../lib/calendar/events';
 import { eventToJson } from '../../../../lib/calendar/api';
 import { runAgentTool } from '../../../../lib/agent';
-import { eventDeleted } from '../../../../lib/calendar/hooks';
+import { flushEventChanges } from '../../../../lib/calendar/hooks';
 import { mergeEventDraft } from '../../../../lib/drafts';
 import { waitUntilFrom } from '../../../../lib/webhooks';
 import { fail, preflight, withCors } from '../../../../lib/calendar/http';
@@ -50,14 +50,14 @@ export const PATCH: APIRoute = async ({ request, locals, url, params }) => {
   } catch (err) { return fail(err); }
 };
 
-export const DELETE: APIRoute = async ({ request, locals, params }) => {
+export const DELETE: APIRoute = async ({ request, locals, url, params }) => {
   try {
     const repo = await getRepo(locals);
     await requireScope(request, repo, 'events:write');
     const e = await find(repo, params.id!);
     if (!e) throw new ApiError(404, 'Event not found.');
     await repo.deleteEvent(e.id);
-    await eventDeleted(repo, e, { waitUntil: waitUntilFrom(locals) });
+    await flushEventChanges(repo, { origin: url.origin, waitUntil: waitUntilFrom(locals) });
     return withCors(json({ deleted: e.id }));
   } catch (err) { return fail(err); }
 };

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

@@ -14,16 +14,20 @@ import { readJson } from '../../../../lib/api';
 import { runAgentTool } from '../../../../lib/agent';
 import { waitUntilFrom } from '../../../../lib/webhooks';
 import { fail } from '../../../../lib/calendar/http';
-import { publicTags, tagFilter } from '../../../../lib/schema';
+import { occurrenceMatches, readEventFilter, resolveEventFilter, tagsMatch } from '../../../../lib/calendar/filter';
 
 // Public read API for other sites, apps and lobby screens.
 //   GET /api/calendar/events?from=2026-10-01&to=2026-10-31&calendar=youth&q=night
 //   GET /api/calendar/events?tag=class (or excludeTag=class; a tag's name or slug)
+//   GET /api/calendar/events?calendar=youth,events&notag=Class&room=chapel
+//   (the /calendar page's filters: each takes several values, comma-separated
+//   or repeated; cal and notag are aliases of calendar and excludeTag)
 //   → { timezone, from, to, occurrences: [{ id, start, end, allDay, cancelled, event }] }
 //   GET /api/calendar/events?expand=0 → { events: [...] } (rules, not instances)
 // Anonymous callers see public calendars (and an unlisted one when asked by
 // slug). A key with events:read also sees private calendars and private
-// custom fields, and its tag filters also match internal "#" tags.
+// custom fields, its tag filters also match internal "#" tags, and its room
+// filter matches every room (anonymous callers: rooms shown on public events).
 const CORS = {
   'Access-Control-Allow-Origin': '*',
   'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
@@ -43,28 +47,28 @@ 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 filter = readEventFilter(url.searchParams);
     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');
-    const cal = slug ? calendars.find((c) => c.slug === slug) : null;
-    if (slug && (!cal || (cal.visibility === 'private' && !full))) throw new ApiError(404, 'Unknown calendar.');
+    const f = resolveEventFilter(filter, { calendars, resources: rooms, allowPrivate: full });
+    if (f.calendarIds && f.calendarIds.length < filter.cal.length) throw new ApiError(404, 'Unknown calendar.');
+    if (f.roomIds && f.roomIds.length < filter.room.length) throw new ApiError(404, 'Unknown room.');
+    const picked = f.calendarIds;
     const q = (url.searchParams.get('q') ?? '').trim().toLowerCase();
     let events = published.filter((e) => {
-      if (cal) return e.calendarIds.includes(cal.id) && (full || eventIsPublic(e, map));
+      if (picked) return e.calendarIds.some((id) => picked.includes(id)) && (full || eventIsPublic(e, map));
       return full ? true : eventIsListed(e, map);
     });
     if (q) events = events.filter((e) => `${e.title} ${e.excerpt} ${e.location.name}`.toLowerCase().includes(q));
-    const tag = url.searchParams.get('tag')?.slice(0, 100), excludeTag = url.searchParams.get('excludeTag')?.slice(0, 100);
-    if (tag || excludeTag) {
-      const tagged = tagFilter(tag, excludeTag);
-      events = events.filter((e) => tagged(full ? e.tags : publicTags(e.tags)));
-    }
+    events = events.filter((e) => tagsMatch(f, e.tags, { internal: full }));
 
     if (url.searchParams.get('expand') === '0') {
+      // rules, not dates: a room filter matches the series' own rooms
+      if (f.roomIds) events = events.filter((e) => occurrenceMatches(f, { event: e }));
       return withCors(json({ timezone: tz, events: events.map((e) => eventToJson(e, origin, map, settings.timezone, { includePrivate: full, resources })) }));
     }
     const day = (param: string, fallback: number) => {
@@ -76,7 +80,9 @@ export const GET: APIRoute = async ({ request, locals, url }) => {
     const to = Math.min(day('to', from + 90 * 86_400_000), from + 400 * 86_400_000);
     if (to <= from) throw new ApiError(400, '"to" must be after "from".');
     const limit = Math.min(1000, Math.max(1, Number(url.searchParams.get('limit')) || 200));
-    const occ = expandEvents(events, settings, { displayTz: tz, now, windowStartMs: from, windowEndMs: to }).slice(0, limit);
+    const occ = expandEvents(events, settings, { displayTz: tz, now, windowStartMs: from, windowEndMs: to })
+      .filter((o) => !f.roomIds || occurrenceMatches(f, o))
+      .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, resources }));

package/src/pages/api/webhooks/docs.ts

@@ -24,6 +24,11 @@ Restoring design history only stages a draft; publishing it emits this event.
 media.created/updated/deleted: a media record is added, its alt text changes, or it is removed.
 site.restored: a content backup is restored; resync instead of expecting individual record events.
 announcement.published: an announcement goes up (acms({ announcements }); scheduled ones when their time comes).
+event.published/updated/unpublished/deleted: a calendar event goes public, changes, stops being
+public or is deleted, by any path: the editor, Schedule, list actions, agent tools, the REST API,
+scheduled publishing, a saved place's new address and environment sync. event.updated means
+something public changed (times, place, rooms, cancelled dates, text, translations); hosts,
+members' requests and staged edits do not emit it. A restore sends site.restored instead.
 Existing event.* and booking.* payloads are described at /api/calendar/docs.
 
 ## Payloads

package/src/pages/calendar/[slug].ics.ts

@@ -4,10 +4,13 @@ import { getRepo } from '../../lib/repo';
 import { siteOrigin } from '../../lib/seo';
 import { CALENDAR } from '../../lib/calendar/config';
 import { feedFor, icsResponse } from '../../lib/calendar/feeds';
+import { readEventFilter, resolveEventFilter } from '../../lib/calendar/filter';
 
 // One calendar's subscribe feed. Public and unlisted calendars are open;
 // private ones need the secret ?t= token from Calendars → Copy link (staff
 // subscriptions). A wrong token looks exactly like a missing calendar.
+// ?tag=, ?notag= and ?room= narrow it like the /calendar page (a `cal` here
+// is ignored: the address names the calendar).
 const sameToken = (a: string, b: string) =>
   a.length === b.length && a.length > 0 && timingSafeEqual(Buffer.from(a), Buffer.from(b));
 
@@ -18,8 +21,11 @@ export const GET: APIRoute = async ({ locals, url, params }) => {
   if (!calendar || calendar.kind !== 'native') return new Response(null, { status: 404 });
   const isPrivate = calendar.visibility === 'private';
   if (isPrivate && !sameToken(url.searchParams.get('t') ?? '', calendar.feedToken)) return new Response(null, { status: 404 });
-  const settings = await repo.getSettings();
-  const { body } = await feedFor(repo, settings, siteOrigin(settings, url), { calendar, allowPrivate: isPrivate });
+  const filter = { ...readEventFilter(url.searchParams), cal: [] };
+  const [settings, resources] = await Promise.all([repo.getSettings(), filter.room.length ? repo.listResources() : []]);
+  const resolved = resolveEventFilter(filter, { calendars: [], resources, allowPrivate: isPrivate });
+  if (resolved.unknown) return new Response(null, { status: 404 });
+  const { body } = await feedFor(repo, settings, siteOrigin(settings, url), { calendar, allowPrivate: isPrivate, filter: resolved });
   // private feeds must never sit in shared caches
   const res = icsResponse(body, `${calendar.slug}.ics`, isPrivate ? 0 : 300);
   if (isPrivate) res.headers.set('Cache-Control', 'private, no-store');

package/src/pages/calendar/feed.ics.ts

@@ -3,13 +3,20 @@ import { getRepo } from '../../lib/repo';
 import { siteOrigin } from '../../lib/seo';
 import { CALENDAR } from '../../lib/calendar/config';
 import { feedFor, icsResponse } from '../../lib/calendar/feeds';
+import { readEventFilter, resolveEventFilter } from '../../lib/calendar/filter';
 
 // Every public calendar in one subscribe feed (/calendar.ics). Feed
 // calendars are not re-published — subscribers can add those at the source.
+// The /calendar page's filters narrow it: /calendar.ics?tag=Class,
+// ?cal=youth,events&notag=Class, ?room=chapel. A calendar or room that isn't
+// public answers 404, like one that doesn't exist.
 export const GET: APIRoute = async ({ locals, url }) => {
   if (!CALENDAR.enabled) return new Response(null, { status: 404 });
   const repo = await getRepo(locals);
-  const settings = await repo.getSettings();
-  const { body } = await feedFor(repo, settings, siteOrigin(settings, url), {});
+  const filter = readEventFilter(url.searchParams);
+  const [settings, calendars, resources] = await Promise.all([repo.getSettings(), repo.listCalendars(), filter.room.length ? repo.listResources() : []]);
+  const resolved = resolveEventFilter(filter, { calendars, resources });
+  if (resolved.unknown) return new Response(null, { status: 404 });
+  const { body } = await feedFor(repo, settings, siteOrigin(settings, url), { filter: resolved });
   return icsResponse(body, 'calendar.ics');
 };