@acms-subir/core 0.3.3 → 0.3.4

package/src/lib/calendar/board.ts

@@ -0,0 +1,171 @@
+// Data for the admin Schedule: every occurrence in a date range — events
+// (drafts included), subscribed calendars, bookings and blocked time —
+// flattened into site-local days so the browser only does layout
+// (lib/calendar/grid.ts). Times are shown in the site timezone.
+import type { ContentRepository } from '../repo/types';
+import type { CalEvent, Settings } from '../schema';
+import { collectViewEvents } from './data';
+import { eventTimeZone, safeColor } from './events';
+import { tzParts, zonedToUtc } from './ics';
+import { addDays, isIsoDay, type GridItem, type Iso } from './grid';
+import { bookingsEnabled } from './config';
+import { siteLocale } from '../dates';
+import { describeRepeat } from './rrule';
+import { holdsRooms } from '../booking/holds';
+
+export type BoardKind = 'event' | 'feed' | 'booking' | 'block';
+export type BoardStatus = 'published' | 'draft' | 'scheduled' | 'archived' | 'feed' | 'pending' | 'confirmed';
+
+export interface BoardItem extends GridItem {
+  kind: BoardKind;
+  id: string; // event id / booking id / '' for feeds
+  time: string; // short start label, e.g. "7p", "10:30a"
+  range: string; // "7:00 – 8:30 PM" or "All day"
+  color: string;
+  calendarId: string;
+  calendarName: string;
+  status: BoardStatus;
+  recurring: boolean;
+  repeat: string; // "Weekly on Wednesday" ('' when it doesn't repeat)
+  rooms: string[]; // bookable rooms this event holds (names)
+  roomsHeld: boolean; // false for drafts that don't hold yet
+  // this occurrence's start as wall time in the event's own zone (for exdates)
+  occurrence: string;
+  cancelled: boolean;
+  location: string;
+  edited: boolean; // live event with unpublished changes
+  url: string; // public URL ('' when none)
+}
+
+export interface BoardCalendar { id: string; name: string; color: string; kind: 'native' | 'feed'; visibility: string }
+
+export interface BoardData {
+  from: Iso;
+  to: Iso;
+  today: Iso;
+  weekStart: 0 | 1;
+  items: BoardItem[];
+  calendars: BoardCalendar[];
+  errors: string[];
+}
+
+const pad = (n: number) => String(n).padStart(2, '0');
+const isoOf = (p: { y: number; m: number; d: number }) => `${p.y}-${pad(p.m)}-${pad(p.d)}`;
+export const NO_CALENDAR = '';
+export const BOOKING_COLOR = '#8e919a';
+
+function shortTime(hh: number, mm: number): string {
+  const h = hh % 12 || 12;
+  return `${h}${mm ? `:${pad(mm)}` : ''}${hh < 12 ? 'a' : 'p'}`;
+}
+
+export function todayIn(tz: string, now = Date.now()): Iso {
+  return isoOf(tzParts(now, tz || 'UTC'));
+}
+
+// local day + minutes for an instant; `endExclusive` maps midnight to the
+// previous day's 24:00 so an event ending at midnight stays on its day
+function local(ms: number, tz: string, endExclusive = false) {
+  const p = tzParts(endExclusive ? ms - 1 : ms, tz);
+  const day = isoOf(p);
+  const min = endExclusive ? p.hh * 60 + p.mm + 1 : p.hh * 60 + p.mm;
+  return { day, min: Math.min(min, 1440), hh: p.hh, mm: p.mm };
+}
+
+export async function loadBoard(repo: ContentRepository, settings: Settings, from: Iso, to: Iso, opts: { now?: number } = {}): Promise<BoardData> {
+  if (!isIsoDay(from) || !isIsoDay(to) || to < from) throw new Error('Pick a valid date range.');
+  // at most ~14 weeks per request — a month grid needs 6, prefetching adds the neighbours
+  if (addDays(from, 100) < to) throw new Error('That date range is too long.');
+  const tz = settings.timezone || 'UTC';
+  const now = opts.now ?? Date.now();
+  const startMs = zonedToUtc(+from.slice(0, 4), +from.slice(5, 7), +from.slice(8, 10), 0, 0, 0, tz);
+  const endIso = addDays(to, 1);
+  const endMs = zonedToUtc(+endIso.slice(0, 4), +endIso.slice(5, 7), +endIso.slice(8, 10), 0, 0, 0, tz);
+  const win = { displayTz: tz, now, windowStartMs: startMs, windowEndMs: endMs };
+
+  const { events, calendars, errors } = await collectViewEvents(repo, settings, win, { audience: 'admin', includeFeeds: true, includeBookings: false });
+  const locale = siteLocale(settings);
+  const timeFmt = new Intl.DateTimeFormat(locale, { hour: 'numeric', minute: '2-digit', timeZone: tz });
+  const rangeOf = (s: number, e: number, allDay: boolean) => {
+    if (allDay) return 'All day';
+    try { return timeFmt.formatRange(s, e); } catch { return `${timeFmt.format(s)} – ${timeFmt.format(e)}`; }
+  };
+  const calById = new Map(calendars.map((c) => [c.id, c]));
+  const roomName = new Map((bookingsEnabled() ? await repo.listResources() : []).map((r) => [r.id, r.name]));
+  const items: BoardItem[] = [];
+
+  for (const v of events) {
+    const e: CalEvent | undefined = v.event;
+    const allDay = v.allDay;
+    const s = local(v.start, tz);
+    const en = local(v.end, tz, true);
+    const startDay = s.day;
+    const endDay = allDay ? addDays(startDay, Math.max(1, v.days) - 1) : en.day < s.day ? s.day : en.day;
+    const cal = e ? e.calendarIds.map((id) => calById.get(id)).find(Boolean) : calendars.find((c) => c.name === v.calendarName && c.kind === 'feed');
+    let occurrence = '';
+    if (e) {
+      const p = tzParts(v.start, eventTimeZone(e, settings));
+      occurrence = allDay ? isoOf(p) : `${isoOf(p)}T${pad(p.hh)}:${pad(p.mm)}`;
+    }
+    items.push({
+      key: e ? `e:${e.id}:${v.start}` : `f:${cal?.id ?? ''}:${v.start}:${v.title}`,
+      kind: e ? 'event' : 'feed',
+      id: e?.id ?? '',
+      title: v.title,
+      startDay, endDay, allDay,
+      startMin: allDay ? 0 : s.min,
+      endMin: allDay ? 1440 : en.min,
+      time: allDay ? '' : shortTime(s.hh, s.mm),
+      range: rangeOf(v.start, v.end, allDay),
+      color: v.color ?? (cal ? safeColor(cal.color) : '#8a8378'),
+      calendarId: cal?.id ?? NO_CALENDAR,
+      calendarName: cal?.name ?? '',
+      status: e ? (e.status as BoardStatus) : 'feed',
+      recurring: Boolean(e?.rrule),
+      repeat: e?.rrule ? describeRepeat(e.rrule, e.start) : '',
+      rooms: e ? e.roomHold.resourceIds.map((id) => roomName.get(id)).filter((n): n is string => Boolean(n)) : [],
+      roomsHeld: e ? holdsRooms(e) : false,
+      occurrence,
+      cancelled: Boolean(v.cancelled),
+      location: v.location,
+      edited: Boolean(e?.draft),
+      url: e?.status === 'published' ? v.url ?? '' : '',
+    });
+  }
+
+  if (bookingsEnabled() && settings.calendar.showBookings) {
+    const [bookings, resources] = await Promise.all([
+      repo.listBookings({ from: startMs, to: endMs, statuses: ['pending', 'confirmed'], kinds: ['booking', 'block'] }),
+      repo.listResources(),
+    ]);
+    const rById = new Map(resources.map((r) => [r.id, r]));
+    for (const b of bookings) {
+      const r = rById.get(b.resourceId);
+      const s = local(b.start, tz);
+      const en = local(b.end, tz, true);
+      const allDay = s.min === 0 && en.min === 1440;
+      items.push({
+        key: `b:${b.id}`,
+        kind: b.kind === 'block' ? 'block' : 'booking',
+        id: b.id,
+        title: b.kind === 'block' ? `${r?.name ?? 'Blocked'} · ${b.notes || 'Blocked'}` : `${r?.name ?? 'Booking'} · ${b.name}`,
+        startDay: s.day, endDay: en.day < s.day ? s.day : en.day, allDay,
+        startMin: allDay ? 0 : s.min, endMin: allDay ? 1440 : en.min,
+        time: allDay ? '' : shortTime(s.hh, s.mm),
+        range: rangeOf(b.start, b.end, allDay),
+        color: BOOKING_COLOR,
+        calendarId: `res:${b.resourceId}`,
+        calendarName: r?.name ?? '',
+        status: b.status as BoardStatus,
+        recurring: false, repeat: '', rooms: [], roomsHeld: false, occurrence: '', cancelled: false,
+        location: r?.name ?? '', edited: false, url: '',
+      });
+    }
+  }
+
+  items.sort((a, b) => a.startDay.localeCompare(b.startDay) || a.startMin - b.startMin);
+  return {
+    from, to, items, errors, today: todayIn(tz, now), weekStart: settings.calendar.weekStart,
+    calendars: calendars.map((c) => ({ id: c.id, name: c.name, color: safeColor(c.color), kind: c.kind, visibility: c.visibility })),
+  };
+}

package/src/lib/calendar/config.ts

@@ -21,6 +21,8 @@ export interface CalendarConfig {
   eventsBase: string;
   // bookings: rooms, people and equipment at bookBase (off = no /book routes)
   bookings: boolean;
+  // starting approval default for booking links (acms({ calendar: { bookings: { approval } } }))
+  bookingApproval: 'auto' | 'rules' | 'manual';
   bookBase: string;
   resourceKinds: string[];
   defaultView: 'month' | 'week' | 'list';
@@ -32,6 +34,7 @@ const FALLBACK: CalendarConfig = {
   base: '/calendar',
   eventsBase: '/events',
   bookings: true,
+  bookingApproval: 'auto',
   bookBase: '/book',
   resourceKinds: ['Room', 'Person', 'Vehicle', 'Equipment'],
   defaultView: 'month',

package/src/lib/calendar/grid.ts

@@ -0,0 +1,169 @@
+// Pure date + layout math for the admin Schedule (month and week grids).
+// Runs on the server and in the browser, so no repo, no Intl time zones:
+// every date here is a site-local calendar day as "YYYY-MM-DD", and every
+// item already carries its local start/end day (lib/calendar/board.ts).
+
+export type Iso = string;
+
+export interface GridItem {
+  key: string;
+  startDay: Iso;
+  endDay: Iso; // inclusive
+  allDay: boolean;
+  startMin: number; // minutes after midnight on startDay (timed items)
+  endMin: number; // minutes after midnight on endDay
+  title: string;
+}
+
+const pad = (n: number) => String(n).padStart(2, '0');
+const toUtc = (d: Iso) => Date.UTC(+d.slice(0, 4), +d.slice(5, 7) - 1, +d.slice(8, 10));
+const fromUtc = (ms: number): Iso => {
+  const t = new Date(ms);
+  return `${t.getUTCFullYear()}-${pad(t.getUTCMonth() + 1)}-${pad(t.getUTCDate())}`;
+};
+
+export const isIsoDay = (s: string) => /^\d{4}-\d{2}-\d{2}$/.test(s) && fromUtc(toUtc(s)) === s;
+export const addDays = (d: Iso, n: number): Iso => fromUtc(toUtc(d) + n * 86_400_000);
+export const diffDays = (a: Iso, b: Iso) => Math.round((toUtc(b) - toUtc(a)) / 86_400_000);
+// 0 = Sunday … 6 = Saturday
+export const dayOfWeek = (d: Iso) => new Date(toUtc(d)).getUTCDay();
+export const monthOf = (d: Iso) => d.slice(0, 7);
+export const isIsoMonth = (s: string) => /^\d{4}-(0[1-9]|1[0-2])$/.test(s);
+export function addMonths(month: string, n: number): string {
+  const y = +month.slice(0, 4), m = +month.slice(5, 7) - 1 + n;
+  const t = new Date(Date.UTC(y, m, 1));
+  return `${t.getUTCFullYear()}-${pad(t.getUTCMonth() + 1)}`;
+}
+
+export function startOfWeek(d: Iso, weekStart: 0 | 1): Iso {
+  return addDays(d, -((dayOfWeek(d) - weekStart + 7) % 7));
+}
+
+// Weeks covering a month: always whole weeks, 4–6 rows depending on the month
+export function monthWeeks(month: string, weekStart: 0 | 1): Iso[][] {
+  const first = `${month}-01`;
+  const last = addDays(`${addMonths(month, 1)}-01`, -1);
+  const weeks: Iso[][] = [];
+  for (let w = startOfWeek(first, weekStart); w <= last; w = addDays(w, 7)) {
+    weeks.push(Array.from({ length: 7 }, (_, i) => addDays(w, i)));
+  }
+  return weeks;
+}
+
+export function weekDays(day: Iso, weekStart: 0 | 1): Iso[] {
+  const s = startOfWeek(day, weekStart);
+  return Array.from({ length: 7 }, (_, i) => addDays(s, i));
+}
+
+// Items that need a bar across days: all-day items and anything that runs
+// past midnight. Single-day timed items render as chips.
+export const isSpanning = (it: GridItem) => it.allDay || it.endDay > it.startDay;
+
+export interface Bar<T extends GridItem> {
+  item: T;
+  col: number; // 0-based column inside the week
+  span: number; // columns covered
+  lane: number;
+  continuesLeft: boolean;
+  continuesRight: boolean;
+}
+
+export interface WeekLayout<T extends GridItem> {
+  bars: Bar<T>[]; // visible bars; `lane` is the line they sit on
+  chips: { item: T; line: number }[][]; // per column, visible chips and their line
+  hidden: number[]; // per column, items not shown ("+N more")
+  all: T[][]; // per column, everything on that day (for the day panel)
+}
+
+const byStart = <T extends GridItem>(a: T, b: T) =>
+  a.startDay.localeCompare(b.startDay) || Number(b.allDay) - Number(a.allDay) || a.startMin - b.startMin || a.title.localeCompare(b.title);
+
+// Lay out one week row as `lines` stacked slots per day. Bars (all-day and
+// multi-day items) take the same line across every day they cover; timed
+// chips fill each day's free lines. A day with more than fits keeps its last
+// line for "+N more".
+export function layoutWeek<T extends GridItem>(days: Iso[], items: T[], lines: number): WeekLayout<T> {
+  const first = days[0], last = days[days.length - 1];
+  const inWeek = items.filter((it) => it.startDay <= last && it.endDay >= first).sort(byStart);
+  const all: T[][] = days.map((d) => inWeek.filter((it) => it.startDay <= d && it.endDay >= d));
+
+  // greedy lane packing, longest bar first among those starting the same day
+  const clip = (d: Iso) => (d < first ? first : d);
+  const spanning = inWeek.filter(isSpanning).sort((a, b) =>
+    clip(a.startDay).localeCompare(clip(b.startDay)) || diffDays(b.startDay, b.endDay) - diffDays(a.startDay, a.endDay) || byStart(a, b));
+  const laneEnds: number[] = [];
+  const placed: Bar<T>[] = [];
+  for (const item of spanning) {
+    const col = Math.max(0, diffDays(first, item.startDay));
+    const end = Math.min(days.length - 1, diffDays(first, item.endDay));
+    let lane = laneEnds.findIndex((e) => e < col);
+    if (lane === -1) { lane = laneEnds.length; laneEnds.push(end); } else laneEnds[lane] = end;
+    placed.push({ item, col, span: end - col + 1, lane, continuesLeft: item.startDay < first, continuesRight: item.endDay > last });
+  }
+  const covers = (b: Bar<T>, c: number) => b.col <= c && b.col + b.span > c;
+  const timed = days.map((d) => inWeek.filter((it) => !isSpanning(it) && it.startDay === d));
+  const overflow = days.map((_, c) => {
+    const here = placed.filter((b) => covers(b, c));
+    return here.length + timed[c].length > lines || here.some((b) => b.lane >= lines);
+  });
+  const visible = (b: Bar<T>) => {
+    if (b.lane >= lines) return false;
+    if (b.lane < lines - 1) return true;
+    for (let c = b.col; c < b.col + b.span; c++) if (overflow[c]) return false;
+    return true;
+  };
+  // a hidden bar needs a "+N more" line in every day it covers, which can
+  // hide more bars on that line — settle until nothing changes
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const b of placed) {
+      if (visible(b)) continue;
+      for (let c = b.col; c < b.col + b.span; c++) if (!overflow[c]) { overflow[c] = true; changed = true; }
+    }
+  }
+  const bars = placed.filter(visible);
+  const chips: { item: T; line: number }[][] = [];
+  const hidden: number[] = [];
+  for (let c = 0; c < days.length; c++) {
+    const capacity = overflow[c] ? lines - 1 : lines;
+    const taken = new Set(bars.filter((b) => covers(b, c)).map((b) => b.lane));
+    const free: number[] = [];
+    for (let l = 0; l < capacity; l++) if (!taken.has(l)) free.push(l);
+    const shown = timed[c].slice(0, free.length).map((item, i) => ({ item, line: free[i] }));
+    chips.push(shown);
+    const hiddenBars = placed.filter((b) => covers(b, c) && !visible(b)).length;
+    hidden.push(hiddenBars + timed[c].length - shown.length);
+  }
+  return { bars, chips, hidden, all };
+}
+
+// Week view: side-by-side columns for overlapping timed items in one day
+export interface Placed<T extends GridItem> { item: T; top: number; height: number; col: number; cols: number }
+export function layoutDay<T extends GridItem>(day: Iso, items: T[]): Placed<T>[] {
+  const list = items
+    .filter((it) => !isSpanning(it) && it.startDay === day)
+    .sort((a, b) => a.startMin - b.startMin || b.endMin - a.endMin);
+  const out: Placed<T>[] = [];
+  let group: Placed<T>[] = [];
+  let groupEnd = -1;
+  const flush = () => {
+    const cols = group.reduce((n, p) => Math.max(n, p.col + 1), 1);
+    for (const p of group) p.cols = cols;
+    out.push(...group);
+    group = [];
+  };
+  for (const item of list) {
+    const end = Math.max(item.endMin, item.startMin + 20);
+    if (item.startMin >= groupEnd && group.length) flush();
+    const taken = new Set(group.filter((p) => p.top + p.height > item.startMin).map((p) => p.col));
+    let col = 0;
+    while (taken.has(col)) col++;
+    group.push({ item, top: item.startMin, height: end - item.startMin, col, cols: 1 });
+    groupEnd = Math.max(groupEnd, end);
+  }
+  if (group.length) flush();
+  return out;
+}
+
+// Move an item by whole days, keeping its length (drag to reschedule)
+export const shiftDays = (from: Iso, to: Iso) => diffDays(from, to);

package/src/lib/calendar/migration.ts

@@ -0,0 +1,16 @@
+// Schedule + approval settings. Site-wide calendar settings (week start,
+// default calendar, booking approval default) live in one JSON column; each
+// booking link gains an approval mode that can follow that default. Existing
+// links that confirmed automatically now follow the site default (which
+// starts as automatic, so nothing changes); manual ones stay manual.
+export const CALENDAR_SETTINGS_MIGRATION = { version: 40, statements: [
+  `ALTER TABLE settings ADD COLUMN calendar TEXT NOT NULL DEFAULT '{}'`,
+  `ALTER TABLE booking_links ADD COLUMN approval TEXT NOT NULL DEFAULT 'default'`,
+  `ALTER TABLE booking_links ADD COLUMN approval_rules TEXT NOT NULL DEFAULT '{}'`,
+  `UPDATE booking_links SET approval = CASE auto_confirm WHEN 1 THEN 'default' ELSE 'manual' END`,
+] };
+
+// events that reserve bookable rooms/people (CalEvent.roomHold)
+export const ROOM_HOLD_MIGRATION = { version: 41, statements: [
+  `ALTER TABLE events ADD COLUMN room_hold TEXT NOT NULL DEFAULT '{}'`,
+] };

package/src/lib/calendar/render.ts

@@ -105,9 +105,9 @@ const dotStyle = (e: DisplayEvent) => (e.k ? ` style="--cal-dot:${e.k}"` : '');
 const chipHtml = (e: DisplayEvent, i: number) =>
   `<button type="button" class="pc-cal-event${e.x ? ' is-cancelled' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="t">${esc(e.tm)}</span><b>${esc(e.t)}</b></button>`;
 
-function monthGridHtml(y: number, m: number, todayN: number, byDay: Map<number, number[]>, events: DisplayEvent[], dows: string[], monthsShort: string[]): string {
+function monthGridHtml(y: number, m: number, todayN: number, byDay: Map<number, number[]>, events: DisplayEvent[], dows: string[], monthsShort: string[], ws: number): string {
   const first = dayNum(y, m, 1);
-  const start = first - dowOfDay(first);
+  const start = first - ((dowOfDay(first) - ws + 7) % 7);
   let h = dows.map((d) => `<div class="pc-cal-dow">${esc(d)}</div>`).join('');
   for (let i = 0; i < 42; i++) {
     const n = start + i;
@@ -149,7 +149,7 @@ var body=root.querySelector('.pc-cal-body'),titleEl=root.querySelector('.pc-cal-
 var D=864e5;
 function dnum(a){return Math.round(Date.UTC(a[0],a[1]-1,a[2])/D)}
 function fday(n){var d=new Date(n*D);return[d.getUTCFullYear(),d.getUTCMonth()+1,d.getUTCDate()]}
-function dow(n){return((n+4)%7+7)%7}
+function dow(n){return((n+4-(P.ws||0))%7+7)%7}
 var byDay={};P.events.forEach(function(e,i){var n0=dnum(e.d);for(var k=0;k<Math.min(e.n,60);k++){(byDay[n0+k]=byDay[n0+k]||[]).push(i)}});
 function esc(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;')}
 function chip(i){var e=P.events[i];return '<button type="button" class="pc-cal-event'+(e.x?' is-cancelled':'')+'" data-ev="'+i+'" data-cal="'+e.c+'"'+(e.k?' style="--cal-dot:'+e.k+'"':'')+'><span class="t">'+esc(e.tm)+'</span><b>'+esc(e.t)+'</b></button>'}
@@ -246,7 +246,9 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     new Intl.DateTimeFormat(locale, { ...o, timeZone: 'UTC' }).format(ms);
   const months = Array.from({ length: 12 }, (_, i) => utcLabel({ month: 'long' }, Date.UTC(2026, i, 1)));
   const monthsShort = Array.from({ length: 12 }, (_, i) => utcLabel({ month: 'short' }, Date.UTC(2026, i, 1)));
-  const dows = Array.from({ length: 7 }, (_, i) => utcLabel({ weekday: 'short' }, Date.UTC(2026, 7, 2 + i))); // Aug 2 2026 = Sunday
+  // Calendar settings → Defaults → "Weeks start on" (0 Sunday, 1 Monday)
+  const ws = settings.calendar?.weekStart ?? 0;
+  const dows = Array.from({ length: 7 }, (_, i) => utcLabel({ weekday: 'short' }, Date.UTC(2026, 7, 2 + ws + i))); // Aug 2 2026 = Sunday
 
   const focusOk = opts.focus && (opts.focus.y * 12 + opts.focus.m) >= minY * 12 + minM && (opts.focus.y * 12 + opts.focus.m) <= maxY * 12 + maxM;
   const [fy, fm] = focusOk ? [opts.focus!.y, opts.focus!.m] : [today.y, today.m];
@@ -254,7 +256,7 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
   let bodyHtml: string;
   let titleText: string;
   if (opts.view === 'week') {
-    const weekStart = todayN - dowOfDay(todayN);
+    const weekStart = todayN - ((dowOfDay(todayN) - ws + 7) % 7);
     const wa = fromDayNum(weekStart);
     const wb = fromDayNum(weekStart + 6);
     titleText = `${monthsShort[wa.m - 1]} ${wa.d} – ${wa.m === wb.m ? '' : `${monthsShort[wb.m - 1]} `}${wb.d}, ${wb.y}`;
@@ -267,7 +269,7 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     if (!order.length && opts.emptyText) bodyHtml = `<p class="pc-cal-empty">${esc(opts.emptyText)}</p>`;
   } else {
     titleText = `${months[fm - 1]} ${fy}`;
-    bodyHtml = monthGridHtml(fy, fm, todayN, byDay, events, dows, monthsShort);
+    bodyHtml = monthGridHtml(fy, fm, todayN, byDay, events, dows, monthsShort, ws);
   }
 
   const navButtons =
@@ -287,7 +289,7 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     month: [fy, fm],
     min: [minY, minM],
     max: [maxY, maxM],
-    months, monthsShort, dows, events,
+    months, monthsShort, dows, events, ws,
     details: 'Details', cancelled: 'Cancelled',
   };
   const json = JSON.stringify(payload).replace(/</g, '\\u003c');

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];