@acms-subir/core 0.3.3 → 0.3.4

package/src/components/editor/EventPanel.tsx

@@ -1,6 +1,8 @@
 import { useMemo, useState } from 'react';
 import type { EventCta, EventLocation } from '../../lib/schema';
 import type { EventFieldConfig } from '../../lib/calendar/config';
+import WhereItLands from '../calendar/WhereItLands';
+import RoomHolds, { type RoomHoldValue } from '../calendar/RoomHolds';
 import { buildRepeat, describeRepeat, parseRepeat, WEEKDAY_CODES, weekdayOf, type RepeatParts } from '../../lib/calendar/rrule';
 
 // The event half of the editor sidebar: When · Repeats · Where · Button ·
@@ -21,6 +23,7 @@ export interface EventMeta {
   calendarIds: string[];
   fields: Record<string, string>;
   rsvp: { enabled: boolean; capacity: number; autoConfirm: boolean; maxSeats: number };
+  roomHold: RoomHoldValue;
 }
 
 export interface CalendarOption {
@@ -35,6 +38,11 @@ interface Props {
   calendars: CalendarOption[];
   fields: EventFieldConfig[];
   siteTimezone: string;
+  // shows the "where it lands" mini month (Schedule data, minus this event)
+  eventId?: string;
+  // for the Rooms section (conflict wording, "Hold now" on drafts)
+  title?: string;
+  status?: string;
 }
 
 const DAY_LETTERS = ['S', 'M', 'T', 'W', 'T', 'F', 'S'];
@@ -64,7 +72,7 @@ function zoneList(): string[] {
   }
 }
 
-export function EventPanel({ meta, onChange, calendars, fields, siteTimezone }: Props) {
+export function EventPanel({ meta, onChange, calendars, fields, siteTimezone, eventId, title = '', status = 'draft' }: Props) {
   const repeat = useMemo(() => parseRepeat(meta.rrule, meta.start), [meta.rrule, meta.start]);
   const [skipDraft, setSkipDraft] = useState('');
   const zones = useMemo(zoneList, []);
@@ -136,6 +144,10 @@ export function EventPanel({ meta, onChange, calendars, fields, siteTimezone }:
         {!meta.allDay && !showEndDate && (
           <button type="button" className="pe-ev-link" onClick={() => setShowEndDate(true)}>Ends on another day</button>
         )}
+        {eventId && datePart(meta.start) && (
+          <WhereItLands date={datePart(meta.start)} eventId={eventId}
+            onPick={(d) => setStart(meta.allDay ? d : `${d}T${timePart(meta.start) || '10:00'}`)} />
+        )}
         <label className="pe-switch-row">
           <span><b>All day</b><small>No start or end time</small></span>
           <input type="checkbox" role="switch" className="pe-switch" checked={meta.allDay} onChange={(e) => toggleAllDay(e.target.checked)} />
@@ -277,6 +289,15 @@ export function EventPanel({ meta, onChange, calendars, fields, siteTimezone }:
         </label>
       </section>
 
+      <RoomHolds
+        times={{ eventId: eventId ?? '', title, start: meta.start, end: meta.end, allDay: meta.allDay, timezone: meta.timezone, rrule: meta.rrule, exdates: meta.exdates }}
+        hold={meta.roomHold}
+        status={status}
+        locationName={meta.location.name}
+        onChange={(roomHold) => onChange({ roomHold })}
+        onLocation={(name) => onChange({ location: { ...meta.location, name } })}
+      />
+
       <section className="pe-sb-section pe-ev">
         <h3 className="pe-sb-title">Button</h3>
         <div className="pe-ev-row">
@@ -327,7 +348,7 @@ export function EventPanel({ meta, onChange, calendars, fields, siteTimezone }:
       <section className="pe-sb-section pe-ev">
         <h3 className="pe-sb-title">Calendars</h3>
         {calendars.length === 0 ? (
-          <p className="pe-ev-note">No calendars yet — the event shows on the main calendar. <a href="/admin/calendar/calendars" target="_blank" rel="noopener">Create one</a> to group events.</p>
+          <p className="pe-ev-note">No calendars yet — the event shows on the main calendar. <a href="/admin/calendar/settings?new=1" target="_blank" rel="noopener">Create one</a> to group events.</p>
         ) : (
           <div className="pe-ev-cals">
             {calendars.map((c) => {

package/src/components/editor/PostEditor.tsx

@@ -31,6 +31,7 @@ import { I18N, localeHomeUrl } from '../../lib/i18n';
 import { mergeEventDraft, mergePageDraft, mergePostDraft } from '../../lib/drafts';
 import { CALENDAR, eventUrl, type EventFieldConfig } from '../../lib/calendar/config';
 import { EventPanel, eventWhenLabel, type CalendarOption, type EventMeta } from './EventPanel';
+import { fetchRoomStatus, NO_HOLD, RoomConflictDialog } from '../calendar/RoomHolds';
 
 // The Ghost-style writing surface, shared by posts AND pages: distraction-free
 // column, cards via "/", autosave, a collapsible settings sidebar, and an
@@ -149,6 +150,7 @@ const NO_EVENT: EventMeta = {
   start: '', end: '', allDay: false, timezone: '', rrule: '', exdates: [], cancelled: false,
   location: { name: '', address: '', url: '' }, cta: { label: '', href: '', style: 'primary' }, calendarIds: [], fields: {},
   rsvp: { enabled: false, capacity: 0, autoConfirm: true, maxSeats: 4 },
+  roomHold: NO_HOLD,
 };
 
 export default function PostEditor({ kind = 'post', post, page, event, calendars = [], eventFields = [], siteTimezone = '', initialHTML, unsplashEnabled, previewPath, sharePath, livePath: livePathProp, templates = [], site = { title: '', url: '' }, languages = [], mainLanguage, translationDrafts = false }: Props) {
@@ -176,7 +178,7 @@ export default function PostEditor({ kind = 'post', post, page, event, calendars
           template: event!.template, publishedAt: event!.publishedAt, scheduledAt: event!.scheduledAt,
           start: event!.start, end: event!.end, allDay: event!.allDay, timezone: event!.timezone, rrule: event!.rrule,
           exdates: event!.exdates, cancelled: event!.cancelled, location: event!.location, cta: event!.cta,
-          calendarIds: event!.calendarIds, fields: event!.fields, rsvp: event!.rsvp,
+          calendarIds: event!.calendarIds, fields: event!.fields, rsvp: event!.rsvp, roomHold: event!.roomHold,
         }
       : {
           ...NO_EVENT,
@@ -192,7 +194,7 @@ export default function PostEditor({ kind = 'post', post, page, event, calendars
   const col = kind === 'event'
     ? { singular: 'Event', plural: 'Events', base: CALENDAR.eventsBase, redirectFrom: [] }
     : kind === 'page' ? CONTENT.posts : (CONTENT.collections[meta.collection] ?? CONTENT.posts);
-  const listHref = kind === 'page' ? '/admin/pages' : kind === 'event' ? '/admin/calendar/events' : `/admin/c/${meta.collection}`;
+  const listHref = kind === 'page' ? '/admin/pages' : kind === 'event' ? '/admin/calendar' : `/admin/c/${meta.collection}`;
   const noun = kind === 'page' ? 'page' : col.singular.toLowerCase();
 
   const [authors, setAuthors] = useState<AuthorOption[]>([]);
@@ -408,6 +410,7 @@ export default function PostEditor({ kind = 'post', post, page, event, calendars
         calendarIds: m.calendarIds,
         fields: m.fields,
         rsvp: m.rsvp,
+        roomHold: m.roomHold,
         scheduledAt: m.scheduledAt,
         translations,
       });
@@ -711,8 +714,17 @@ export default function PostEditor({ kind = 'post', post, page, event, calendars
     toastTimer.current = setTimeout(() => setToast(null), 4500);
   }
 
-  async function transition(patch: Partial<Meta>) {
+  // publishing or scheduling an event that holds rooms: check for bookings
+  // that overlap first, and let the author keep or cancel each one
+  const [roomGate, setRoomGate] = useState<{ patch: Partial<Meta>; rooms: Parameters<typeof RoomConflictDialog>[0]['rooms'] } | null>(null);
+  async function transition(patch: Partial<Meta>, roomsChecked = false) {
     setPublishOpen(false);
+    const m0 = metaRef.current;
+    if (kind === 'event' && !roomsChecked && (patch.status === 'published' || patch.status === 'scheduled') && m0.roomHold.resourceIds.length) {
+      const st = await fetchRoomStatus({ eventId: docId, title: m0.title, start: m0.start, end: m0.end, allDay: m0.allDay, timezone: m0.timezone, rrule: m0.rrule, exdates: m0.exdates }, m0.roomHold).catch(() => null);
+      const rooms = (st?.rooms ?? []).filter((r) => m0.roomHold.resourceIds.includes(r.id) && r.conflicts.length);
+      if (rooms.length) { setRoomGate({ patch, rooms }); return; }
+    }
     const next = { ...metaRef.current, ...patch };
     metaRef.current = next;
     setMetaState(next);
@@ -902,6 +914,19 @@ export default function PostEditor({ kind = 'post', post, page, event, calendars
 
   return (
     <div className={`pe-shell ${sidebarOpen ? 'has-sidebar' : ''} ${split ? 'has-split' : ''}`}>
+      {roomGate && (
+        <RoomConflictDialog
+          rooms={roomGate.rooms}
+          onCancel={() => setRoomGate(null)}
+          onConfirm={async ({ keep, cancel, message }) => {
+            if (cancel.length) await actions.events.cancelBookingsForEvent({ ids: cancel, message });
+            const hold = metaRef.current.roomHold;
+            const patch = { ...roomGate.patch, roomHold: { ...hold, keep: [...new Set([...hold.keep, ...keep])] } };
+            setRoomGate(null);
+            await transition(patch, true);
+          }}
+        />
+      )}
       {toast && (
         <div className="pe-toast" role="status">
           <span className="pe-toast-check">✓</span>
@@ -911,7 +936,7 @@ export default function PostEditor({ kind = 'post', post, page, event, calendars
       )}
       <header className="pe-topbar">
         <div className="pe-topbar-left">
-          <a className="pe-btn ghost sm" href={listHref} onClick={(e) => { if (e.metaKey || e.ctrlKey || e.shiftKey) return; e.preventDefault(); requestLeave('list'); }} aria-label={kind === 'page' ? 'Back to pages' : `Back to ${col.plural.toLowerCase()}`}>‹<span className="pe-hide-sm">{kind === 'page' ? 'Pages' : col.plural}</span></a>
+          <a className="pe-btn ghost sm" href={listHref} onClick={(e) => { if (e.metaKey || e.ctrlKey || e.shiftKey) return; e.preventDefault(); requestLeave('list'); }} aria-label={kind === 'page' ? 'Back to pages' : kind === 'event' ? 'Back to the schedule' : `Back to ${col.plural.toLowerCase()}`}>‹<span className="pe-hide-sm">{kind === 'page' ? 'Pages' : kind === 'event' ? 'Schedule' : col.plural}</span></a>
           <span className={`pe-savestate ${saveState}`}>
             <i className="pe-save-dot" aria-hidden="true" />
             {STATUS_LABEL[meta.status]}{pending && <em className="pe-edited-dot"> · edited</em>}<span className="pe-hide-sm"> · {saveLabel}</span>
@@ -1538,11 +1563,14 @@ export default function PostEditor({ kind = 'post', post, page, event, calendars
 
           {kind === 'event' && (
             <EventPanel
+              eventId={docId}
               meta={meta}
               onChange={(patch) => setMeta(patch)}
               calendars={calendars}
               fields={eventFields}
               siteTimezone={siteTimezone}
+              title={meta.title}
+              status={meta.status}
             />
           )}
 

package/src/layouts/Admin.astro

@@ -109,15 +109,14 @@ const groups: { id: string; label: string; items: Item[] }[] = [
     ? [{
         id: 'calendar',
         label: 'Calendar',
+        // two homes: Schedule (anything on a date — grid, list, calendar
+        // settings) and Bookings (anything people reserve — requests, rooms &
+        // people, booking links). Sub-pages highlight their home.
         items: [
-          { key: 'calendar:events', label: 'Events', href: '/admin/calendar/events', icon: icons.calendar, count: null },
+          { key: 'calendar:schedule', label: 'Schedule', href: '/admin/calendar', icon: icons.calendar, count: null },
           ...(bookingsEnabled()
-            ? [
-                { key: 'calendar:bookings', label: 'Bookings', href: '/admin/calendar/bookings', icon: icons.bookings, count: pendingBookings || null, attention: pendingBookings > 0 },
-                { key: 'calendar:resources', label: 'Resources', href: '/admin/calendar/resources', icon: icons.resources, count: null },
-              ]
+            ? [{ key: 'calendar:bookings', label: 'Bookings', href: '/admin/calendar/bookings', icon: icons.bookings, count: pendingBookings || null, attention: pendingBookings > 0 }]
             : []),
-          { key: 'calendar:calendars', label: 'Calendars', href: '/admin/calendar/calendars', icon: icons.calendars, count: null },
         ],
       }]
     : []),

package/src/layouts/Site.astro

@@ -14,6 +14,7 @@ import { diffDesign } from '../lib/designDiff';
 import { getTheme } from '../lib/theme';
 import { analyticsHead, analyticsBody } from '../lib/analytics';
 import { socialIconPath, socialIconSvg } from '../lib/socialIcons';
+import type { SiteChrome } from '../lib/site-chrome';
 import '../styles/site.css';
 import '../styles/cards.css';
 import '../styles/live.css';
@@ -136,6 +137,30 @@ const readLinks = [
   ...(SEARCH.enabled ? [{ label: 'Search', url: searchAction }] : []),
   { label: 'RSS', url: '/rss.xml' },
 ];
+// a theme's templates/header.astro / footer.astro get this instead of core markup
+const langName = (l: string) => {
+  try { const n = new Intl.DisplayNames([l], { type: 'language' }).of(l); return n ? n[0].toLocaleUpperCase(l) + n.slice(1) : l.toUpperCase(); }
+  catch { return l.toUpperCase(); }
+};
+const chromeLink = (n: { label: string; url: string }) => ({ label: n.label, url: lnk(n.url), current: isCurrent(lnk(n.url)), external: isExternal(n.url) });
+const chrome: SiteChrome = {
+  title: settings.siteTitle, tagline: settings.tagline, logo: settings.siteLogo,
+  homeUrl: reqLocale ? localeHomeUrl(reqLocale) : '/',
+  links: headerLinks.map(chromeLink),
+  footerLinks: footerNav.map(chromeLink),
+  social: socialNav.map((n) => ({ ...chromeLink(n), icon: n.icon })),
+  readLinks: readLinks.map(chromeLink),
+  footerHtml,
+  languages: I18N.enabled ? I18N.locales.map((l) => ({ code: l, label: langName(l), url: localePath(barePath, l), current: l === (reqLocale || I18N.defaultLocale) })) : [],
+  search: showSearch ? { url: searchAction, label: searchT.label } : null,
+  schemeToggle,
+  liveHeader: Boolean(liveSignals?.header),
+  headerStyle: String(tokens.header), footerStyle: String(tokens.footer),
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const HeaderTpl = design.theme.HeaderTemplate as any;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const FooterTpl = design.theme.FooterTemplate as any;
 // hreflang alternates: every public page exists in each language (translated
 // words where available, the main language otherwise)
 const isHomePath = I18N.enabled && !noindex && !bare;
@@ -246,7 +271,8 @@ const homeJsonLd =
       </script>
     )}
     {!bare && <a class="skip-link" href="#main">Skip to content</a>}
-    {!bare && (
+    {!bare && HeaderTpl && <HeaderTpl site={chrome} />}
+    {!bare && !HeaderTpl && (
       <header class="site-header" data-style={tokens.header}>
         <div class="site-header-in">
           <a class="brand" href={reqLocale ? localeHomeUrl(reqLocale) : '/'}>
@@ -644,7 +670,8 @@ const homeJsonLd =
     <main class="site-main" id="main">
       <slot />
     </main>
-    {!bare && (
+    {!bare && FooterTpl && <FooterTpl site={chrome} />}
+    {!bare && !FooterTpl && (
       <footer class="site-footer" data-style={tokens.footer}>
         <div class="site-footer-in">
           {tokens.footer === 'columns' ? (

package/src/lib/backup/content.ts

@@ -2,6 +2,11 @@ import { z } from 'zod';
 import { Page, Post, Media, Link, Tag, User, NavItem, Redirect, Settings, Calendar, CalEvent, Resource, BookingLink, Booking } from '../schema';
 import type { ContentRepository } from '../repo/types';
 
+// backups from before booking approval modes: a link that didn't confirm on
+// its own must stay manual (a missing `approval` would follow the site default)
+const legacyApproval = (l: unknown) =>
+  l && typeof l === 'object' && !('approval' in l) && (l as { autoConfirm?: boolean }).autoConfirm === false ? { ...l, approval: 'manual' } : l;
+
 export const BookingRequest = z.object({ keyHash: z.string().regex(/^[a-f0-9]{64}$/), requestHash: z.string().regex(/^[a-f0-9]{64}$/), bookingId: z.string().min(1), createdAt: z.number().int().nonnegative() });
 export type BookingRequest = z.infer<typeof BookingRequest>;
 export const BackupContent = z.object({
@@ -9,7 +14,7 @@ export const BackupContent = z.object({
   settings: Settings.partial(), pages: z.array(Page), posts: z.array(Post), media: z.array(Media), links: z.array(Link),
   tags: z.array(Tag), navItems: z.array(NavItem), users: z.array(User), redirects: z.array(Redirect).default([]),
   calendars: z.array(Calendar).default([]), events: z.array(CalEvent).default([]), resources: z.array(Resource).default([]),
-  bookingLinks: z.array(BookingLink).default([]), bookings: z.array(Booking).default([]), bookingRequests: z.array(BookingRequest).optional(),
+  bookingLinks: z.array(z.preprocess(legacyApproval, BookingLink)).default([]), bookings: z.array(Booking).default([]), bookingRequests: z.array(BookingRequest).optional(),
 }).superRefine((data, ctx) => {
   if (data.version >= 5 && !data.bookingRequests) ctx.addIssue({ code: 'custom', message: 'Version 5 requires booking retry records.' });
   const keys = new Set<string>();

package/src/lib/booking/agent.ts

@@ -8,6 +8,7 @@ import { ApiError } from '../api';
 import { bookingsEnabled } from '../calendar/config';
 import { availabilityContext, bookingJson, BookingError, createResourceBooking, rescheduleBooking, setBookingStatus } from './service';
 import { addDaysYmd, describeLink, slotsForDay, ymd } from './availability';
+import { confirmsInstantly, linkApproval } from './approval';
 
 export const BookingToolInputs = [
   z.object({ tool: z.literal('list_resources'), arguments: z.object({}).strict() }).strict(),
@@ -65,7 +66,7 @@ export async function runBookingTool(repo: ContentRepository, input: Input, allo
   try {
     switch (input.tool) {
       case 'list_resources':
-        return { resources: resources.map((r) => ({ slug: r.slug, name: r.name, kind: r.kind, capacity: r.capacity, visibility: r.visibility, links: links.filter((l) => l.resourceId === r.id).map((l) => ({ slug: l.slug, name: l.name, rules: describeLink(l), mode: l.mode, lengths: l.mode === 'range' ? l.lengths : [l.duration], autoConfirm: l.autoConfirm, active: l.active, visibility: l.visibility })) })) };
+        return { resources: resources.map((r) => ({ slug: r.slug, name: r.name, kind: r.kind, capacity: r.capacity, visibility: r.visibility, links: links.filter((l) => l.resourceId === r.id).map((l) => ({ slug: l.slug, name: l.name, rules: describeLink(l), mode: l.mode, lengths: l.mode === 'range' ? l.lengths : [l.duration], autoConfirm: confirmsInstantly(linkApproval(l, settings)), active: l.active, visibility: l.visibility })) })) };
       case 'check_availability': {
         const { r, l } = resolve(input.arguments.resource, input.arguments.link);
         const c = await availabilityContext(repo, r, l, settings);
@@ -74,7 +75,7 @@ export async function runBookingTool(repo: ContentRepository, input: Input, allo
         const days = Array.from({ length: input.arguments.days }, (_, i) => addDaysYmd(from, i)).map((date) => ({
           date, slots: slotsForDay(c, date, input.arguments.minutes).slice(0, 60).map((s) => ({ start: new Date(s.start).toISOString(), end: new Date(s.end).toISOString(), minutes: s.minutes })),
         }));
-        return { timezone: tz, autoConfirm: l.autoConfirm, days };
+        return { timezone: tz, autoConfirm: confirmsInstantly(linkApproval(l, settings)), days };
       }
       case 'list_bookings': {
         const a = input.arguments;

package/src/lib/booking/approval.ts

@@ -0,0 +1,70 @@
+// Booking approval: does a new booking confirm at once, or wait for a
+// decision? Each link either follows the site default (Calendar settings →
+// Bookings, seeded from acms({ calendar: { bookings: { approval } } })) or
+// picks its own mode. "rules" confirms unless one of the rules flags the
+// booking. Pure apart from the first-time lookup, which the caller supplies.
+import type { ApprovalMode, ApprovalRules, BookingLink, Settings } from '../schema';
+import { CALENDAR } from '../calendar/config';
+
+export interface Approval {
+  mode: ApprovalMode;
+  rules: ApprovalRules;
+  // true when the link follows the site default
+  inherited: boolean;
+}
+
+export function siteApproval(settings: Pick<Settings, 'calendar'>): { mode: ApprovalMode; rules: ApprovalRules } {
+  return { mode: settings.calendar.approval || CALENDAR.bookingApproval, rules: settings.calendar.approvalRules };
+}
+
+export function linkApproval(link: Pick<BookingLink, 'approval' | 'approvalRules'>, settings: Pick<Settings, 'calendar'>): Approval {
+  if (link.approval === 'default') return { ...siteApproval(settings), inherited: true };
+  return { mode: link.approval, rules: link.approvalRules, inherited: false };
+}
+
+// what the public page promises before someone books
+export function confirmsInstantly(a: Approval): boolean {
+  return a.mode === 'auto';
+}
+
+export interface ApprovalInput {
+  start: number;
+  end: number;
+  seats: number;
+  // has this email booked (any status but declined/cancelled) before?
+  returning: boolean;
+}
+
+// why a "rules" booking needs a person to look at it; [] = confirm now
+export function approvalReasons(a: Approval, b: ApprovalInput): string[] {
+  if (a.mode === 'auto') return [];
+  if (a.mode === 'manual') return ['Every booking on this link needs approval'];
+  const r = a.rules;
+  const out: string[] = [];
+  if (r.longerThan > 0 && (b.end - b.start) / 60_000 > r.longerThan) out.push(`Longer than ${durationLabel(r.longerThan)}`);
+  if (r.firstTime && !b.returning) out.push('First booking from this email');
+  if (r.moreSeats > 0 && b.seats > r.moreSeats) out.push(`More than ${r.moreSeats} seats`);
+  return out;
+}
+
+export function decideStatus(a: Approval, b: ApprovalInput): 'confirmed' | 'pending' {
+  return approvalReasons(a, b).length ? 'pending' : 'confirmed';
+}
+
+export function durationLabel(min: number): string {
+  if (min % 1440 === 0) return `${min / 1440} day${min === 1440 ? '' : 's'}`;
+  if (min % 60 === 0) return `${min / 60} hour${min === 60 ? '' : 's'}`;
+  if (min > 60) return `${Math.floor(min / 60)} h ${min % 60} min`;
+  return `${min} min`;
+}
+
+export const APPROVAL_LABEL: Record<ApprovalMode, string> = {
+  auto: 'Automatically confirm',
+  rules: 'Automatically, unless…',
+  manual: 'I approve each booking',
+};
+
+// one short phrase for rows and badges: "Instant" / "Needs approval" / "Instant, with rules"
+export function approvalShort(a: Approval): string {
+  return a.mode === 'auto' ? 'Instant' : a.mode === 'manual' ? 'Needs approval' : 'Instant, with rules';
+}

package/src/lib/booking/holds.ts

@@ -0,0 +1,120 @@
+// Rooms held by events. An event that lists rooms/people in roomHold makes
+// them unbookable while it happens (± setup/cleanup) or for the whole day.
+// Holds are computed from events every time — never stored as bookings — so
+// moving, repeating, skipping a date, cancelling or deleting the event frees
+// or moves the room automatically. availabilityContext() adds these to its
+// busy list, so every booking path (pages, embeds, app, API, agent) obeys.
+import type { ContentRepository } from '../repo/types';
+import type { Booking, CalEvent, Resource, Settings } from '../schema';
+import { expandEvents } from '../calendar/events';
+import { tzParts, zonedToUtc } from '../calendar/ics';
+import { resourceZone } from './availability';
+
+export interface Hold {
+  resourceId: string;
+  eventId: string;
+  title: string;
+  start: number; // incl. setup
+  end: number; // incl. cleanup
+  eventStart: number; // the occurrence itself
+  eventEnd: number;
+}
+
+const DAY = 86_400_000;
+
+/** Does this event hold its rooms right now? */
+export function holdsRooms(e: Pick<CalEvent, 'status' | 'cancelled' | 'roomHold'>): boolean {
+  if (e.cancelled || !e.roomHold.resourceIds.length) return false;
+  return e.status === 'published' || e.status === 'scheduled' || (e.status === 'draft' && e.roomHold.whileDraft);
+}
+
+// midnight (in tz) of the day containing ms
+function dayStart(ms: number, tz: string): number {
+  const p = tzParts(ms, tz);
+  return zonedToUtc(p.y, p.m, p.d, 0, 0, 0, tz);
+}
+function nextDayStart(ms: number, tz: string): number {
+  // +26h then back to that day's midnight survives DST changes
+  return dayStart(dayStart(ms, tz) + DAY + 2 * 3_600_000, tz);
+}
+
+/** Holds for the given events in [from, to). `force` counts drafts too (editor previews). */
+export function holdsFromEvents(
+  events: CalEvent[],
+  resources: Map<string, Pick<Resource, 'id' | 'timezone'>>,
+  settings: Pick<Settings, 'timezone'>,
+  from: number,
+  to: number,
+  opts: { force?: boolean; resourceId?: string } = {}
+): Hold[] {
+  const out: Hold[] = [];
+  const holding = events.filter((e) => (opts.force ? !e.cancelled && e.roomHold.resourceIds.length > 0 : holdsRooms(e))
+    && (!opts.resourceId || e.roomHold.resourceIds.includes(opts.resourceId)));
+  if (!holding.length) return out;
+  // widen the window so setup/cleanup and whole-day holds at the edges count
+  const pad = 2 * DAY;
+  const occurrences = expandEvents(holding, settings, { displayTz: settings.timezone || 'UTC', now: from, windowStartMs: from - pad, windowEndMs: to + pad });
+  for (const o of occurrences) {
+    const h = o.event.roomHold;
+    for (const resourceId of h.resourceIds) {
+      if (opts.resourceId && resourceId !== opts.resourceId) continue;
+      const r = resources.get(resourceId);
+      if (!r) continue;
+      let start: number;
+      let end: number;
+      if (h.span === 'day') {
+        const tz = resourceZone(r, settings.timezone || 'UTC');
+        start = dayStart(o.start, tz);
+        end = nextDayStart(Math.max(o.start, o.end - 1), tz);
+      } else {
+        start = o.start - h.before * 60_000;
+        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 });
+    }
+  }
+  return out.sort((a, b) => a.start - b.start);
+}
+
+/** Holds on the site's live events (what booking pages must respect). */
+export async function eventHolds(repo: ContentRepository, settings: Pick<Settings, 'timezone'>, from: number, to: number, resourceId?: string): Promise<Hold[]> {
+  const [events, resources] = await Promise.all([repo.listEvents(), repo.listResources()]);
+  return holdsFromEvents(events, new Map(resources.map((r) => [r.id, r])), settings, from, to, { resourceId });
+}
+
+export interface HoldConflict {
+  booking: Pick<Booking, 'id' | 'name' | 'email' | 'start' | 'end' | 'status' | 'resourceId' | 'kind' | 'notes'>;
+  hold: Hold;
+}
+
+/**
+ * Bookings that overlap an event's holds. `event` may be unsaved (the
+ * editor's current values): holds are computed as if it were published.
+ * Repeating events are checked over the next `horizonDays` (default a year).
+ */
+export async function holdConflicts(
+  repo: ContentRepository,
+  settings: Pick<Settings, 'timezone'>,
+  event: CalEvent,
+  opts: { now?: number; horizonDays?: number } = {}
+): Promise<{ conflicts: HoldConflict[]; holds: Hold[] }> {
+  const now = opts.now ?? Date.now();
+  const to = now + (opts.horizonDays ?? 366) * DAY;
+  const resources = new Map((await repo.listResources()).map((r) => [r.id, r]));
+  const holds = holdsFromEvents([event], resources, settings, now, to, { force: true });
+  if (!holds.length) return { conflicts: [], holds };
+  const keep = new Set(event.roomHold.keep);
+  const conflicts: HoldConflict[] = [];
+  for (const resourceId of new Set(holds.map((h) => h.resourceId))) {
+    const mine = holds.filter((h) => h.resourceId === resourceId);
+    const bookings = await repo.listBookings({ resourceId, from: mine[0].start, to: mine[mine.length - 1].end, statuses: ['pending', 'confirmed'], kinds: ['booking', 'block'] });
+    for (const b of bookings) {
+      if (keep.has(b.id)) continue;
+      // a booking's own buffers (hold_start/end) don't count, only its real time
+      const hold = mine.find((h) => b.start < h.end && b.end > h.start);
+      if (hold) conflicts.push({ booking: { id: b.id, name: b.name, email: b.email, start: b.start, end: b.end, status: b.status, resourceId: b.resourceId, kind: b.kind, notes: b.notes }, hold });
+    }
+  }
+  return { conflicts: conflicts.sort((a, b) => a.booking.start - b.booking.start), holds };
+}

package/src/lib/booking/service.ts

@@ -12,6 +12,8 @@ import { manageUrl as manageUrlFor, eventUrl } from '../calendar/config';
 import { eventTimeZone, locationLine } from '../calendar/events';
 import { bookingEmail, whenText, type BookingEmail } from './emails';
 import { holdOf, isBookable, resourceZone, type AvailabilityContext, type Interval } from './availability';
+import { decideStatus, linkApproval } from './approval';
+import { eventHolds } from './holds';
 
 export interface FlowOptions {
   origin: string;
@@ -62,11 +64,13 @@ export async function availabilityContext(
   ignoreBookingId?: string
 ): Promise<AvailabilityContext> {
   const to = now + (link.maxAdvance + 2) * 86_400_000;
-  const [bookings, busy] = await Promise.all([
+  const [bookings, busy, held] = await Promise.all([
     repo.listBookings({ resourceId: resource.id, from: now - 86_400_000, to, statuses: ['pending', 'confirmed'] }),
     busyIntervals(resource, now - 86_400_000, to, now),
+    // events that use this room/person (lib/booking/holds.ts)
+    eventHolds(repo, settings, now - 86_400_000, to, resource.id),
   ]);
-  return { resource, link, bookings, busy, siteTimezone: settings.timezone, now, ignoreBookingId };
+  return { resource, link, bookings, busy: [...busy, ...held.map(({ start, end }) => ({ start, end }))], siteTimezone: settings.timezone, now, ignoreBookingId };
 }
 
 // ---- notifications ---------------------------------------------------------
@@ -171,7 +175,11 @@ export async function createResourceBooking(
   // staff adding a booking by hand may ignore notice windows, never overlaps
   const ctx = await availabilityContext(repo, resource, link, settings, opts.now ?? Date.now());
   if (args.source !== 'admin' && !isBookable(ctx, args.start, args.end)) throw new BookingError(409, 'That time was just taken or isn’t available. Please pick another.');
-  const status: BookingStatus = args.status ?? (link.autoConfirm ? 'confirmed' : 'pending');
+  const approval = linkApproval(link, settings);
+  const returning = approval.mode === 'rules' && approval.rules.firstTime
+    ? (await repo.listBookings({ email: booker.email, statuses: ['pending', 'confirmed'], kinds: ['booking'] })).length > 0
+    : true;
+  const status: BookingStatus = args.status ?? decideStatus(approval, { start: args.start, end: args.end, seats: 1, returning });
   const b = await repo.createBooking({
     kind: 'booking', resourceId: resource.id, linkId: link.id, eventId: '', status,
     start: args.start, end: args.end, ...holdOf(link, args.start, args.end),
@@ -275,3 +283,29 @@ export async function sendDueReminders(repo: ContentRepository, opts: FlowOption
   await kickEmail(repo,opts.locals,opts.waitUntil);
   return due.length;
 }
+
+// cron: pending bookings nobody answered within the link's deadline get the
+// chosen decision (approve or decline). Bookings that already started are
+// left alone — deciding them now would only send a confusing email.
+export async function decideOverdue(repo: ContentRepository, opts: FlowOptions): Promise<number> {
+  const now = opts.now ?? Date.now();
+  const pending = await repo.listBookings({ from: now, statuses: ['pending'], kinds: ['booking'] });
+  if (!pending.length) return 0;
+  const settings = await repo.getSettings();
+  const links = new Map<string, BookingLink | null>();
+  let decided = 0;
+  for (const b of pending) {
+    if (b.start <= now) continue;
+    if (!links.has(b.linkId)) links.set(b.linkId, await repo.getBookingLink(b.linkId));
+    const link = links.get(b.linkId);
+    if (!link) continue;
+    const { rules } = linkApproval(link, settings);
+    if (!rules.deadlineHours || b.createdAt + rules.deadlineHours * 3_600_000 > now) continue;
+    try {
+      await setBookingStatus(repo, b, rules.deadlineAction === 'decline' ? 'declined' : 'confirmed', opts,
+        rules.deadlineAction === 'decline' ? 'We weren’t able to confirm this booking in time. Please pick another time.' : undefined);
+      decided++;
+    } catch { /* changed meanwhile — next sweep sees the new state */ }
+  }
+  return decided;
+}

package/src/lib/calendar/agent-schema.ts

@@ -15,6 +15,14 @@ const eventFields = {
   location: z.object({ name: z.string().max(300).default(''), address: z.string().max(500).default(''), url: z.string().max(1000).default('') }).strict().optional(),
   cta: z.object({ label: z.string().max(120).default(''), href: z.string().max(1000).default(''), style: z.enum(['primary', 'outline']).default('primary') }).strict().optional(),
   calendars: z.array(z.string().max(100)).max(20).optional(),
+  // bookable rooms/people (slugs from the booking resources) this event uses:
+  // they can't be booked while it happens (± setup/cleanup minutes) or all day
+  rooms: z.object({
+    resources: z.array(z.string().max(100)).max(50),
+    span: z.enum(['event', 'day']).default('event'),
+    setup: z.number().int().min(0).max(1440).default(0),
+    cleanup: z.number().int().min(0).max(1440).default(0),
+  }).strict().optional(),
   tags: z.array(z.string().trim().min(1).max(100)).max(50).optional(),
   cancelled: z.boolean().optional(),
   seoTitle: z.string().max(300).optional(),
@@ -43,6 +51,6 @@ export const EVENT_TOOL_DESCRIPTIONS: Record<(typeof EVENT_TOOL_NAMES)[number],
   get_event: 'Read one event including any pending draft. Times are wall-clock strings in the event timezone.',
   list_calendars: 'List calendars (slug, name, visibility, kind). Use slugs in create_event/update_event "calendars".',
   create_event: 'Create a DRAFT event. start/end are wall-clock "YYYY-MM-DDTHH:mm" (or "YYYY-MM-DD" with allDay) in the event timezone (site timezone when omitted). content is Markdown. rrule is an RFC 5545 rule like "FREQ=WEEKLY;BYDAY=TU". Never publishes.',
-  update_event: 'Update supplied event fields. Published/scheduled events stage a pending draft that goes live on publish/Update. calendars replaces the list.',
+  update_event: 'Update supplied event fields. rooms (resource slugs) holds bookable rooms so they cannot be booked during the event; [] releases them. Published/scheduled events stage a pending draft that goes live on publish/Update. calendars replaces the list.',
   publish_event: 'Publish an event (applying any pending draft). Requires owner-enabled publishing permission.',
 };

package/src/lib/calendar/agent.ts

@@ -35,6 +35,17 @@ async function resolveCalendars(repo: ContentRepository, slugs: string[] | undef
   });
 }
 
+async function resolveRooms(repo: ContentRepository, rooms: { resources: string[]; span: 'event' | 'day'; setup: number; cleanup: number } | undefined, keep: string[] = []) {
+  if (rooms === undefined) return undefined;
+  const all = await repo.listResources();
+  const resourceIds = rooms.resources.map((s) => {
+    const r = all.find((x) => x.slug === s || x.id === s);
+    if (!r) throw new ApiError(400, `Unknown room or person "${s}". Call list_resources for valid slugs.`);
+    return r.id;
+  });
+  return { resourceIds, span: rooms.span, before: rooms.setup, after: rooms.cleanup, whileDraft: false, keep };
+}
+
 function checkLinks(a: { cta?: { href: string }; location?: { url: string }; timezone?: string }) {
   if (a.cta?.href && !/^(https?:\/\/|\/(?!\/)|mailto:|tel:)/i.test(a.cta.href)) throw new ApiError(400, 'cta.href must start with https://, /, mailto: or tel:.');
   if (a.location?.url && !/^https?:\/\//i.test(a.location.url)) throw new ApiError(400, 'location.url must start with https://.');
@@ -54,6 +65,7 @@ export async function runEventTool(repo: ContentRepository, input: EventToolInpu
       start: e.start, end: e.end, allDay: e.allDay, rrule: e.rrule,
       next: o ? formatOccurrence(o, settings.timezone || 'UTC', siteLocale(settings)).range : '',
       calendars: e.calendarIds.map((id) => calMap.get(id)?.slug).filter(Boolean),
+      rooms: e.roomHold.resourceIds.length ? { resources: e.roomHold.resourceIds, span: e.roomHold.span, setup: e.roomHold.before, cleanup: e.roomHold.after } : null,
       hasPendingDraft: Boolean(e.draft), editUrl: editUrl(e.id),
     };
   };
@@ -91,13 +103,14 @@ export async function runEventTool(repo: ContentRepository, input: EventToolInpu
         rrule: a.rrule ?? '', excerpt: a.excerpt ?? '', location: a.location, cta: a.cta, tags: a.tags,
         cancelled: a.cancelled ?? false, seoTitle: a.seoTitle, seoDesc: a.seoDesc,
         calendarIds: (await resolveCalendars(repo, a.calendars)) ?? [],
+        ...(a.rooms ? { roomHold: await resolveRooms(repo, a.rooms) } : {}),
         ...(a.content !== undefined ? { bodyHtml: renderAgentMarkdown(a.content) } : {}),
       });
       if (a.tags?.length) await repo.ensureTags(a.tags);
       return { ...summary(e) };
     }
     case 'update_event': {
-      const { id, content, calendars: slugs, ...rest } = input.arguments;
+      const { id, content, calendars: slugs, rooms, ...rest } = input.arguments;
       checkLinks(rest);
       const before = await repo.getEvent(id);
       if (!before) throw new ApiError(404, 'Event not found.');
@@ -108,6 +121,8 @@ export async function runEventTool(repo: ContentRepository, input: EventToolInpu
       }
       const calendarIds = await resolveCalendars(repo, slugs);
       if (calendarIds) data.calendarIds = calendarIds;
+      const roomHold = await resolveRooms(repo, rooms, before.roomHold.keep);
+      if (roomHold) data.roomHold = roomHold;
       if (data.start !== undefined || data.end !== undefined || data.allDay !== undefined) {
         const merged = mergeEventDraft(before);
         try {