@acms-subir/core 0.3.3 → 0.3.5

package/src/lib/calendar/schedule.ts

@@ -0,0 +1,166 @@
+// Writes behind the admin Schedule: quick add, drag to move (a whole series
+// or one occurrence), undo, duplicate. Everything goes through the same
+// save/apply path as the event editor, so hooks, feeds, search and webhooks
+// see the same changes. A move applies at once, even on a published event —
+// the editor's "stage until Update" flow is for content edits, not dates.
+import type { ContentRepository } from '../repo/types';
+import type { CalEvent } from '../schema';
+import { slugify } from '../schema';
+import { ApiError } from '../api';
+import { applyEventUpdate, saveEvent, type SaveHooks } from '../content-service';
+import { addWallDays, formatWall, parseWall } from './events';
+import { rruleMap, WEEKDAY_CODES, weekdayOf } from './rrule';
+import { eventDeleted } from './hooks';
+import { waitUntilFrom } from '../webhooks';
+
+async function uniqueSlug(repo: ContentRepository, title: string) {
+  const base = slugify(title) || 'event';
+  let slug = base;
+  for (let n = 2; await repo.getEventBySlug(slug); n++) slug = `${base}-${n}`;
+  return slug;
+}
+
+const live = (s: CalEvent['status']) => s === 'published' || s === 'scheduled';
+
+// Save on a live event without staging: stage, then apply just this change.
+// Refuses when the event already has unrelated unpublished edits, so a drag
+// never publishes someone's half-finished copy.
+async function saveNow(repo: ContentRepository, e: CalEvent, data: Parameters<typeof saveEvent>[2], hooks: SaveHooks) {
+  if (live(e.status) && e.draft) {
+    throw new ApiError(409, 'This event has unpublished changes. Open it and update or discard them first.');
+  }
+  const saved = await saveEvent(repo, e.id, data, hooks);
+  return live(e.status) ? applyEventUpdate(repo, e.id, hooks) : saved;
+}
+
+export interface QuickEvent {
+  title: string;
+  start: string; // YYYY-MM-DD or YYYY-MM-DDTHH:mm
+  end: string;
+  allDay: boolean;
+  calendarId: string;
+  rrule: string;
+  location: string;
+  publish: boolean;
+  // bookable rooms/people this event uses (held while it happens)
+  roomIds?: string[];
+}
+
+export async function quickCreate(repo: ContentRepository, q: QuickEvent, hooks: SaveHooks): Promise<CalEvent> {
+  const title = q.title.trim().slice(0, 300) || 'Untitled event';
+  const cal = q.calendarId ? await repo.getCalendar(q.calendarId) : null;
+  const created = await repo.createEvent({
+    title, slug: await uniqueSlug(repo, title), start: q.start, allDay: q.allDay, status: 'draft',
+    calendarIds: cal?.kind === 'native' ? [cal.id] : [],
+    location: { name: q.location.trim().slice(0, 300), address: '', url: '' },
+  });
+  if (q.roomIds?.length) await saveEvent(repo, created.id, { roomHold: { resourceIds: q.roomIds, span: 'event', before: 0, after: 0, whileDraft: false, keep: [] } }, hooks);
+  // times + repeat go through the editor's validation (end defaults, pairs)
+  await saveEvent(repo, created.id, { start: q.start, end: q.end || undefined, allDay: q.allDay, rrule: q.rrule }, hooks);
+  return q.publish ? saveEvent(repo, created.id, { status: 'published' }, hooks) : (await repo.getEvent(created.id))!;
+}
+
+// Shift a recurrence rule by whole days so "weekly on Wednesday" moved two
+// days later becomes "weekly on Friday" (and nth-weekday / day-of-month
+// rules follow the new first date). UNTIL moves with the series.
+export function shiftRrule(rrule: string, days: number, newStart: string): string {
+  if (!rrule || !days) return rrule;
+  const p = rruleMap(rrule);
+  if (p.FREQ === 'WEEKLY' && p.BYDAY) {
+    p.BYDAY = p.BYDAY.split(',').map((c) => {
+      const i = (WEEKDAY_CODES as readonly string[]).indexOf(c);
+      return i < 0 ? c : WEEKDAY_CODES[(((i + days) % 7) + 7) % 7];
+    }).join(',');
+  }
+  if (p.FREQ === 'MONTHLY') {
+    const wd = weekdayOf(newStart);
+    if (p.BYDAY && /^-?\d(SU|MO|TU|WE|TH|FR|SA)$/.test(p.BYDAY)) p.BYDAY = `${wd.nth >= 5 || p.BYDAY.startsWith('-') ? -1 : wd.nth}${WEEKDAY_CODES[wd.dow]}`;
+    else if (p.BYMONTHDAY && !p.BYMONTHDAY.includes(',')) p.BYMONTHDAY = String(wd.day);
+  }
+  if (p.UNTIL && /^\d{8}$/.test(p.UNTIL)) {
+    const u = parseWall(`${p.UNTIL.slice(0, 4)}-${p.UNTIL.slice(4, 6)}-${p.UNTIL.slice(6, 8)}`);
+    if (u) p.UNTIL = formatWall(addWallDays(u, days)).replace(/-/g, '');
+  }
+  const order = ['FREQ', 'INTERVAL', 'BYDAY', 'BYMONTHDAY', 'BYMONTH', 'COUNT', 'UNTIL', 'WKST'];
+  return Object.entries(p).sort(([a], [b]) => order.indexOf(a) - order.indexOf(b)).map(([k, v]) => `${k}=${v}`).join(';');
+}
+
+const shift = (wall: string, days: number) => {
+  const w = parseWall(wall);
+  return w ? formatWall(addWallDays(w, days)) : wall;
+};
+
+export type MoveUndo =
+  | { kind: 'series'; id: string; days: number }
+  | { kind: 'split'; id: string; seriesId: string; occurrence: string };
+
+// Move a whole event (and every repeat) by `days`
+export async function moveSeries(repo: ContentRepository, id: string, days: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo }> {
+  const e = await repo.getEvent(id);
+  if (!e) throw new ApiError(404, 'Event not found.');
+  if (!Number.isInteger(days) || Math.abs(days) > 3660) throw new ApiError(400, 'Pick a day to move it to.');
+  const start = shift(e.start, days);
+  const event = await saveNow(repo, e, {
+    start, end: shift(e.end, days), allDay: e.allDay,
+    ...(e.rrule ? { rrule: shiftRrule(e.rrule, days, start), exdates: e.exdates.map((x) => shift(x, days)) } : {}),
+  }, hooks);
+  return { event, undo: { kind: 'series', id, days: -days } };
+}
+
+// Move one occurrence of a repeating event: skip that date in the series and
+// add a one-off copy on the new date. No schema change, and the copy is a
+// normal event the editor can open.
+export async function moveOccurrence(repo: ContentRepository, id: string, occurrence: string, days: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo }> {
+  const e = await repo.getEvent(id);
+  if (!e) throw new ApiError(404, 'Event not found.');
+  if (!e.rrule) return moveSeries(repo, id, days, hooks);
+  const occ = parseWall(occurrence);
+  const first = parseWall(e.start);
+  if (!occ || !first) throw new ApiError(400, 'That date isn’t part of this event.');
+  if (e.exdates.includes(occurrence)) throw new ApiError(409, 'That date was already removed from the series.');
+  // keep the occurrence's own length (first occurrence's start → end)
+  const toMs = (w: { y: number; m: number; d: number; hh: number; mm: number }) => Date.UTC(w.y, w.m - 1, w.d, w.hh, w.mm);
+  const lenMs = toMs(parseWall(e.end) ?? first) - toMs(first);
+  const newStart = addWallDays(occ, days);
+  const t = new Date(toMs(newStart) + lenMs);
+  const pad = (n: number) => String(n).padStart(2, '0');
+  const endDay = `${t.getUTCFullYear()}-${pad(t.getUTCMonth() + 1)}-${pad(t.getUTCDate())}`;
+  const endStr = e.allDay ? endDay : `${endDay}T${pad(t.getUTCHours())}:${pad(t.getUTCMinutes())}`;
+
+  await saveNow(repo, e, { exdates: [...e.exdates, occurrence] }, hooks);
+  const copy = await repo.createEvent({
+    title: e.title, slug: await uniqueSlug(repo, e.title), start: formatWall(newStart), end: endStr, allDay: e.allDay,
+    timezone: e.timezone, status: 'draft', excerpt: e.excerpt, bodyJson: e.bodyJson, bodyHtml: e.bodyHtml, cover: e.cover, coverAlt: e.coverAlt,
+    location: e.location, cta: e.cta, calendarIds: e.calendarIds, fields: e.fields, tags: e.tags, cancelled: e.cancelled, rsvp: e.rsvp,
+    template: e.template, featured: false,
+  });
+  const event = live(e.status) ? await saveEvent(repo, copy.id, { status: 'published' }, hooks) : copy;
+  return { event, undo: { kind: 'split', id: copy.id, seriesId: e.id, occurrence } };
+}
+
+export async function undoMove(repo: ContentRepository, undo: MoveUndo, hooks: SaveHooks): Promise<void> {
+  if (undo.kind === 'series') {
+    await moveSeries(repo, undo.id, undo.days, hooks);
+    return;
+  }
+  const series = await repo.getEvent(undo.seriesId);
+  const copy = await repo.getEvent(undo.id);
+  if (copy) {
+    await repo.deleteEvent(copy.id);
+    await eventDeleted(repo, copy, { waitUntil: waitUntilFrom(hooks.locals) });
+  }
+  if (series) await saveNow(repo, series, { exdates: series.exdates.filter((x) => x !== undo.occurrence) }, hooks);
+}
+
+export async function duplicateEvent(repo: ContentRepository, id: string): Promise<CalEvent> {
+  const e = await repo.getEvent(id);
+  if (!e) throw new ApiError(404, 'Event not found.');
+  const src = e.draft ? { ...e, ...(e.draft as Partial<CalEvent>) } : e;
+  const title = `${src.title} (copy)`;
+  return repo.createEvent({
+    title, slug: await uniqueSlug(repo, title), start: src.start, end: src.end, allDay: src.allDay, timezone: src.timezone,
+    rrule: src.rrule, exdates: src.exdates, status: 'draft', excerpt: src.excerpt, bodyJson: src.bodyJson, bodyHtml: src.bodyHtml,
+    cover: src.cover, coverAlt: src.coverAlt, location: src.location, cta: src.cta, calendarIds: src.calendarIds, fields: src.fields,
+    tags: src.tags, rsvp: src.rsvp, template: src.template,
+  });
+}

package/src/lib/content-service.ts

@@ -132,6 +132,11 @@ export async function cleanEventInput(repo: ContentRepository, data: EventSave,
       throw new ApiError(400, err instanceof Error ? err.message : 'Invalid time.');
     }
   }
+  if (out.roomHold !== undefined) {
+    // only rooms/people that exist; order kept, duplicates dropped
+    const known = new Set((await repo.listResources()).map((r) => r.id));
+    out.roomHold = { ...out.roomHold, resourceIds: [...new Set(out.roomHold.resourceIds.filter((id) => known.has(id)))] };
+  }
   if (out.calendarIds !== undefined) {
     const known = new Set((await repo.listCalendars()).filter((c) => c.kind === 'native').map((c) => c.id));
     out.calendarIds = [...new Set(out.calendarIds.filter((c) => known.has(c)))];

package/src/lib/drafts.ts

@@ -25,7 +25,7 @@ export const PAGE_DRAFT_KEYS = [
 export const EVENT_DRAFT_KEYS = [
   'title', 'slug', 'bodyJson', 'bodyHtml', 'excerpt', 'tags', 'cover', 'coverAlt',
   'seoTitle', 'seoDesc', 'featured', 'template', 'start', 'end', 'allDay',
-  'timezone', 'rrule', 'exdates', 'cancelled', 'location', 'cta', 'calendarIds', 'fields', 'rsvp', 'translations',
+  'timezone', 'rrule', 'exdates', 'cancelled', 'location', 'cta', 'calendarIds', 'fields', 'rsvp', 'translations', 'roomHold',
 ] as const;
 
 type PostDraftKey = (typeof POST_DRAFT_KEYS)[number];

package/src/lib/import/bundle.ts

@@ -146,7 +146,8 @@ export const assetPlaceholder = (ref: string) => `${ASSET_SCHEME}${ref}`;
 // Swap every acms-asset:<ref> for its re-hosted URL. <img> tags built by the
 // importers carry only src/alt/width/height, so images that gained responsive
 // variants get srcset/sizes added here. Unresolved refs (a failed download)
-// fall back to the original URL, which is reported separately.
+// fall back to an absolute source URL, or an empty string if none is known.
+// Copy failures are reported separately by the runner.
 export interface ResolvedAsset { url: string; srcset?: string; sizes?: string }
 const PLACEHOLDER_RE = /acms-asset:([a-z0-9-]{1,40})/g;
 export function resolveAssets(value: string, resolved: Map<string, ResolvedAsset>, fallback: Map<string, string>): string {

package/src/lib/mobile/calendar.ts

@@ -8,9 +8,10 @@ import { availabilityContext } from '../booking/service';
 import { addDaysYmd, describeLink, linkLengths, localMidnight, slotsForDay, ymd } from '../booking/availability';
 import { siteOrigin } from '../seo';
 import { safeUrl } from './content';
-import { pageQuery, isoDay, queryParams } from './http';
+import { pageQuery, isoDay, isoDayOrInstant, queryParams } from './http';
 import { localizeDoc } from '../translations';
 import { localeQuery, mobileLocale, localizedUrl } from './locale';
+import { confirmsInstantly, linkApproval } from '../booking/approval';
 
 export function requireCalendar(bookings = false) {
   if (!CALENDAR.enabled || (bookings && !bookingsEnabled())) throw new ApiError(404, 'This feature is disabled.');
@@ -21,7 +22,7 @@ export async function listCalendars(repo: ContentRepository, url: URL) {
   const origin = siteOrigin(await repo.getSettings(), url);
   return { calendars: (await repo.listCalendars()).filter(c => c.visibility === 'public').map(c => calendarToJson(c, origin)) };
 }
-export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: isoDay.optional(), to: isoDay.optional(), calendar: z.string().min(1).max(200).optional(), q: z.string().max(100).optional() }).strict();
+export const eventsQuery = z.object({ ...pageQuery, locale: localeQuery, from: isoDayOrInstant.optional(), to: isoDayOrInstant.optional(), calendar: z.string().min(1).max(200).optional(), q: z.string().max(100).optional() }).strict();
 export async function listEvents(repo: ContentRepository, url: URL) {
   requireCalendar();
   const q = eventsQuery.parse(queryParams(url));
@@ -29,8 +30,11 @@ export async function listEvents(repo: ContentRepository, url: URL) {
   const [settings, calendars, events] = await Promise.all([repo.getSettings(), repo.listCalendars(), repo.listPublishedEvents()]);
   // days are the site's calendar days (a New York site's "today" starts at midnight there, not UTC)
   const tz = settings.timezone || 'UTC';
-  const from = localMidnight(q.from ?? ymd(Date.now(), tz), tz);
-  const to = q.to ? localMidnight(q.to, tz) : localMidnight(addDaysYmd(q.from ?? ymd(Date.now(), tz), 30), tz);
+  // a plain day is the site's midnight; a date-time is that exact instant
+  const at = (v: string) => (v.length === 10 ? localMidnight(v, tz) : Date.parse(v));
+  const fromDay = q.from ?? ymd(Date.now(), tz);
+  const from = at(fromDay);
+  const to = q.to ? at(q.to) : fromDay.length === 10 ? localMidnight(addDaysYmd(fromDay, 30), tz) : from + 30 * 86400000;
   if (to <= from || to - from > 90 * 86400000 + 3600000) throw new ApiError(400, 'Use an event window of 1 to 90 days.');
   const all = new Map(calendars.map(c => [c.id, c]));
   const cal = q.calendar ? calendars.find(c => c.slug === q.calendar && c.visibility !== 'private') : null;
@@ -67,7 +71,7 @@ export async function listResources(repo: ContentRepository, url: URL) {
     photo: safeUrl(r.photo, origin), timezone: r.timezone || settings.timezone || 'UTC', url: origin + resourceUrl(r.slug),
     links: links.filter(l => l.resourceId === r.id && l.active && l.visibility === 'public').map(l => ({
       id: l.id, slug: l.slug, name: l.name, description: l.description, mode: l.mode, lengths: linkLengths(l), rules: describeLink(l),
-      askPhone: l.askPhone, autoConfirm: l.autoConfirm, url: origin + bookingLinkUrl(r.slug, l.slug),
+      askPhone: l.askPhone, autoConfirm: confirmsInstantly(linkApproval(l, settings)), url: origin + bookingLinkUrl(r.slug, l.slug),
       questions: l.questions.map(({ id, label, type, required, options }) => ({ id, label, type, required, options })),
     })),
   })), pagination: { page: q.page, limit: q.limit, nextPage: visible.length > start + q.limit ? q.page + 1 : null } };
@@ -85,7 +89,7 @@ export async function getAvailability(repo: ContentRepository, url: URL) {
   const ctx = await availabilityContext(repo, resource, link, settings);
   const timezone = resource.timezone || settings.timezone || 'UTC';
   const from = q.from ?? ymd(Date.now(), timezone);
-  return { timezone, mode: link.mode, lengths: linkLengths(link), autoConfirm: link.autoConfirm,
+  return { timezone, mode: link.mode, lengths: linkLengths(link), autoConfirm: confirmsInstantly(linkApproval(link, settings)),
     days: Array.from({ length: q.days }, (_, i) => addDaysYmd(from, i)).map(date => ({ date,
       slots: slotsForDay(ctx, date, q.minutes).map(s => ({ start: new Date(s.start).toISOString(), end: new Date(s.end).toISOString(), minutes: s.minutes })),
     })),

package/src/lib/mobile/http.ts

@@ -57,6 +57,12 @@ export const pageQuery = {
 export const isoDay = z.string().regex(/^\d{4}-\d{2}-\d{2}$/).refine((s) => {
   const n = Date.parse(s); return Number.isFinite(n) && new Date(n).toISOString().slice(0, 10) === s;
 }, 'Use a valid calendar date.');
+// a site-local day ("2026-10-01" = midnight in the site timezone) or an exact
+// ISO 8601 instant with a zone ("2026-10-01T18:00:00Z", "…T13:00:00-05:00")
+export const isoDayOrInstant = z.string().max(40).refine((s) => {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(s)) return isoDay.safeParse(s).success;
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})$/.test(s) && Number.isFinite(Date.parse(s));
+}, 'Use a date (YYYY-MM-DD) or an ISO date-time with a timezone (2026-10-01T18:00:00Z).');
 
 export function methodNotAllowed(allow = 'GET, HEAD, OPTIONS') {
   const res = failure(new ApiError(405, 'Method not allowed.'));

package/src/lib/repo/migrations.ts

@@ -4,6 +4,7 @@ import { EMAIL_MIGRATION } from '../email/migration';
 import { WEBHOOK_MIGRATION } from '../webhook-sql';
 import { PUSH_MIGRATION } from '../push/migration';
 import { EDITOR_MIGRATION, EDITOR_GRACE_MIGRATION } from '../editor/migration';
+import { CALENDAR_SETTINGS_MIGRATION, ROOM_HOLD_MIGRATION } from '../calendar/migration';
 // Versioned schema migrations shared by the two SQLite-dialect adapters
 // (D1 and libSQL). Applied versions are recorded in the `migrations` table;
 // each adapter's runner applies whatever is newer, in order, at startup.
@@ -512,6 +513,8 @@ export const MIGRATIONS: Migration[] = [
   PUSH_MIGRATION,
   EDITOR_MIGRATION,
   EDITOR_GRACE_MIGRATION,
+  CALENDAR_SETTINGS_MIGRATION,
+  ROOM_HOLD_MIGRATION,
 ];
 
 export const LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;

package/src/lib/repo/sql.ts

@@ -144,7 +144,7 @@ function rowToEvent(r: Row): CalEvent {
     start: r.starts, end: r.ends ?? '', allDay: Boolean(r.all_day), timezone: r.timezone ?? '',
     rrule: r.rrule ?? '', exdates: json(r.exdates, []), cancelled: Boolean(r.cancelled),
     location: json(r.location, {}), cta: json(r.cta, {}), calendarIds: json(r.calendar_ids, []),
-    fields: json(r.fields, {}), sourceUid: r.source_uid ?? '', rsvp: json(r.rsvp, {}),
+    fields: json(r.fields, {}), sourceUid: r.source_uid ?? '', rsvp: json(r.rsvp, {}), roomHold: json(r.room_hold, {}),
     startAt: Number(r.start_at), endAt: Number(r.end_at), draft: parseDraft(r.draft), translations: parseTranslations(r.translations),
     publishedAt: r.published_at === null || r.published_at === undefined ? null : Number(r.published_at),
     scheduledAt: r.scheduled_at === null || r.scheduled_at === undefined ? null : Number(r.scheduled_at),
@@ -161,6 +161,14 @@ function rowToResource(r: Row): Resource {
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
 }
+// Callers that still speak the old on/off flag (REST, agent tools, older
+// code) set autoConfirm without an approval mode: map it so "off" really
+// holds bookings. On create, "on" follows the site default (which starts as
+// automatic); on update it pins the link to automatic.
+function legacyApproval<T extends { autoConfirm?: boolean; approval?: BookingLink['approval'] }>(data: T, update = false): T {
+  if (data.approval !== undefined || data.autoConfirm === undefined) return data;
+  return { ...data, approval: data.autoConfirm ? (update ? 'auto' : 'default') : 'manual' };
+}
 function rowToLink2(r: Row): BookingLink {
   return BookingLink.parse({
     id: r.id, resourceId: r.resource_id, slug: r.slug, name: r.name, description: r.description ?? '', mode: r.mode ?? 'slots',
@@ -168,6 +176,7 @@ function rowToLink2(r: Row): BookingLink {
     step: Number(r.step), bufferBefore: Number(r.buffer_before), bufferAfter: Number(r.buffer_after),
     minNotice: Number(r.min_notice), maxAdvance: Number(r.max_advance), perDayCap: Number(r.per_day_cap),
     hours: r.hours ? json(r.hours, null) : null, autoConfirm: Boolean(r.auto_confirm), visibility: r.visibility ?? 'public',
+    approval: r.approval ?? 'default', approvalRules: json(r.approval_rules, {}),
     askPhone: Boolean(r.ask_phone), questions: json(r.questions, []), confirmMessage: r.confirm_message ?? '',
     redirectUrl: r.redirect_url ?? '', active: Boolean(r.active), order: Number(r.ord ?? 0),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
@@ -811,8 +820,8 @@ export class SqlRepository implements ContentRepository {
     await this.driver.run(
       `INSERT INTO events (id, slug, title, body_json, body_html, excerpt, cover, cover_alt, seo_title, seo_desc, status, featured, tags, template,
         starts, ends, all_day, timezone, rrule, exdates, cancelled, location, cta, calendar_ids, fields, source_uid, start_at, end_at,
-        published_at, scheduled_at, created_at, updated_at, rsvp)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        published_at, scheduled_at, created_at, updated_at, rsvp, room_hold)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         id, data.slug, data.title, data.bodyJson ?? '', data.bodyHtml ?? '', data.excerpt ?? '', data.cover ?? '', data.coverAlt ?? '',
         data.seoTitle ?? '', data.seoDesc ?? '', data.status ?? 'draft', data.featured ? 1 : 0, JSON.stringify(data.tags ?? []), data.template ?? '',
@@ -820,7 +829,7 @@ export class SqlRepository implements ContentRepository {
         data.cancelled ? 1 : 0, JSON.stringify(data.location ?? {}), JSON.stringify(data.cta ?? {}), JSON.stringify(data.calendarIds ?? []),
         JSON.stringify(data.fields ?? {}), data.sourceUid ?? '', startAt, endAt,
         data.publishedAt ?? (data.status === 'published' ? now : null), data.scheduledAt ?? null, now, now,
-        JSON.stringify(data.rsvp ?? {}),
+        JSON.stringify(data.rsvp ?? {}), JSON.stringify(data.roomHold ?? {}),
       ]
     );
     await this.syncEventIndex(id);
@@ -845,7 +854,7 @@ export class SqlRepository implements ContentRepository {
       if (v !== undefined) { sets.push(`${col} = ?`); args.push(v); }
     }
     const jsonCols: Record<string, string> = {
-      tags: 'tags', exdates: 'exdates', location: 'location', cta: 'cta', calendarIds: 'calendar_ids', fields: 'fields', rsvp: 'rsvp', translations: 'translations',
+      tags: 'tags', exdates: 'exdates', location: 'location', cta: 'cta', calendarIds: 'calendar_ids', fields: 'fields', rsvp: 'rsvp', translations: 'translations', roomHold: 'room_hold',
     };
     for (const [k, col] of Object.entries(jsonCols)) {
       const v = (data as Record<string, unknown>)[k];
@@ -936,10 +945,11 @@ export class SqlRepository implements ContentRepository {
     return {
       sql: `INSERT INTO booking_links (id, resource_id, slug, name, description, mode, duration, lengths, min_days, max_days, step, buffer_before,
         buffer_after, min_notice, max_advance, per_day_cap, hours, auto_confirm, visibility, ask_phone, questions, confirm_message, redirect_url,
-        active, ord, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        active, ord, created_at, updated_at, approval, approval_rules) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [l.id, l.resourceId, l.slug, l.name, l.description, l.mode, l.duration, JSON.stringify(l.lengths), l.minDays, l.maxDays, l.step,
         l.bufferBefore, l.bufferAfter, l.minNotice, l.maxAdvance, l.perDayCap, l.hours ? JSON.stringify(l.hours) : null, l.autoConfirm ? 1 : 0,
-        l.visibility, l.askPhone ? 1 : 0, JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.createdAt, l.updatedAt],
+        l.visibility, l.askPhone ? 1 : 0, JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.createdAt, l.updatedAt,
+        l.approval, JSON.stringify(l.approvalRules)],
     };
   }
   private bookingInsert(b: Booking): SqlStatement {
@@ -1017,7 +1027,7 @@ export class SqlRepository implements ContentRepository {
     await this.ready;
     const now = Date.now();
     const next = await this.first('SELECT COALESCE(MAX(ord), -1) + 1 AS n FROM booking_links WHERE resource_id = ?', [data.resourceId]);
-    const l = BookingLink.parse({ ...data, id: crypto.randomUUID(), order: Number(next?.n ?? 0), createdAt: now, updatedAt: now });
+    const l = BookingLink.parse({ ...legacyApproval(data), id: crypto.randomUUID(), order: Number(next?.n ?? 0), createdAt: now, updatedAt: now });
     const st = this.linkInsert(l);
     await this.driver.run(st.sql, st.args);
     return l;
@@ -1026,14 +1036,14 @@ export class SqlRepository implements ContentRepository {
     await this.ready;
     const cur = await this.getBookingLink(id);
     if (!cur) return;
-    const l = BookingLink.parse({ ...cur, ...data, id, updatedAt: Date.now() });
+    const l = BookingLink.parse({ ...cur, ...legacyApproval(data, true), id, updatedAt: Date.now() });
     await this.driver.run(
       `UPDATE booking_links SET slug = ?, name = ?, description = ?, mode = ?, duration = ?, lengths = ?, min_days = ?, max_days = ?, step = ?,
         buffer_before = ?, buffer_after = ?, min_notice = ?, max_advance = ?, per_day_cap = ?, hours = ?, auto_confirm = ?, visibility = ?,
-        ask_phone = ?, questions = ?, confirm_message = ?, redirect_url = ?, active = ?, ord = ?, updated_at = ? WHERE id = ?`,
+        ask_phone = ?, questions = ?, confirm_message = ?, redirect_url = ?, active = ?, ord = ?, updated_at = ?, approval = ?, approval_rules = ? WHERE id = ?`,
       [l.slug, l.name, l.description, l.mode, l.duration, JSON.stringify(l.lengths), l.minDays, l.maxDays, l.step, l.bufferBefore, l.bufferAfter,
         l.minNotice, l.maxAdvance, l.perDayCap, l.hours ? JSON.stringify(l.hours) : null, l.autoConfirm ? 1 : 0, l.visibility, l.askPhone ? 1 : 0,
-        JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.updatedAt, id]
+        JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.updatedAt, l.approval, JSON.stringify(l.approvalRules), id]
     );
   }
   async deleteBookingLink(id: string) {
@@ -1048,6 +1058,7 @@ export class SqlRepository implements ContentRepository {
     const args: unknown[] = [];
     if (filter.resourceId) { where.push('resource_id = ?'); args.push(filter.resourceId); }
     if (filter.eventId) { where.push('event_id = ?'); args.push(filter.eventId); }
+    if (filter.email) { where.push('email = ?'); args.push(filter.email.toLowerCase()); }
     if (filter.from !== undefined) { where.push('end_at > ?'); args.push(filter.from); }
     if (filter.to !== undefined) { where.push('start_at < ?'); args.push(filter.to); }
     if (filter.statuses?.length) { where.push(`status IN (${filter.statuses.map(() => '?').join(', ')})`); args.push(...filter.statuses); }
@@ -1614,14 +1625,14 @@ export class SqlRepository implements ContentRepository {
       ...(content.events ?? []).map((e) => ({
         sql: `INSERT INTO events (id, slug, title, body_json, body_html, excerpt, cover, cover_alt, seo_title, seo_desc, status, featured, tags, template,
           starts, ends, all_day, timezone, rrule, exdates, cancelled, location, cta, calendar_ids, fields, source_uid, start_at, end_at,
-          draft, published_at, scheduled_at, created_at, updated_at, rsvp)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          draft, published_at, scheduled_at, created_at, updated_at, rsvp, room_hold)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: [
           e.id, e.slug, e.title, e.bodyJson, e.bodyHtml, e.excerpt, e.cover, e.coverAlt, e.seoTitle, e.seoDesc, e.status, e.featured ? 1 : 0,
           JSON.stringify(e.tags), e.template, e.start, e.end, e.allDay ? 1 : 0, e.timezone, e.rrule, JSON.stringify(e.exdates),
           e.cancelled ? 1 : 0, JSON.stringify(e.location), JSON.stringify(e.cta), JSON.stringify(e.calendarIds), JSON.stringify(e.fields),
           e.sourceUid, e.startAt, e.endAt, e.draft ? JSON.stringify(e.draft) : null, e.publishedAt, e.scheduledAt, e.createdAt, e.updatedAt,
-          JSON.stringify(e.rsvp ?? {}),
+          JSON.stringify(e.rsvp ?? {}), JSON.stringify(e.roomHold ?? {}),
         ],
       })),
       ...(content.resources ?? []).map((r) => this.resourceInsert(r)),
@@ -1836,6 +1847,7 @@ export class SqlRepository implements ContentRepository {
       ai: JSON.parse(String(r?.ai ?? '{}')),
       live: JSON.parse(String(r?.live ?? '{}')),
       push: JSON.parse(String(r?.push ?? '{}')),
+      calendar: JSON.parse(String(r?.calendar ?? '{}')),
       agent: JSON.parse(String(r?.agent ?? '{}')),
       draftsApiKey: r?.drafts_api_key ?? '',
       draftsAllowedOrigins: JSON.parse(String(r?.drafts_allowed_origins ?? '[]')),
@@ -1852,9 +1864,9 @@ export class SqlRepository implements ContentRepository {
       siteTitle:'site_title', tagline:'tagline', footerText:'footer_text', linksName:'links_name', linksBio:'links_bio', linksAvatar:'links_avatar',
       activeTheme:'active_theme', designOverrides:'design_overrides', sectionPages:'section_pages', siteLogo:'site_logo', siteUrl:'site_url', siteFavicon:'site_favicon', siteCover:'site_cover',
       announcement:'announcement', analytics:'analytics', headCode:'head_code', footerCode:'footer_code', timezone:'timezone', locale:'locale',
-      draftsApiKey:'drafts_api_key', draftsAllowedOrigins:'drafts_allowed_origins', draftDesign:'draft_design', ai:'ai', agent:'agent', live:'live', push:'push',
+      draftsApiKey:'drafts_api_key', draftsAllowedOrigins:'drafts_allowed_origins', draftDesign:'draft_design', ai:'ai', agent:'agent', live:'live', push:'push', calendar:'calendar',
     };
-    const jsonKeys = new Set(['designOverrides','sectionPages','announcement','analytics','draftsAllowedOrigins','draftDesign','ai','agent','live','push']);
+    const jsonKeys = new Set(['designOverrides','sectionPages','announcement','analytics','draftsAllowedOrigins','draftDesign','ai','agent','live','push','calendar']);
     const entries = Object.entries(data).filter(([k,v]) => columns[k] && v !== undefined);
     if (!entries.length) return;
     const design = entries.some(([k]) => ['activeTheme','designOverrides','sectionPages','siteLogo','siteFavicon','siteCover','draftDesign'].includes(k));

package/src/lib/repo/types.ts

@@ -39,7 +39,7 @@ export type EventUpdate = Partial<
     | 'title' | 'slug' | 'bodyJson' | 'bodyHtml' | 'excerpt' | 'cover' | 'coverAlt'
     | 'seoTitle' | 'seoDesc' | 'status' | 'featured' | 'tags' | 'template'
     | 'start' | 'end' | 'allDay' | 'timezone' | 'rrule' | 'exdates' | 'cancelled'
-    | 'location' | 'cta' | 'calendarIds' | 'fields' | 'sourceUid' | 'rsvp' | 'translations'
+    | 'location' | 'cta' | 'calendarIds' | 'fields' | 'sourceUid' | 'rsvp' | 'translations' | 'roomHold'
     | 'publishedAt' | 'scheduledAt'
   >
 >;
@@ -152,7 +152,7 @@ export interface ContentRepository {
   // write that can fail on a race: it inserts atomically only if the held
   // range is still free (resource bookings) or seats remain (RSVPs), and
   // returns null when it lost.
-  listBookings(filter?: { resourceId?: string; eventId?: string; from?: number; to?: number; statuses?: BookingStatus[]; kinds?: Booking['kind'][] }): Promise<Booking[]>;
+  listBookings(filter?: { resourceId?: string; eventId?: string; email?: string; from?: number; to?: number; statuses?: BookingStatus[]; kinds?: Booking['kind'][] }): Promise<Booking[]>;
   getBooking(id: string): Promise<Booking | null>;
   getBookingByToken(token: string): Promise<Booking | null>;
   createBooking(

package/src/lib/scheduler.ts

@@ -2,7 +2,7 @@ import { syncDueLive } from './live/service';
 import type { ContentRepository } from './repo/types';
 import { processDueDeliveries } from './webhooks';
 import { dispatchEmail } from './email/service';
-import { sendDueReminders } from './booking/service';
+import { decideOverdue, sendDueReminders } from './booking/service';
 import { runPushJobs } from './push/service';
 
 // All work is awaited on both hosts. Traffic-triggered fallbacks do not mark
@@ -14,6 +14,8 @@ export async function runScheduledTasks(repo: ContentRepository, locals?: unknow
     publish: () => repo.publishDuePosts(startedAt),
     webhooks: () => processDueDeliveries(repo),
     reminders: () => sendDueReminders(repo, { origin: settings.siteUrl, locals, now: startedAt }),
+    // pending bookings past their approval deadline (Calendar settings → Bookings)
+    approvals: () => decideOverdue(repo, { origin: settings.siteUrl, locals, now: startedAt }),
     email: () => dispatchEmail(repo, locals, 10),
     live: () => syncDueLive(repo, locals),
     // queued first-publish notices, starting-soon reminders, receipts, retention

package/src/lib/schema.ts

@@ -314,6 +314,17 @@ export const EventCta = z.object({
 });
 export type EventCta = z.infer<typeof EventCta>;
 
+export const RoomHold = z.object({
+  resourceIds: z.array(z.string()).default([]),
+  span: z.enum(['event', 'day']).default('event'),
+  before: z.number().int().min(0).max(1440).default(0), // setup minutes
+  after: z.number().int().min(0).max(1440).default(0), // cleanup minutes
+  whileDraft: z.boolean().default(false),
+  // bookings you chose to keep (share the room): no longer flagged as conflicts
+  keep: z.array(z.string()).default([]),
+});
+export type RoomHold = z.infer<typeof RoomHold>;
+
 export const CalEvent = z.object({
   id: z.string(),
   slug: z.string(),
@@ -355,6 +366,10 @@ export const CalEvent = z.object({
     autoConfirm: z.boolean().default(true),
     maxSeats: z.number().int().default(4),
   }).default({}),
+  // rooms/people this event uses: they can't be booked while it happens (or
+  // all day). Computed into availability, never stored as bookings. Drafts
+  // only hold when whileDraft is on; cancelled events never hold.
+  roomHold: RoomHold.default({}),
   startAt: z.number(),
   endAt: z.number(),
   translations: DocTranslations,
@@ -444,6 +459,36 @@ export type BookingQuestion = z.infer<typeof BookingQuestion>;
 export const BookingMode = z.enum(['slots', 'range', 'day']);
 export type BookingMode = z.infer<typeof BookingMode>;
 
+// Booking approval: "auto" confirms at once, "manual" holds every booking for
+// a decision, "rules" confirms unless one of the rules flags it. A link can
+// follow the site default ("default") or pick its own. The deadline decides
+// pending bookings nobody answered (0 hours = keep waiting).
+export const ApprovalMode = z.enum(['auto', 'rules', 'manual']);
+export type ApprovalMode = z.infer<typeof ApprovalMode>;
+export const ApprovalRules = z.object({
+  // 0 = rule off
+  longerThan: z.number().int().min(0).default(0), // minutes
+  firstTime: z.boolean().default(false),
+  moreSeats: z.number().int().min(0).default(0),
+  deadlineHours: z.number().int().min(0).max(24 * 60).default(0),
+  deadlineAction: z.enum(['approve', 'decline']).default('approve'),
+});
+export type ApprovalRules = z.infer<typeof ApprovalRules>;
+
+// Site-wide calendar preferences (Calendar settings → Defaults / Bookings)
+export const CalendarSettings = z.object({
+  // first column of every month grid: 0 = Sunday, 1 = Monday
+  weekStart: z.union([z.literal(0), z.literal(1)]).default(0),
+  // calendar new events land in (quick add, New event); '' = none
+  defaultCalendarId: z.string().default(''),
+  // '' = not chosen in the admin yet → acms({ calendar.bookings.approval }) → auto
+  approval: z.union([ApprovalMode, z.literal('')]).default(''),
+  approvalRules: ApprovalRules.default({}),
+  // show bookings on the Schedule grid
+  showBookings: z.boolean().default(true),
+});
+export type CalendarSettings = z.infer<typeof CalendarSettings>;
+
 export const BookingLink = z.object({
   id: z.string(),
   resourceId: z.string(),
@@ -466,6 +511,9 @@ export const BookingLink = z.object({
   hours: WeeklyHours.nullable().default(null),
   // confirmed at once (and on the calendar) vs. held as pending for approval
   autoConfirm: z.boolean().default(true),
+  // supersedes autoConfirm: 'default' follows Calendar settings → Bookings
+  approval: z.union([ApprovalMode, z.literal('default')]).default('default'),
+  approvalRules: ApprovalRules.default({}),
   visibility: z.enum(['public', 'unlisted']).default('public'),
   askPhone: z.boolean().default(false),
   questions: z.array(BookingQuestion).default([]),
@@ -584,6 +632,7 @@ export function normalizeRedirectPath(input: string): string {
 
 export const Settings = z.object({
   live: LiveConfig.default({}),
+  calendar: CalendarSettings.default({}),
   // push notification automation (lib/push); the feature itself is acms({ mobile: { push } })
   push: PushSettings.default({}),
   siteTitle: z.string().default('My Site'),