@acms-subir/core 0.3.44 → 0.3.46

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @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
+
+- 318e6a1: Rooms: clashes between events, a public free/busy check, and room colours and names in public event data.
+
+  **Clashes.** Room bookings already couldn't take a room an event holds, but two events could hold the same room at once with no warning. The event editor's Rooms box now warns when another event holds a ticked room at an overlapping time, setup and cleanup included. It shows that event's title (linking to it) and date, for example "Hall is also held by another event · Practice · Thu, Jan 10 · 7:00 – 8:00 PM". Both events keep the room, so the warning says to change a time or pick another room if they can't share it. The room list says "Another event" or "Busy on 3 of 12 dates", and Quick add counts these as busy too. Other events count while they hold rooms: published or scheduled, drafts with Hold now, and not on a cancelled date. New in `@acms-subir/core/server`:
+
+  - `eventRoomClashes(repo, eventOrId, { horizonDays?, now? })`: the other events holding the same rooms at overlapping times, as `{ hold, other }` pairs.
+  - `roomBusy(repo, { roomIds, from, to, ignore? })`: everything that takes the rooms in a span (event holds, bookings, staff blocks and busy calendars), with names for staff. `ignore: { eventId, key }` leaves out the date being moved.
+
+  Neither function checks permissions. Holds now carry the date's occurrence `key`, and occurrences carry `roomIds`, the rooms that date holds.
+
+  **Public free/busy.** `GET /api/v1/rooms/free?room=<slug>&start=&end=` answers `{ room, start, end, free, busy: [{ start, end }] }`. The busy times are merged and clipped to the span and never say what or who. Only rooms with the new **Anyone can check if it’s free** switch answer; any other slug is a 404. Spans are at most 31 days, answers are never cached, and each address gets 30 checks a minute.
+
+  **Room colour and names.** Each room (Admin → Calendar → Rooms) gets:
+
+  - a **Colour**, for events in it on calendars and screens;
+  - **Name it on public events**, off by default, so existing rooms stay unnamed until staff turn it on.
+
+  Public event data now has `rooms: [{ slug, name, color }]`, listing only rooms with that switch on, with `color` `null` when a room has none. It appears in `/api/v1/events` (on each event and on each occurrence, the rooms that date holds), `/api/v1/events/:slug`, `/api/v1/search`, `/api/calendar/events` and webhook payloads. An API key with `events:read` and the agent tools see every room. Calendar views (`collectViewEvents`: `/calendar`, cards, embeds) give each native event `rooms: [{ id, slug, name, color }]` under the same rule. The editor API's resources take `color`, `showOnEvents` and `requestable`, and environment sync carries them.
+
+  Migration 64 adds `resources.color`, `show_on_events` and `requestable`; changing the colour or the naming switch refreshes cached pages and API answers. New docs: `npx acms docs calendar` covers repeats, cancelled dates, rooms and clashes, and `npx acms docs server` has the two new functions.
+
 ## 0.3.44
 
 ### Patch Changes

package/cli/main.mjs

@@ -10,7 +10,7 @@ import { addMobile, mobileCommand, listApps } from './mobile.mjs';
 import { mobileDoctor, renderDoctor } from './mobile-doctor.mjs';
 import { monitorCommand, renderMonitor } from './monitor.mjs';
 const HELP=`acms — ACMS project, theme and agent tools
-Discovery: inspect | schema theme | docs theme | docs sections | docs mobile | docs sync | docs server
+Discovery: inspect | schema theme | docs theme | docs sections | docs mobile | docs sync | docs server | docs calendar
            agent init [--mobile]   write .agents/skills (theme; mobile when an app exists)
 Check:  check [--build]   validate every project theme, refresh section types,
                           report sections without a native app version
@@ -140,6 +140,7 @@ export async function main() {
     else if(cmd==='docs'&&sub==='mobile')data={markdown:await readFile(resolve(CORE,'docs/mobile.md'),'utf8')};
     else if(cmd==='docs'&&sub==='sync')data={markdown:await readFile(resolve(CORE,'docs/environment-sync.md'),'utf8')};
     else if(cmd==='docs'&&sub==='server')data={markdown:await readFile(resolve(CORE,'docs/server.md'),'utf8')};
+    else if(cmd==='docs'&&sub==='calendar')data={markdown:await readFile(resolve(CORE,'docs/calendar.md'),'utf8')};
     else if(cmd==='section')data=await sectionCommand(sub,rest,flags);
     else if(cmd==='check') {
       const p=await project(),themes=(await listLocalThemes(p)).filter(t=>t.origin==='project');
@@ -148,7 +149,7 @@ export async function main() {
     }
     else if(cmd==='agent'&&sub==='init')data=await agentInit(flags);
     else if(cmd==='inspect') {
-      const p=await project();data={coreVersion:p.version,themeApiVersion:1,project:p.pkg.name,targets:{cloudflare:await exists('wrangler.jsonc')||await exists('wrangler.toml'),docker:await exists('Dockerfile')},themes:await listLocalThemes(p),capabilities:['theme-schema','theme-create','theme-check','theme-dev','theme-pack','scoped-design-api','editable-sections','section-library','section-types','page-presets','mobile-apps','mobile-editor-apps','mobile-recipes','mobile-docs','mobile-doctor','monitor-kuma','migrate','server-api'],mobileApps:await mobileApps(),configuration:await readJson(resolve(p.cwd,'.astro/acms-project.json')).catch(()=>({source:'Run astro sync or dev to discover configured collections.',collections:null}))};
+      const p=await project();data={coreVersion:p.version,themeApiVersion:1,project:p.pkg.name,targets:{cloudflare:await exists('wrangler.jsonc')||await exists('wrangler.toml'),docker:await exists('Dockerfile')},themes:await listLocalThemes(p),capabilities:['theme-schema','theme-create','theme-check','theme-dev','theme-pack','scoped-design-api','editable-sections','section-library','section-types','page-presets','mobile-apps','mobile-editor-apps','mobile-recipes','mobile-docs','mobile-doctor','monitor-kuma','migrate','server-api','calendar-docs'],mobileApps:await mobileApps(),configuration:await readJson(resolve(p.cwd,'.astro/acms-project.json')).catch(()=>({source:'Run astro sync or dev to discover configured collections.',collections:null}))};
     } else if(cmd==='theme')data=await themeCommand(sub,rest,flags);
     else if(['site','design','content','media'].includes(cmd))data=await remoteCommand(cmd,sub,rest,flags);
     else fail('USAGE','Unknown command.',[],['Run acms --help']);

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`,
@@ -1136,12 +1234,26 @@ var MIGRATIONS = [
   // with or without the answers); '{}' = off. Not public, so no cache trigger.
   { version: 63, statements: [
     `ALTER TABLE forms ADD COLUMN alerts TEXT NOT NULL DEFAULT '{}'`
-  ] }
+  ] },
+  // rooms: a colour and whether public event data names them
+  // (Resource.color / .showOnEvents, both visible), and whether anyone may ask
+  // if they're free (Resource.requestable, never shown, so no cache bump)
+  { version: 64, statements: [
+    `ALTER TABLE resources ADD COLUMN color TEXT NOT NULL DEFAULT ''`,
+    `ALTER TABLE resources ADD COLUMN show_on_events INTEGER NOT NULL DEFAULT 0`,
+    `ALTER TABLE resources ADD COLUMN requestable INTEGER NOT NULL DEFAULT 0`,
+    `DROP TRIGGER content_version_resources_update`,
+    contentVersionTriggers("resources", [...CONTENT_VERSION_COLUMNS.resources, "color", "show_on_events"])[2]
+  ] },
+  // every change to a published event, from any write path, queued for its
+  // side effects (webhooks, "event changed" pushes, slug redirects)
+  EVENT_CHANGES_MIGRATION
 ];
 var CURRENT_CONTENT_VERSION_COLUMNS = {
   ...CONTENT_VERSION_COLUMNS,
   settings: [...CONTENT_VERSION_COLUMNS.settings, "links_verified", "links_avatar_shape", "links_avatar_fit", "links_avatar_scale", "legal"],
   events: [...CONTENT_VERSION_COLUMNS.events, "cancelled_dates"],
+  resources: [...CONTENT_VERSION_COLUMNS.resources, "color", "show_on_events"],
   announcements: ANNOUNCEMENT_VISIBLE_COLUMNS
 };
 var LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;
@@ -1164,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: [] };
@@ -1172,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 < ?`,
@@ -1193,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/calendar.md

@@ -0,0 +1,112 @@
+# Calendar: repeats, single dates, rooms and clashes
+
+How events repeat, how one date of a series is changed, and how events hold rooms.
+Read it with `npx acms docs calendar`. The functions named here come from
+`@acms-subir/core/server` (`npx acms docs server` has their signatures), and the app
+API is in `docs/mobile-api-v1.md` in the framework repository.
+
+## Times and repeats
+
+An event stores **wall-clock** times in its own timezone (the site's when it has
+none): `start` and `end` are `YYYY-MM-DDTHH:mm`, or `YYYY-MM-DD` for all-day events,
+whose `end` is the last day, inclusive. A 6 PM class stays at 6 PM across daylight
+saving changes.
+
+A repeating event has an `rrule`, the RFC 5545 rule without the `RRULE:` prefix, such
+as `FREQ=WEEKLY;BYDAY=TH`. The editor offers daily, weekly on chosen days, monthly by
+date or by weekday ("second Tuesday"), and yearly, each ending never, on a date or
+after a number of times. Other rules round-trip as custom rules. Every repeat is the
+same event: one page, one slug, the same hosts and rooms. The calendar, the app API,
+the ICS feeds and room holds expand it into **occurrences** (dates) as needed.
+
+`exdates` skips dates entirely: they vanish from the calendar and feeds. Dragging a
+whole series on the admin Schedule moves the rule with it ("weekly on Thursday" moved a
+day becomes "weekly on Friday").
+
+## Occurrence keys
+
+Each date of a series has a **key**: its start as wall-clock time in the event's
+timezone, in the same format as `start` (`2030-01-10T18:00`, or `2030-01-10` for
+all-day events). Changes to single dates are stored on the event under that key. Take
+keys from `listOccurrences` (`o.key`) rather than building them.
+
+When the series moves to another day, stored keys move with it. When its time or rule
+is edited instead, keys that no longer match a date are ignored, not an error.
+
+## Cancelled dates
+
+Cancelling one date (**Cancel this date** in the editor, the Schedule, a host's My
+events, or `cancelOccurrence`) applies at once, even on a published event. The date
+stays listed, struck through as "Cancelled", so nobody wonders where it went:
+
+- the event page, `/calendar`, `/api/v1/events` and `/api/calendar/events` mark it
+  `cancelled`;
+- the ICS feeds add an override for that date with `STATUS:CANCELLED`;
+- its room holds are released for that slot;
+- its RSVPs are cancelled, and each person gets the "cancelled" email. Restoring the
+  date doesn't bring them back, so people sign up again;
+- the "When an event changes" push rule can announce it.
+
+The keys are stored in `cancelledDates`. `restoreOccurrence` undoes a cancellation.
+
+## Rooms
+
+Rooms, people and equipment are **Resources** (Admin → Calendar → Rooms; they need
+`calendar.bookings`, which is on by default). An event **holds** rooms
+(`roomHold.resourceIds`, the Rooms box in the editor) while it happens, plus any setup
+and cleanup minutes, or all day:
+
+- Published and scheduled events hold their rooms. A draft holds them only with **Hold
+  now** on. A cancelled event, or a cancelled date, holds nothing.
+- Holds are worked out from the events every time and never stored, so moving,
+  repeating, skipping or cancelling a date frees or moves the room automatically.
+- Room bookings (`/book`, embeds, the app, the API) can't take a held room.
+
+Each room also has:
+
+- **Colour** (`color`, `#rrggbb` or `''`): for events in that room on calendars and
+  screens.
+- **Name it on public events** (`showOnEvents`, off by default): public event data
+  names the room. When it's off, only staff see that an event uses the room.
+- **Anyone can check if it’s free** (`requestable`, off by default): the room answers
+  the public free/busy check below.
+
+### Rooms in event data
+
+- `/api/v1/events`, `/api/v1/events/:slug`, `/api/v1/search`, `/api/calendar/events`
+  and webhook payloads carry `rooms: [{ slug, name, color }]` on each event (`color`
+  is `null` when the room has none). Each occurrence also has `rooms`, the rooms that
+  date holds. Only rooms with **Name it on public events** appear. Staff callers (an
+  API key with `events:read`, the agent tools) see every room.
+- Calendar views built on `collectViewEvents` (the `/calendar` page, calendar cards,
+  embeds) get `rooms: [{ id, slug, name, color }]` on each native event's
+  occurrence, with the same rule for public views. Admin views get every room.
+- Site code reads `event.roomHold.resourceIds`, or `o.roomIds` on an occurrence.
+
+### Clashes
+
+Bookings can't take a held room, but two **events** may hold the same room at once.
+The event editor's Rooms box warns when another event holds a ticked room at an
+overlapping time, with that event's title and date. Both events keep the room, so
+change a time or pick another room if they can't share it. The same box still lists
+bookings the event would overlap, with Keep or Cancel and email.
+
+Site code and other framework features use the same checks:
+
+- `eventRoomClashes(repo, eventOrId)`: the other events holding this event's rooms at
+  overlapping times over the next year, as pairs of `{ hold, other }` (one date of each).
+- `roomBusy(repo, { roomIds, from, to, ignore? })`: everything that takes the rooms in
+  a span (event holds, bookings, staff blocks and the rooms' busy calendars), with
+  names. `ignore: { eventId, key }` leaves out the date you're about to move.
+
+Both include names, so show them to staff only. Neither checks permissions.
+
+### Public free/busy
+
+`GET /api/v1/rooms/free?room=<slug>&start=<day or date-time>&end=<…>` answers
+whether a room is free, plus the busy times inside the span (merged), never what or
+who. Only rooms with **Anyone can check if it’s free** answer, and every other slug is
+a 404. Spans are at most 31 days, and a plain day means midnight in the site's
+timezone. Answers are never cached, and each address gets 30 checks a minute. The
+client has `roomFree({ room, start, end })`, and the native package has
+`useRoomFree(query)`.

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/docs/mobile.md

@@ -127,6 +127,7 @@ Read the app's `AGENTS.md` too: it holds the same rules, next to the code.
 | `useLinks()` / `useForm(id)` / `useSubmitForm(id)` | the links page; published forms and sending answers; check `features.links` / `features.forms` |
 | `useLive()` | live video: `snapshot`, `status` (`live`/`upcoming`/`offline`), `isLive`, localized `view` text, the owner's `display` choices (`style`, `bar`, `header`, `dock`). Polls every 30 s only in the foreground, rechecks on resume, drops an expired "live" even offline; idle while `features.live` is false. Render `<LiveCard>` / `<LiveTag>` |
 | `useResources()` / `useAvailability({ resource, link })` / `useBooking()` | bookings |
+| `useRoomFree({ room, start, end })` | bookings: is a requestable room free (no names) |
 | `useLocale()`, `useTheme()`, `useLayout()`, `useRefresh()`, `useOpenLink()` | language, tokens, layout, refresh, links |
 | `usePushRegistration({ topics })` / `usePushTopics()` / `useNewPushTopics()` / `useNotificationTaps()` | push notifications (see Push notifications); topic names come in the app's language |
 | `useAnnouncements({ kind, pinned })` / `useAnnouncement(id)` / `useAnnouncementState()` | announcements up right now; unread and closed banners kept on the phone (a dot, never a number); idle while `features.announcements` is false |

package/docs/server.md

@@ -12,6 +12,7 @@ import {
   getRepo, currentUser,
   listEvents, getEvent, listOccurrences,
   cancelOccurrence, restoreOccurrence,
+  eventRoomClashes, roomBusy,
   listMyEvents, listEventRequests, submitEventRequest, updateEventRequest,
   withdrawEventRequest, approveEventRequest, declineEventRequest, setHostedOccurrence,
 } from '@acms-subir/core/server';
@@ -32,6 +33,8 @@ getEvent(repo: Repo, id: string): Promise<CalEvent | null>
 listOccurrences(repo: Repo, w: { eventId?: string; from: Date | number; to: Date | number; tag?: string; excludeTag?: string }): Promise<Occurrence[]>
 cancelOccurrence(repo: Repo, eventId: string, occurrenceKey: string, ctx: WriteContext): Promise<CalEvent>
 restoreOccurrence(repo: Repo, eventId: string, occurrenceKey: string, ctx: WriteContext): Promise<CalEvent>
+eventRoomClashes(repo: Repo, event: string | CalEvent, opts?: { horizonDays?: number; now?: Date | number }): Promise<EventClash[]>
+roomBusy(repo: Repo, q: { roomIds: string[]; from: Date | number; to: Date | number; ignore?: { eventId: string; key?: string } }): Promise<BusySlot[]>
 
 // event requests: `who` is currentUser()'s result (anything with `id` and `can()` works)
 listMyEvents(repo: Repo, who: ServerUser | null): Promise<CalEvent[]>
@@ -45,12 +48,16 @@ setHostedOccurrence(repo: Repo, who: ServerUser | null, eventId: string, occurre
 
 type Role = 'owner' | 'administrator' | 'editor' | 'author' | 'contributor' | (string & {})
 interface ServerUser { id: string; email: string; name: string; role: Role; staff: boolean; can(permission: string): boolean }
-interface Occurrence { event: CalEvent; start: number; end: number; allDay: boolean; days: number; key: string; cancelled: boolean }
+interface Occurrence { event: CalEvent; start: number; end: number; allDay: boolean; days: number; key: string; cancelled: boolean; roomIds: string[] }
+interface Hold { resourceId: string; eventId: string; key: string; title: string; start: number; end: number; eventStart: number; eventEnd: number }
+interface EventClash { hold: Hold; other: Hold }
+interface BusySlot { resourceId: string; start: number; end: number; kind: 'event' | 'booking' | 'block' | 'calendar'; title: string; eventId?: string; key?: string; bookingId?: string }
 interface WriteContext { url: URL; locals: unknown }
 ```
 
 The types `Repo`, `Role`, `ServerUser`, `CalEvent`, `Occurrence`, `ListEventsOptions`,
-`OccurrenceWindow`, `WriteContext` and `EventRequestInput` are exported too.
+`OccurrenceWindow`, `WriteContext`, `EventRequestInput`, `Hold`, `EventClash` and
+`BusySlot` are exported too.
 
 - **`getRepo(locals)`**: the site's content store for this request. Pass `Astro.locals`
   (or the endpoint/action's `locals`). `Repo` is an opaque handle; pass it to the other
@@ -121,6 +128,44 @@ another day (the admin's drag-to-move), its cancelled dates move with it. If its
 or rule is edited instead, keys that no longer match an occurrence are ignored, not an
 error.
 
+## Rooms
+
+Events hold rooms (`event.roomHold.resourceIds`, the Rooms box in the event editor)
+while they happen, plus any setup and cleanup minutes, or all day. Room bookings
+already can't take a held room. Two events, though, may hold the same room at once.
+These two functions find where things want the same room. Both include names, so
+show their results to staff only, and neither checks permissions.
+
+- **`eventRoomClashes(repo, event, opts?)`**: other events holding the same rooms as
+  this one at overlapping times, soonest first. Pass an event id, or a `CalEvent` with
+  unsaved values, which is checked as if it were published. The other events count
+  while they hold rooms: when they're published or scheduled, or drafts with **Hold
+  now** on, and not on a cancelled date. Each clash pairs one of this event's dates
+  (`hold`) with the other event's date (`other`). `hold.start`/`hold.end` include
+  setup and cleanup, and `eventStart`/`eventEnd` are the date's own times. It looks a
+  year ahead (`horizonDays`). The event editor shows the same check as a warning; both
+  events keep the room.
+- **`roomBusy(repo, { roomIds, from, to, ignore? })`**: everything that takes these
+  rooms in `[from, to)`, soonest first. That covers events holding them, pending and
+  confirmed bookings, staff blocks, and the rooms' busy calendars. `kind` says which,
+  and `title` is the event's title, the booker's name or the block's note (`''` for a
+  busy calendar). `ignore: { eventId, key }` leaves out one date of an event, such as
+  the date you're about to move, and `ignore: { eventId }` leaves out the whole event.
+  An empty list means every room is free. Windows are at most 400 days.
+
+```ts
+// is the hall free next Wednesday 5–6 PM for this one class date?
+const busy = await roomBusy(repo, {
+  roomIds: [hall.id], from: new Date('2030-01-09T22:00:00Z'), to: new Date('2030-01-09T23:00:00Z'),
+  ignore: { eventId: classEvent.id, key: '2030-01-10T18:00' },
+});
+if (busy.length) return `Taken by ${busy[0].title || 'something else'}`;
+```
+
+For people outside the staff, `GET /api/v1/rooms/free?room=<slug>&start=&end=` answers
+only free or busy (with the busy times), never what or who. It works only for rooms
+marked **Anyone can check if it’s free**.
+
 ## Private event fields
 
 A custom field can be private:

package/integration.mjs

@@ -874,6 +874,8 @@ export default function acms(options = {}) {
         ['/embed/book/[resource]/[link]', 'embed/book/[resource]/[link].astro'],
         ['/api/v1/resources', 'api/v1/resources.ts'],
         ['/api/v1/availability', 'api/v1/availability.ts'],
+        // free or busy for a requestable room (no names)
+        ['/api/v1/rooms/free', 'api/v1/rooms/free.ts'],
         ['/api/calendar/availability', 'api/calendar/availability.ts'],
         ['/api/calendar/bookings', 'api/calendar/bookings/index.ts'],
         ['/api/calendar/bookings/[id]', 'api/calendar/bookings/[id].ts'],

package/package.json

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

package/src/actions/index.ts

@@ -22,7 +22,7 @@ import { getCalendarEvents } from '../lib/calendar/ics';
 import { siteLocale } from '../lib/dates';
 import { normalizePageLocale, localeHomeUrl } from '../lib/i18n';
 import { CALENDAR, bookingsEnabled } from '../lib/calendar/config';
-import { holdConflicts } from '../lib/booking/holds';
+import { eventClashes, holdConflicts } from '../lib/booking/holds';
 import { setBookingStatus } from '../lib/booking/service';
 import { eventTimeZone, featuredOccurrence, formatOccurrence, isValidTimeZone, normalizeEventTimes } from '../lib/calendar/events';
 import { eventsFromCsv, eventsFromIcs, eventsFromVEvents } from '../lib/calendar/import';
@@ -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,15 +1026,15 @@ 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 };
       },
     }),
     // Event editor → Rooms: which rooms/people are free at this event's time
-    // (for every room, so the picker can label them), and which existing
-    // bookings the selected rooms would overlap. Works on unsaved values.
+    // (for every room, so the picker can label them), which existing bookings
+    // the selected rooms would overlap, and which other events hold them then
+    // (a warning: both keep the room). Works on unsaved values.
     roomStatus: defineAction({
       input: z.object({
         eventId: z.string().default(''),
@@ -1064,7 +1063,7 @@ export const server = {
           timezone: input.timezone, rrule: input.rrule, exdates: input.exdates, status: 'published', startAt: 0, endAt: 0, createdAt: 0, updatedAt: 0,
           roomHold: { ...input.roomHold, resourceIds: resources.map((r) => r.id), keep: input.roomHold.keep },
         });
-        const { conflicts, holds } = await holdConflicts(repo, settings, probe, { now });
+        const [{ conflicts, holds }, { clashes }] = await Promise.all([holdConflicts(repo, settings, probe, { now }), eventClashes(repo, settings, probe, { now })]);
         const tz = settings.timezone || 'UTC';
         const locale = siteLocale(settings);
         const day = new Intl.DateTimeFormat(locale, { weekday: 'short', month: 'short', day: 'numeric', timeZone: tz });
@@ -1077,9 +1076,18 @@ export const server = {
           holds: holdsLabel,
           rooms: resources.map((r) => {
             const mine = conflicts.filter((c) => c.booking.resourceId === r.id);
+            // one row per other event's date, however many of ours it overlaps
+            const others = [...new Map(clashes.filter((c) => c.other.resourceId === r.id).map((c) => [`${c.other.eventId}:${c.other.eventStart}`, c])).values()];
             return {
               id: r.id, name: r.name, kind: r.kind, capacity: r.capacity,
               datesWithBookings: new Set(mine.map((c) => c.hold.eventStart)).size, dates: occurrences,
+              datesWithEvents: new Set(others.map((c) => c.hold.eventStart)).size,
+              datesBusy: new Set([...mine.map((c) => c.hold.eventStart), ...others.map((c) => c.hold.eventStart)]).size,
+              events: others.slice(0, 20).map((c) => ({
+                id: `${c.other.eventId}:${c.other.eventStart}`, eventId: c.other.eventId, title: c.other.title,
+                when: `${day.format(c.other.eventStart)} · ${range(c.other.eventStart, c.other.eventEnd)}`,
+              })),
+              eventCount: others.length,
               conflicts: mine.slice(0, 20).map((c) => ({
                 id: c.booking.id, name: c.booking.kind === 'block' ? `Blocked${c.booking.notes ? ` · ${c.booking.notes}` : ''}` : c.booking.name,
                 block: c.booking.kind === 'block', status: c.booking.status,

package/src/components/calendar/QuickAdd.tsx

@@ -98,7 +98,7 @@ export default function QuickAdd(props: Props) {
       const s = allDay ? day : `${day}T${from}`;
       const e = allDay ? (endDay < day ? day : endDay) : `${endDay < day ? day : endDay}T${to}`;
       fetchRoomStatus({ eventId: '', title, start: s, end: e, allDay, timezone: '', rrule: repeatRule(repeat, day), exdates: [] }, NO_HOLD)
-        .then((d) => setRooms((d?.rooms ?? []).map((r) => ({ id: r.id, name: r.name, busy: r.conflicts.length }))))
+        .then((d) => setRooms((d?.rooms ?? []).map((r) => ({ id: r.id, name: r.name, busy: r.conflicts.length + r.eventCount }))))
         .catch(() => {});
     }, 350);
     return () => clearTimeout(t);