@acms-subir/core 0.3.45 → 0.3.46

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @acms-subir/core
 
+## 0.3.46
+
+### Patch Changes
+
+- de6694e: Event webhooks, the "When an event changes" push and slug redirects now follow every change to a published event, however it's made. Before, only the event editor, the Schedule and the list's bulk actions ran them. A scheduled event that went live sent no `event.published`, a saved place's new address sent no `event.updated` and no push, and an environment sync sent no event webhooks. Now database triggers record each write to a published event in the same transaction, and the side effects run right after the request (or from the scheduler, for scheduled publishing).
+
+  - **Scheduled publishing** behaves like pressing Publish: `event.published`, with the same payload.
+  - **Agent tools and the REST API**: unchanged on the surface. Edits to a live event still wait as a staged draft, and `publish_event` (or `"publish": true`) and DELETE send their webhooks.
+  - **A saved place's new name or address**: `event.updated`, and the "When an event changes" push for the new place (people with an RSVP already got the email).
+  - **Environment sync**: sends the event webhooks but never member pushes for events. An event a run publishes counts as already announced (no "new event" push), and its date, time or place changes send no change push. Posts a run publishes keep their "new post" push.
+  - **Restores** still send only `site.restored`. Changes still waiting from before the restore are dropped.
+  - **Drafts** (new events, ICS/CSV imports, Duplicate, "Make an editable copy", members' requests) send nothing until they're published.
+  - `event.updated` now means something public changed: times, place, cancelled dates, text, translations, calendars, rooms, RSVP settings. Saving only hosts or a member's request, or publishing an event that's already published, no longer sends it. Each write sends its own webhook, so moving a series that has cancelled dates sends two `event.updated`, the second with the moved cancelled dates (before, the one webhook had the old ones).
+
+  Payloads are unchanged. Migration 65 adds the `event_changes` table (with its triggers on `events`) and `push_control`, and rebuilds the events' first-publish push triggers. Other features can keep their own queues from their own triggers on `events`. The repository has new `claimEventChanges` and `finishEventChanges`.
+
 ## 0.3.45
 
 ### Patch Changes

package/cli/migrations.generated.mjs

@@ -84,24 +84,24 @@ function trigger(name, action, table, when, event, data) {
 function content(kind) {
   const table = `${kind}s`;
   const fields = kind === "post" ? ["collection", "slug", "title", "status", "body", "body_json", "body_html", "excerpt", "tags", "cover", "cover_alt", "seo_title", "seo_desc", "featured", "author_id", "template", "published_at"] : ["slug", "title", "status", "is_home", "locale", "blocks", "body_json", "body_html", "seo_title", "seo_desc", "template"];
-  const snapshot = (row) => `json_object('id',${row}.id,'slug',${row}.slug,'title',${row}.title,'status',${row}.status,
+  const snapshot2 = (row) => `json_object('id',${row}.id,'slug',${row}.slug,'title',${row}.title,'status',${row}.status,
     ${kind === "post" ? `'collection',${row}.collection` : `'locale',${row}.locale,'isHome',json(CASE WHEN ${row}.is_home THEN 'true' ELSE 'false' END)`})`;
-  const changed = fields.map((f) => `OLD.${f} IS NOT NEW.${f}`).join(" OR ");
+  const changed2 = fields.map((f) => `OLD.${f} IS NOT NEW.${f}`).join(" OR ");
   const event = `CASE WHEN OLD.status!='published' THEN '${kind}.published'
     WHEN NEW.status!='published' THEN '${kind}.unpublished' ELSE '${kind}.updated' END`;
   return [
-    trigger(`webhook_${kind}_insert`, "INSERT", table, "NEW.status='published'", `'${kind}.published'`, `json_object('${kind}',${snapshot("NEW")})`),
+    trigger(`webhook_${kind}_insert`, "INSERT", table, "NEW.status='published'", `'${kind}.published'`, `json_object('${kind}',${snapshot2("NEW")})`),
     trigger(
       `webhook_${kind}_update`,
       "UPDATE",
       table,
-      `(OLD.status='published' OR NEW.status='published') AND (${changed})`,
+      `(OLD.status='published' OR NEW.status='published') AND (${changed2})`,
       event,
-      `json_object('${kind}',json(CASE WHEN NEW.status='published' THEN ${snapshot("NEW")}
-        ELSE json_set(${snapshot("OLD")},'$.status',NEW.status) END),
-        'previous',json(CASE WHEN OLD.status='published' THEN ${snapshot("OLD")} ELSE 'null' END))`
+      `json_object('${kind}',json(CASE WHEN NEW.status='published' THEN ${snapshot2("NEW")}
+        ELSE json_set(${snapshot2("OLD")},'$.status',NEW.status) END),
+        'previous',json(CASE WHEN OLD.status='published' THEN ${snapshot2("OLD")} ELSE 'null' END))`
     ),
-    trigger(`webhook_${kind}_delete`, "DELETE", table, "OLD.status='published'", `'${kind}.deleted'`, `json_object('${kind}',${snapshot("OLD")})`)
+    trigger(`webhook_${kind}_delete`, "DELETE", table, "OLD.status='published'", `'${kind}.deleted'`, `json_object('${kind}',${snapshot2("OLD")})`)
   ];
 }
 var media = (row) => `json_object('media',json_object('id',${row}.id,'key',${row}.key,'filename',${row}.filename,
@@ -218,6 +218,104 @@ var ROOM_HOLD_MIGRATION = { version: 41, statements: [
   `ALTER TABLE events ADD COLUMN room_hold TEXT NOT NULL DEFAULT '{}'`
 ] };
 
+// src/lib/calendar/change-migration.ts
+var now4 = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+var 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"
+];
+var 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"
+];
+var snapshot = (row) => `json_object(${EVENT_CHANGE_SNAPSHOT.map((c) => `'${c}',${row}.${c}`).join(",")})`;
+var live = "(SELECT suppressed FROM webhook_control WHERE id=1)=0";
+var quiet = "COALESCE((SELECT quiet FROM push_control WHERE id=1),0)";
+var record = (id, before, after) => `INSERT INTO event_changes (event_id,old_row,new_row,quiet,created_at)
+  VALUES (${id},${before},${after},${quiet},${now4});`;
+var changed = EVENT_CHANGE_COLUMNS.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(" OR ");
+var skipped = `CASE WHEN (SELECT suppressed FROM webhook_control WHERE id=1)=1 OR ${quiet}=1 THEN 'skipped' ELSE 'pending' END`;
+var 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,${now4},${now4}
+    WHERE NOT EXISTS (SELECT 1 FROM push_queue WHERE key='event:'||NEW.id);`;
+var 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`
+] };
+
 // src/lib/maps/migration.ts
 var PLACES_MIGRATION = { version: 43, statements: [
   `CREATE TABLE IF NOT EXISTS places (
@@ -468,8 +566,8 @@ var CONTENT_VERSION_COLUMNS = {
 };
 var BUMP_CONTENT_VERSION = "UPDATE settings SET content_version = content_version + 1 WHERE id = 1;";
 function contentVersionTriggers(table, columns) {
-  const changed = columns.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(" OR ");
-  const update = `CREATE TRIGGER content_version_${table}_update AFTER UPDATE OF ${columns.join(", ")} ON ${table} WHEN ${changed} BEGIN ${BUMP_CONTENT_VERSION} END`;
+  const changed2 = columns.map((c) => `OLD.${c} IS NOT NEW.${c}`).join(" OR ");
+  const update = `CREATE TRIGGER content_version_${table}_update AFTER UPDATE OF ${columns.join(", ")} ON ${table} WHEN ${changed2} BEGIN ${BUMP_CONTENT_VERSION} END`;
   if (table === "settings") return [update];
   return [
     `CREATE TRIGGER content_version_${table}_insert AFTER INSERT ON ${table} BEGIN ${BUMP_CONTENT_VERSION} END`,
@@ -1146,7 +1244,10 @@ var MIGRATIONS = [
     `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
 ];
 var CURRENT_CONTENT_VERSION_COLUMNS = {
   ...CONTENT_VERSION_COLUMNS,
@@ -1175,7 +1276,7 @@ async function pendingMigrations(db) {
   return { applied, pending: MIGRATIONS.filter((m) => m.version > applied) };
 }
 async function runMigrations(db, opts = {}) {
-  const now4 = opts.now ?? Date.now;
+  const now5 = opts.now ?? Date.now;
   const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const first = await pendingMigrations(db);
   if (!first.pending.length) return { from: first.applied, to: first.applied, applied: [] };
@@ -1183,10 +1284,10 @@ async function runMigrations(db, opts = {}) {
   if (refused) return { from: first.applied, to: first.applied, applied: [], deferred: refused.version };
   await db.run(MIGRATION_LOCK_TABLE);
   const owner = crypto.randomUUID();
-  const deadline = now4() + (opts.waitMs ?? 6e4);
+  const deadline = now5() + (opts.waitMs ?? 6e4);
   let waited = false;
   for (; ; ) {
-    const t = now4();
+    const t = now5();
     await db.run(
       `INSERT INTO migration_lock (id, owner, expires_at) VALUES (1, ?, ?)
        ON CONFLICT(id) DO UPDATE SET owner = excluded.owner, expires_at = excluded.expires_at WHERE migration_lock.expires_at < ?`,
@@ -1204,13 +1305,13 @@ async function runMigrations(db, opts = {}) {
   try {
     const { applied, pending } = await pendingMigrations(db);
     if (applied === 1 && !await appliedVersion(db)) {
-      await db.run("INSERT INTO migrations (version, applied_at) VALUES (1, ?)", [now4()]);
+      await db.run("INSERT INTO migrations (version, applied_at) VALUES (1, ?)", [now5()]);
     }
     for (const m of pending) {
       opts.log?.(`Applying migration ${m.version}`);
       await db.batch([
         ...m.statements.map((sql) => ({ sql })),
-        { sql: "INSERT INTO migrations (version, applied_at) VALUES (?, ?)", args: [m.version, now4()] }
+        { sql: "INSERT INTO migrations (version, applied_at) VALUES (?, ?)", args: [m.version, now5()] }
       ]);
     }
     return { from: applied, to: pending.length ? pending[pending.length - 1].version : applied, applied: pending.map((m) => m.version) };

package/docs/environment-sync.md

@@ -221,6 +221,12 @@ This publishes only the draft-capable items in that run. It rejects later edits
 to those items instead of implicitly publishing somebody else's changes.
 Design/layout changes conservatively share a settings guard.
 
+What a run publishes or changes sends the destination's webhooks, as an edit
+there would (`post.*`, `page.*`, `event.*`). It never sends app push
+notifications for events: an event a run publishes counts as already
+announced, and its date, time or place changes send no "When an event changes"
+notice. Posts a run publishes still get the "new post" notice.
+
 ## History and rollback
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acms-subir/core",
-  "version": "0.3.45",
+  "version": "0.3.46",
   "publishConfig": {
     "access": "public"
   },

package/src/actions/index.ts

@@ -32,7 +32,6 @@ import { collectViewEvents } from '../lib/calendar/data';
 import { loadBoard } from '../lib/calendar/board';
 import { cancelOccurrence, duplicateEvent, moveOccurrence, moveSeries, quickCreate, restoreOccurrence, undoMove } from '../lib/calendar/schedule';
 import { waitUntilFrom } from '../lib/webhooks';
-import { eventChanged, eventDeleted } from '../lib/calendar/hooks';
 import { siteOrigin } from '../lib/seo';
 import type { CalEvent } from '../lib/schema';
 import { CalEvent as CalEventSchema } from '../lib/schema';
@@ -40,7 +39,7 @@ import { diffDesign, revertDesignChange, summarizeChanges } from '../lib/designD
 import { shareEpoch } from '../lib/drafts';
 import { createDesignToken } from '../lib/preview';
 import { getTheme } from '../lib/theme';
-import { savePost, applyPostUpdate, savePage, applyPageUpdate, saveEvent, applyEventUpdate, type SaveHooks } from '../lib/content-service';
+import { savePost, applyPostUpdate, savePage, applyPageUpdate, saveEvent, applyEventUpdate, flushEventHooks, type SaveHooks } from '../lib/content-service';
 import { resolveMapLink, searchPlaces } from '../lib/maps/service';
 import { savePlace } from '../lib/maps/places';
 
@@ -1027,9 +1026,8 @@ export const server = {
       handler: async ({ id }, ctx) => {
         await requireCan(ctx, 'content.delete');
         const repo = await getRepo(ctx.locals);
-        const before = await repo.getEvent(id);
         await repo.deleteEvent(id);
-        await eventDeleted(repo, before, { waitUntil: waitUntilFrom(ctx.locals) });
+        await flushEventHooks(repo, hooksFor(ctx));
         return { ok: true };
       },
     }),

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';
@@ -169,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/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/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, rooms] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listResources()]);
-  const data = eventToJson(after, opts.origin, new Map(calendars.map((c) => [c.id, c])), settings.timezone, { resources: new Map(rooms.map((r) => [r.id, r])) });
-  await emitWebhook(repo, type, { event: data }, { waitUntil: opts.waitUntil }).catch(() => {});
+  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;
 }
 

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/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/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