@acms-subir/core 0.3.44 → 0.3.45

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @acms-subir/core
 
+## 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

@@ -1136,12 +1136,23 @@ 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]
   ] }
 ];
 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;

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/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.45",
   "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';
@@ -1034,8 +1034,9 @@ export const server = {
       },
     }),
     // 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 +1065,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 +1078,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);

package/src/components/calendar/RoomHolds.tsx

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

package/src/lib/booking/holds.ts

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

package/src/lib/booking/service.ts

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

package/src/lib/calendar/agent.ts

@@ -110,7 +110,8 @@ export async function runEventTool(repo: ContentRepository, input: EventToolInpu
     case 'get_event': {
       const e = await repo.getEvent(input.arguments.id);
       if (!e) throw new ApiError(404, 'Event not found.');
-      return { ...eventToJson(mergeEventDraft(e), ctx.origin, calMap, settings.timezone, { includePrivate: true }), bodyHtml: mergeEventDraft(e).bodyHtml, hasPendingDraft: Boolean(e.draft), editUrl: editUrl(e.id) };
+      const rooms = new Map((await repo.listResources()).map((r) => [r.id, r]));
+      return { ...eventToJson(mergeEventDraft(e), ctx.origin, calMap, settings.timezone, { includePrivate: true, resources: rooms }), bodyHtml: mergeEventDraft(e).bodyHtml, hasPendingDraft: Boolean(e.draft), editUrl: editUrl(e.id) };
     }
     case 'create_event': {
       const a = input.arguments;

package/src/lib/calendar/api.ts

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