@acms-subir/core 0.3.3 → 0.3.5

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/components/import/ImportExport.tsx

@@ -98,7 +98,7 @@ function ImportTab({ onFinished, openHistory }: { onFinished: () => void; openHi
   const key = planKeyFor(options);
   const stale = !!plan && planKey !== key;
   const assetFiles = bundle ? bundle.assets.filter((a) => a.kind !== 'media').length : 0;
-  const needsFiles = isGhost && assetFiles > 0 && !siteUrl.trim() && !contentZip && !source?.zip;
+  const needsFiles = isGhost && !!bundle?.assets.some((a) => !/^https?:\/\//i.test(a.url)) && !siteUrl.trim() && !contentZip && !source?.zip;
   const resumable = source ? readJournal(source.hash) : null;
   const toImport = plan ? plan.counts.posts.create + plan.counts.posts.update + plan.counts.pages.create + plan.counts.pages.update : 0;
 
@@ -198,7 +198,7 @@ function ImportTab({ onFinished, openHistory }: { onFinished: () => void; openHi
                   <span className="btn sm">{contentZip ? 'Change ZIP' : 'Add content folder ZIP'}</span>
                   <span className="hint">{contentZip ? `${contentZip.name} · ${plural(contentZip.zip.names.length, 'file')}` : 'Optional. Used first; the address is the fallback.'}</span>
                 </label>
-                {needsFiles && <p className="imp-mark warn">Without an address or ZIP, images will point at the old site and break when it goes away.</p>}
+                {needsFiles && <p className="imp-mark warn">Enter the old site’s address or add its content folder ZIP before importing. Missing files without a source URL are left empty and listed in the report.</p>}
               </div>
             )}
 
@@ -252,7 +252,7 @@ function ImportTab({ onFinished, openHistory }: { onFinished: () => void; openHi
             <div className="imp-actions">
               <button type="button" className="btn" disabled={!!busy} onClick={check}>{busy === 'plan' ? 'Checking…' : plan ? 'Check again' : 'Check import'}</button>
               {plan && (
-                <button type="button" className="btn primary" disabled={!!busy || stale || toImport === 0} onClick={run} title={stale ? 'Options changed: check again first' : ''}>
+                <button type="button" className="btn primary" disabled={!!busy || stale || needsFiles || toImport === 0} onClick={run} title={stale ? 'Options changed: check again first' : ''}>
                   {busy === 'run' ? 'Importing…' : resumable?.runId ? `Resume import` : `Import ${plural(toImport, 'item')}`}
                 </button>
               )}
@@ -341,7 +341,7 @@ function Done({ report, reset, openHistory }: { report: Report; reset: () => voi
       )}
       {!!report.failedAssets?.length && (
         <>
-          <p className="imp-mark warn">{plural(report.failedAssets.length, 'file')} couldn’t be copied and still point at the old site</p>
+          <p className="imp-mark warn">{plural(report.failedAssets.length, 'file')} couldn’t be copied. Source URLs are kept when available; otherwise the references are left empty.</p>
           <ul className="imp-list">{report.failedAssets.map((f, i) => <li key={i}>{f.url}<small>{f.error}</small></li>)}</ul>
         </>
       )}

package/src/components/import/runner.ts

@@ -101,8 +101,14 @@ export function findInZip(zip: ZipIndex, path: string): string | null {
 }
 
 export function sourceAssetUrl(bundle: ImportBundle, asset: ImportAsset): string {
-  if (/^https?:\/\//.test(asset.url)) return asset.url;
-  return bundle.source.siteUrl ? `${bundle.source.siteUrl.replace(/\/+$/, '')}/${asset.url}` : `/${asset.url}`;
+  // A ZIP path is not a URL on the destination site. Only an absolute
+  // source URL is safe to retain when copying fails.
+  try {
+    const url = /^[a-z][a-z\d+.-]*:/i.test(asset.url)
+      ? new URL(asset.url)
+      : new URL(asset.url.replace(/^\/+/, ''), `${bundle.source.siteUrl.replace(/\/+$/, '')}/`);
+    return ['http:', 'https:'].includes(url.protocol) ? url.href : '';
+  } catch { return ''; }
 }
 
 async function fetchAsset(bundle: ImportBundle, asset: ImportAsset, contentZip: ZipIndex | null): Promise<File> {
@@ -170,6 +176,10 @@ export async function runImport(
   const journal: Journal = readJournal(hash) ?? { runId: '', assets: {}, failed: {}, done: [], authorIds: {} };
   const save = () => writeJournal(hash, journal);
 
+  if (source.kind === 'ghost' && !files && bundle.assets.some((a) => !journal.assets[a.ref] && !sourceAssetUrl(bundle, a))) {
+    throw new Error('This Ghost export references images or files. Enter the old site’s address or add its content folder ZIP before importing.');
+  }
+
   // 1. files → media library
   const assets = bundle.assets.filter((a) => a.kind !== 'media');
   const total = assets.length + bundle.media.length;
@@ -214,6 +224,13 @@ export async function runImport(
 
   const resolved = new Map(Object.entries(journal.assets).map(([ref, r]) => [ref, r]));
   const fallback = new Map(bundle.assets.map((a) => [a.ref, sourceAssetUrl(bundle, a)]));
+  // Video/audio are not copied yet, but missing source URLs still need to
+  // be reported instead of quietly turning into destination-relative URLs.
+  for (const a of bundle.assets.filter((a) => a.kind === 'media')) {
+    if (!resolved.has(a.ref) && !fallback.get(a.ref)) {
+      journal.failed[a.ref] = 'Video/audio cannot be copied yet. Enter the old site’s address to keep its source URL.';
+    } else delete journal.failed[a.ref];
+  }
   const fix = (v: string) => resolveAssets(v, resolved, fallback);
 
   // 2. run + authors + tags; only people with a byline become authors
@@ -261,7 +278,7 @@ export async function runImport(
   const identity = Object.fromEntries(Object.entries(bundle.identity).map(([k, v]) => [k, typeof v === 'string' ? fix(v) : v]));
   const failedAssets = Object.entries(journal.failed).map(([ref, error]) => {
     const a = bundle.assets.find((x) => x.ref === ref);
-    return { url: a ? sourceAssetUrl(bundle, a) : ref.replace(/^m-/, 'media '), error };
+    return { url: a ? sourceAssetUrl(bundle, a) || a.url : ref.replace(/^m-/, 'media '), error };
   });
   const { report } = await api<{ report: Record<string, unknown> }>({
     op: 'finish', runId: journal.runId, options, identity,

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 };
+}