@acms-subir/core 0.3.43 → 0.3.45

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @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
+
+- b011cee: Moving one date of a repeating event on the admin Schedule now keeps what belongs to that date. Dragging a single date still splits it off into a one-off copy, but the copy now keeps the series' hosts, room hold, translations and SEO title and description. Before, all of these were left behind, so the room looked free at the new time, the date dropped off the hosts' My events, and the Spanish title was gone. That date's RSVPs, including places in line, move to the copy at the new time. Everyone with a seat gets the "new time" email with the updated calendar file, while places in line move quietly. **Undo** moves the RSVPs back to the series' date (with the email again) before the copy is deleted, so undoing never cancels anyone. Undo now refuses with "This event has unpublished changes" before anything changes, instead of deleting the copy first.
+
+  Dates moved before this release keep their copies as they are: staff can still add the hosts and room on those by hand. `repo.createEvent` now stores `translations` (it ignored them before), and the repository has a new `moveOccurrenceRsvps(eventId, start, { eventId?, start, end })`.
+
 ## 0.3.43
 
 ### 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.43",
+  "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(),
   };