@acms-subir/core 0.2.0 → 0.3.1

package/src/lib/booking/agent.ts

@@ -0,0 +1,108 @@
+// Agent / MCP tools for bookings. Reads are always available to the agent
+// key; anything that emails a guest or changes a booking needs the owner's
+// "agent publishing" permission, like publishing content.
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import type { Booking } from '../schema';
+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';
+
+export const BookingToolInputs = [
+  z.object({ tool: z.literal('list_resources'), arguments: z.object({}).strict() }).strict(),
+  z.object({ tool: z.literal('check_availability'), arguments: z.object({
+    resource: z.string().min(1), link: z.string().min(1),
+    from: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(), days: z.number().int().min(1).max(31).default(7),
+    minutes: z.number().int().optional(),
+  }).strict() }).strict(),
+  z.object({ tool: z.literal('list_bookings'), arguments: z.object({
+    status: z.enum(['pending', 'confirmed', 'declined', 'cancelled']).optional(), resource: z.string().optional(),
+    from: z.string().optional(), limit: z.number().int().min(1).max(100).default(25),
+  }).strict() }).strict(),
+  z.object({ tool: z.literal('create_booking'), arguments: z.object({
+    resource: z.string().min(1), link: z.string().min(1), start: z.string().min(1), minutes: z.number().int().optional(),
+    name: z.string().min(1).max(120), email: z.string().email(), phone: z.string().max(40).optional(),
+    answers: z.record(z.string()).optional(),
+  }).strict() }).strict(),
+  z.object({ tool: z.literal('update_booking'), arguments: z.object({
+    id: z.string().min(1), status: z.enum(['confirmed', 'declined', 'cancelled']).optional(),
+    start: z.string().optional(), notes: z.string().max(4000).optional(), message: z.string().max(1000).optional(),
+  }).strict() }).strict(),
+] as const;
+
+export const BOOKING_TOOL_NAMES = ['list_resources', 'check_availability', 'list_bookings', 'create_booking', 'update_booking'] as const;
+export const BOOKING_WRITE_TOOLS = ['create_booking', 'update_booking'];
+export const BOOKING_TOOL_DESCRIPTIONS: Record<(typeof BOOKING_TOOL_NAMES)[number], string> = {
+  list_resources: 'List bookable resources (rooms, people, equipment) and their booking links with rules (length, auto-confirm, visibility).',
+  check_availability: 'Open start times for a resource + link (slugs) over the next days. Returns ISO start/end per slot.',
+  list_bookings: 'List bookings (guest name, email, answers, status). Filter by status (pending = waiting for approval) or resource slug.',
+  create_booking: 'Book a slot for a guest (checks availability; confirms or holds for approval per the link; emails the guest). Needs publishing permission.',
+  update_booking: 'Confirm, decline or cancel a booking, move it (start), or set private notes. Emails the guest. Needs publishing permission.',
+};
+
+type Input = z.infer<(typeof BookingToolInputs)[number]>;
+const ms = (s: string) => {
+  const n = Date.parse(s);
+  if (!Number.isFinite(n)) throw new ApiError(400, `"${s}" isn't an ISO date-time.`);
+  return n;
+};
+
+export async function runBookingTool(repo: ContentRepository, input: Input, allowWrite: boolean, ctx: { origin: string; waitUntil?: (p: Promise<unknown>) => void }) {
+  if (!bookingsEnabled()) throw new ApiError(404, 'Bookings are disabled on this site.');
+  if (BOOKING_WRITE_TOOLS.includes(input.tool) && !allowWrite) throw new ApiError(403, 'Agent publishing is disabled. An owner can enable it in Settings.');
+  const settings = await repo.getSettings();
+  const resources = await repo.listResources();
+  const links = await repo.listBookingLinks();
+  const resolve = (resource: string, link: string) => {
+    const r = resources.find((x) => x.slug === resource || x.id === resource);
+    const l = r ? links.find((x) => x.resourceId === r.id && (x.slug === link || x.id === link)) : undefined;
+    if (!r || !l) throw new ApiError(404, 'Unknown resource or link. Call list_resources.');
+    return { r, l };
+  };
+  const flow = { origin: ctx.origin, waitUntil: ctx.waitUntil };
+  const out = (b: Booking) => bookingJson(b, { resourceSlug: resources.find((r) => r.id === b.resourceId)?.slug, linkSlug: links.find((l) => l.id === b.linkId)?.slug });
+  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 })) })) };
+      case 'check_availability': {
+        const { r, l } = resolve(input.arguments.resource, input.arguments.link);
+        const c = await availabilityContext(repo, r, l, settings);
+        const tz = r.timezone || settings.timezone || 'UTC';
+        const from = input.arguments.from ?? ymd(Date.now(), tz);
+        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 };
+      }
+      case 'list_bookings': {
+        const a = input.arguments;
+        const r = a.resource ? resources.find((x) => x.slug === a.resource) : undefined;
+        if (a.resource && !r) throw new ApiError(404, 'Unknown resource.');
+        const list = await repo.listBookings({ resourceId: r?.id, from: a.from ? ms(a.from) : Date.now() - 86_400_000, statuses: a.status ? [a.status] : undefined });
+        return { total: list.length, items: list.slice(0, a.limit).map(out) };
+      }
+      case 'create_booking': {
+        const a = input.arguments;
+        const { r, l } = resolve(a.resource, a.link);
+        const start = ms(a.start);
+        const minutes = a.minutes ?? (l.mode === 'day' ? 1440 : l.mode === 'range' ? l.lengths[0] ?? l.duration : l.duration);
+        const b = await createResourceBooking(repo, { resource: r, link: l, start, end: start + minutes * 60_000, source: 'agent', booker: { name: a.name, email: a.email, phone: a.phone, answers: a.answers } }, flow);
+        return out(b);
+      }
+      case 'update_booking': {
+        const a = input.arguments;
+        let b = await repo.getBooking(a.id);
+        if (!b) throw new ApiError(404, 'Booking not found.');
+        if (a.notes !== undefined) await repo.updateBooking(b.id, { notes: a.notes });
+        if (a.start) b = await rescheduleBooking(repo, b, ms(a.start), ms(a.start) + (b.end - b.start), { ...flow, skipRules: false });
+        if (a.status) b = await setBookingStatus(repo, b, a.status, flow, a.message);
+        return out((await repo.getBooking(b.id))!);
+      }
+    }
+  } catch (err) {
+    if (err instanceof BookingError) throw new ApiError(err.status, err.message);
+    throw err;
+  }
+}

package/src/lib/booking/availability.ts

@@ -0,0 +1,221 @@
+// The availability engine: what can be booked, and when. Pure — callers pass
+// in the resource, the link, the bookings that hold time and any busy
+// intervals from external calendars.
+//
+//   resource hours (or a date override)  ∩  link hours  →  open windows
+//   open windows − holds (bookings ± buffers) − busy feeds − notice/advance
+//   → start times of the link's length (slots / range) or whole days (day)
+//
+// All wall-clock math happens in the resource's zone, so "9am–5pm" stays
+// 9–5 across DST.
+import type { Booking, BookingLink, Resource, TimeRange, Weekday } from '../schema';
+import { WEEKDAYS } from '../schema';
+import { tzParts, zonedToUtc } from '../calendar/ics';
+import { isValidTimeZone } from '../calendar/events';
+
+const DAY = 86_400_000;
+const MIN = 60_000;
+
+export interface Interval { start: number; end: number }
+export interface Slot { start: number; end: number; minutes: number }
+
+export interface AvailabilityContext {
+  resource: Resource;
+  link: BookingLink;
+  // pending + confirmed holds on this resource (any link) — other links'
+  // buffers already live in each booking's holdStart/holdEnd
+  bookings: Pick<Booking, 'holdStart' | 'holdEnd' | 'start' | 'linkId' | 'status' | 'kind' | 'id'>[];
+  busy: Interval[];
+  siteTimezone: string;
+  now: number;
+  // reschedule: ignore this booking's own hold
+  ignoreBookingId?: string;
+}
+
+const pad = (n: number) => String(n).padStart(2, '0');
+export const resourceZone = (r: Pick<Resource, 'timezone'>, siteTz: string) =>
+  isValidTimeZone(r.timezone) ? r.timezone : isValidTimeZone(siteTz) ? siteTz : 'UTC';
+
+const minutesOf = (hhmm: string) => {
+  const [h, m] = hhmm.split(':').map(Number);
+  return h * 60 + m;
+};
+
+export function ymd(ms: number, tz: string): string {
+  const p = tzParts(ms, tz);
+  return `${p.y}-${pad(p.m)}-${pad(p.d)}`;
+}
+export function addDaysYmd(date: string, n: number): string {
+  const [y, m, d] = date.split('-').map(Number);
+  const t = new Date(Date.UTC(y, m - 1, d + n));
+  return `${t.getUTCFullYear()}-${pad(t.getUTCMonth() + 1)}-${pad(t.getUTCDate())}`;
+}
+const weekdayOf = (date: string): Weekday => {
+  const [y, m, d] = date.split('-').map(Number);
+  return WEEKDAYS[new Date(Date.UTC(y, m - 1, d)).getUTCDay()];
+};
+export const localMidnight = (date: string, tz: string) => {
+  const [y, m, d] = date.split('-').map(Number);
+  return zonedToUtc(y, m, d, 0, 0, 0, tz);
+};
+
+// minute ranges for one local date: override wins over weekly hours; a link
+// with its own hours can only narrow them
+export function dayRanges(resource: Resource, link: BookingLink | null, date: string): [number, number][] {
+  const ov = resource.overrides.find((o) => date >= o.date && date <= (o.endDate || o.date));
+  const base = (ov ? ov.ranges : resource.hours[weekdayOf(date)]) ?? [];
+  let ranges = normalize(base);
+  if (link?.hours) ranges = intersect(ranges, normalize(link.hours[weekdayOf(date)] ?? []));
+  return ranges;
+}
+
+function normalize(list: TimeRange[]): [number, number][] {
+  const r = list
+    .map((t) => [minutesOf(t.start), t.end === '00:00' ? 1440 : minutesOf(t.end)] as [number, number])
+    .filter(([a, b]) => b > a)
+    .sort((a, b) => a[0] - b[0]);
+  const out: [number, number][] = [];
+  for (const cur of r) {
+    const last = out[out.length - 1];
+    if (last && cur[0] <= last[1]) last[1] = Math.max(last[1], cur[1]);
+    else out.push([...cur]);
+  }
+  return out;
+}
+
+function intersect(a: [number, number][], b: [number, number][]): [number, number][] {
+  const out: [number, number][] = [];
+  for (const [s1, e1] of a) for (const [s2, e2] of b) {
+    const s = Math.max(s1, s2), e = Math.min(e1, e2);
+    if (e > s) out.push([s, e]);
+  }
+  return out;
+}
+
+const overlaps = (a0: number, a1: number, b0: number, b1: number) => a0 < b1 && a1 > b0;
+
+function blocked(ctx: AvailabilityContext, start: number, end: number): boolean {
+  const hs = start - ctx.link.bufferBefore * MIN;
+  const he = end + ctx.link.bufferAfter * MIN;
+  for (const b of ctx.bookings) {
+    if (b.id === ctx.ignoreBookingId) continue;
+    if (b.status !== 'pending' && b.status !== 'confirmed') continue;
+    if (b.kind === 'rsvp') continue;
+    if (overlaps(hs, he, b.holdStart, b.holdEnd)) return true;
+  }
+  for (const i of ctx.busy) if (overlaps(start, end, i.start, i.end)) return true;
+  return false;
+}
+
+function capReached(ctx: AvailabilityContext, date: string, tz: string): boolean {
+  if (!ctx.link.perDayCap) return false;
+  const n = ctx.bookings.filter(
+    (b) => b.linkId === ctx.link.id && b.id !== ctx.ignoreBookingId && (b.status === 'pending' || b.status === 'confirmed') && ymd(b.start, tz) === date
+  ).length;
+  return n >= ctx.link.perDayCap;
+}
+
+export function linkLengths(link: BookingLink): number[] {
+  if (link.mode === 'range') {
+    const l = [...new Set(link.lengths.filter((n) => n >= 5 && n <= 24 * 60))].sort((a, b) => a - b);
+    return l.length ? l : [link.duration];
+  }
+  return [Math.max(5, link.duration)];
+}
+
+// the open start times on one local date (all lengths unless `minutes` given)
+export function slotsForDay(ctx: AvailabilityContext, date: string, minutes?: number): Slot[] {
+  const tz = resourceZone(ctx.resource, ctx.siteTimezone);
+  const earliest = ctx.now + ctx.link.minNotice * MIN;
+  const latest = ctx.now + ctx.link.maxAdvance * DAY;
+  if (capReached(ctx, date, tz)) return [];
+  const midnight = localMidnight(date, tz);
+  if (ctx.link.mode === 'day') {
+    const out: Slot[] = [];
+    for (let n = Math.max(1, ctx.link.minDays); n <= Math.max(ctx.link.minDays, ctx.link.maxDays); n++) {
+      if (minutes && minutes !== n * 1440) continue;
+      // every day in the span must be open at all; the whole span must be free
+      let open = true;
+      for (let k = 0; k < n; k++) if (!dayRanges(ctx.resource, ctx.link, addDaysYmd(date, k)).length) open = false;
+      const start = midnight;
+      const end = localMidnight(addDaysYmd(date, n), tz);
+      // a day that has already begun (or falls inside the notice window) is out
+      if (!open || start < earliest || start > latest) continue;
+      if (blocked(ctx, start, end)) continue;
+      out.push({ start, end, minutes: n * 1440 });
+    }
+    return out;
+  }
+  const step = Math.max(5, ctx.link.step) * MIN;
+  const lengths = minutes ? [minutes] : linkLengths(ctx.link);
+  const out: Slot[] = [];
+  const [y, m, d] = date.split('-').map(Number);
+  for (const [a, b] of dayRanges(ctx.resource, ctx.link, date)) {
+    // wall-clock → UTC per boundary, so a window spanning a DST change is right
+    const wStart = zonedToUtc(y, m, d, Math.floor(a / 60), a % 60, 0, tz);
+    const wEnd = b >= 1440 ? localMidnight(addDaysYmd(date, 1), tz) : zonedToUtc(y, m, d, Math.floor(b / 60), b % 60, 0, tz);
+    for (const len of lengths) {
+      for (let s = wStart; s + len * MIN <= wEnd; s += step) {
+        if (s < earliest || s > latest) continue;
+        const e = s + len * MIN;
+        if (blocked(ctx, s, e)) continue;
+        out.push({ start: s, end: e, minutes: len });
+      }
+    }
+  }
+  return out.sort((p, q) => p.start - q.start || p.minutes - q.minutes);
+}
+
+// dates (in the resource zone) with at least one opening
+export function openDays(ctx: AvailabilityContext, fromDate: string, days: number, minutes?: number): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < days; i++) {
+    const date = addDaysYmd(fromDate, i);
+    if (slotsForDay(ctx, date, minutes).length) out.push(date);
+  }
+  return out;
+}
+
+export function nextOpenings(ctx: AvailabilityContext, count: number, horizonDays = 60): Slot[] {
+  const tz = resourceZone(ctx.resource, ctx.siteTimezone);
+  const out: Slot[] = [];
+  const seenDays = new Set<string>();
+  let date = ymd(ctx.now, tz);
+  for (let i = 0; i < Math.min(horizonDays, ctx.link.maxAdvance + 1) && out.length < count; i++, date = addDaysYmd(date, 1)) {
+    const slots = slotsForDay(ctx, date);
+    // range/day links: one chip per day reads better than 5 starts on day one
+    const pick = ctx.link.mode === 'slots' ? slots : slots.slice(0, 1);
+    for (const s of pick) {
+      if (ctx.link.mode !== 'slots' && seenDays.has(date)) continue;
+      seenDays.add(date);
+      out.push(s);
+      if (out.length >= count) break;
+    }
+  }
+  return out;
+}
+
+// server-side check before an insert (the DB guard backs it up for races)
+export function isBookable(ctx: AvailabilityContext, start: number, end: number): boolean {
+  const tz = resourceZone(ctx.resource, ctx.siteTimezone);
+  const minutes = Math.round((end - start) / MIN);
+  return slotsForDay(ctx, ymd(start, tz), minutes).some((s) => s.start === start && s.end === end);
+}
+
+export const holdOf = (link: Pick<BookingLink, 'bufferBefore' | 'bufferAfter'>, start: number, end: number) => ({
+  holdStart: start - link.bufferBefore * MIN,
+  holdEnd: end + link.bufferAfter * MIN,
+});
+
+export function describeLength(minutes: number): string {
+  if (minutes % 1440 === 0) return `${minutes / 1440} day${minutes === 1440 ? '' : 's'}`;
+  if (minutes < 60) return `${minutes} min`;
+  const h = Math.floor(minutes / 60), m = minutes % 60;
+  return m ? `${h} h ${m} min` : `${h} h`;
+}
+
+export function describeLink(link: BookingLink): string {
+  if (link.mode === 'day') return link.minDays === link.maxDays ? describeLength(link.minDays * 1440) : `${link.minDays}–${link.maxDays} days`;
+  const l = linkLengths(link);
+  return l.length === 1 ? describeLength(l[0]) : `${describeLength(l[0])} – ${describeLength(l[l.length - 1])}`;
+}

package/src/lib/booking/emails.ts

@@ -0,0 +1,115 @@
+// Booking emails: plain, readable HTML (inline styles, no images) plus a
+// text part. Confirmed bookings carry an .ics so one tap adds them to the
+// booker's calendar.
+import type { Booking, BookingLink, Resource, Settings } from '../schema';
+import { siteLocale } from '../dates';
+import { escapeText, foldLine } from '../calendar/ics-write';
+import type { Mail } from '../email';
+
+const esc = (s: string) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+
+export function whenText(b: Pick<Booking, 'start' | 'end'>, tz: string, settings: Settings, allDayish = false): string {
+  const locale = siteLocale(settings);
+  const f = (o: Intl.DateTimeFormatOptions) => new Intl.DateTimeFormat(locale, { ...o, timeZone: tz });
+  if (allDayish) {
+    const last = b.end - 1;
+    const d = f({ weekday: 'short', month: 'short', day: 'numeric' });
+    return d.format(b.start) === d.format(last) ? `${f({ weekday: 'long', month: 'long', day: 'numeric' }).format(b.start)} · all day` : `${d.format(b.start)} – ${d.format(last)}`;
+  }
+  const zone = f({ hour: 'numeric', timeZoneName: 'short' }).formatToParts(b.start).find((p) => p.type === 'timeZoneName')?.value ?? '';
+  return `${f({ weekday: 'long', month: 'long', day: 'numeric' }).format(b.start)} · ${f({ hour: 'numeric', minute: '2-digit' }).format(b.start)} – ${f({ hour: 'numeric', minute: '2-digit' }).format(b.end)} ${zone}`.trim();
+}
+
+const utc = (ms: number) => new Date(ms).toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
+
+export function bookingIcs(b: Booking, title: string, location: string, url: string, host: string, method: 'REQUEST' | 'CANCEL' = 'REQUEST', options: { organizer?: string; allDay?: boolean } = {}): string {
+  const day = (ms: number) => new Intl.DateTimeFormat('en-CA', { timeZone: b.timezone || 'UTC', year: 'numeric', month: '2-digit', day: '2-digit' }).format(ms).replaceAll('-', '');
+  const actualMethod = method === 'CANCEL' ? 'CANCEL' : options.organizer ? 'REQUEST' : 'PUBLISH';
+  const lines = [
+    'BEGIN:VCALENDAR', 'VERSION:2.0', 'PRODID:-//acms-subir//Bookings//EN', `METHOD:${actualMethod}`,
+    'BEGIN:VEVENT', `UID:booking-${b.id}@acms.invalid`, `DTSTAMP:${utc(Date.now())}`, ...(options.allDay ? [`DTSTART;VALUE=DATE:${day(b.start)}`, `DTEND;VALUE=DATE:${day(b.end)}`] : [`DTSTART:${utc(b.start)}`, `DTEND:${utc(b.end)}`]),
+    ...(options.organizer ? [`ORGANIZER:mailto:${options.organizer}`, `ATTENDEE;RSVP=FALSE:mailto:${b.email}`] : []),
+    `SUMMARY:${escapeText(title)}`, ...(location ? [`LOCATION:${escapeText(location)}`] : []), `DESCRIPTION:${escapeText(`Manage: ${url}`)}`,
+    `URL:${url}`, `STATUS:${method === 'CANCEL' ? 'CANCELLED' : 'CONFIRMED'}`, `SEQUENCE:${b.notificationVersion ?? 0}`,
+    'END:VEVENT', 'END:VCALENDAR',
+  ];
+  return lines.map(foldLine).join('\r\n') + '\r\n';
+}
+
+interface Ctx {
+  booking: Booking;
+  resource: Resource | null;
+  link: BookingLink | null;
+  title: string; // "Fellowship Hall · Event or reception" / event title
+  location: string;
+  when: string;
+  manageUrl: string;
+  siteTitle: string;
+  host: string;
+  message?: string;
+  organizer?: string;
+  allDay?: boolean;
+}
+
+function layout(heading: string, intro: string, c: Ctx, button?: { href: string; label: string }): { html: string; text: string } {
+  const rows: [string, string][] = [['What', c.title], ['When', c.when], ...(c.location ? [['Where', c.location] as [string, string]] : [])];
+  if (c.booking.seats > 1) rows.push(['Seats', String(c.booking.seats)]);
+  const html = `<!doctype html><html><body style="margin:0;background:#f6f5f2;font-family:-apple-system,Segoe UI,Inter,Arial,sans-serif;color:#1e1f24">
+<div style="max-width:520px;margin:0 auto;padding:28px 20px">
+<p style="font-size:13px;color:#6b6e78;margin:0 0 18px">${esc(c.siteTitle)}</p>
+<h1 style="font-size:22px;margin:0 0 8px">${esc(heading)}</h1>
+<p style="font-size:15px;line-height:1.55;margin:0 0 18px;color:#3d3f47">${esc(intro)}</p>
+<table style="width:100%;border-collapse:collapse;background:#fff;border:1px solid #e5e3de;border-radius:10px">${rows
+    .map(([k, v]) => `<tr><td style="padding:10px 14px;font-size:13px;color:#6b6e78;width:70px;border-bottom:1px solid #eeece8">${k}</td><td style="padding:10px 14px;font-size:14px;border-bottom:1px solid #eeece8">${esc(v)}</td></tr>`)
+    .join('')}</table>
+${c.message ? `<p style="font-size:14px;line-height:1.55;margin:18px 0 0">${esc(c.message)}</p>` : ''}
+${button ? `<p style="margin:22px 0 0"><a href="${esc(button.href)}" style="display:inline-block;background:#1e1f24;color:#fff;text-decoration:none;font-weight:600;font-size:14px;padding:10px 16px;border-radius:8px">${esc(button.label)}</a></p>` : ''}
+<p style="font-size:12px;color:#8e919a;margin:26px 0 0">Reference ${esc(c.booking.id.slice(0, 8).toUpperCase())}</p>
+</div></body></html>`;
+  const text = [heading, '', intro, '', ...rows.map(([k, v]) => `${k}: ${v}`), ...(c.message ? ['', c.message] : []), ...(button ? ['', `${button.label}: ${button.href}`] : []), '', `Reference ${c.booking.id.slice(0, 8).toUpperCase()}`].join('\n');
+  return { html, text };
+}
+
+export type BookingEmail = 'received' | 'confirmed' | 'declined' | 'cancelled' | 'rescheduled' | 'updated' | 'reminder' | 'staff-new';
+
+export function bookingEmail(kind: BookingEmail, c: Ctx): Mail {
+  const manage = { href: c.manageUrl, label: 'View or change your booking' };
+  const ics = (method: 'REQUEST' | 'CANCEL' = 'REQUEST') => [{ filename: 'booking.ics', type: `text/calendar; charset=utf-8; method=${method === 'CANCEL' ? 'CANCEL' : c.organizer ? 'REQUEST' : 'PUBLISH'}`, content: bookingIcs(c.booking, c.title, c.location, c.manageUrl, c.host, method, { organizer: c.organizer, allDay: c.allDay }) }];
+  switch (kind) {
+    case 'received': {
+      const m = layout('Request received', `Thanks, ${c.booking.name || 'there'}. We'll confirm by email soon.`, c, manage);
+      return { to: c.booking.email, subject: `Request received: ${c.title}`, ...m };
+    }
+    case 'confirmed': {
+      const m = layout('You’re booked', `It’s confirmed. Import the attached file to add it to your calendar.`, { ...c, message: c.message || c.link?.confirmMessage || '' }, manage);
+      return { to: c.booking.email, subject: `Confirmed: ${c.title} — ${c.when}`, ...m, attachments: ics() };
+    }
+    case 'declined': {
+      const m = layout('We couldn’t confirm your request', 'Sorry — this time isn’t available. You’re welcome to pick another.', c);
+      return { to: c.booking.email, subject: `Not available: ${c.title}`, ...m };
+    }
+    case 'cancelled': {
+      const m = layout('Booking cancelled', 'This booking has been cancelled.', c);
+      return { to: c.booking.email, subject: `Cancelled: ${c.title}`, ...m, attachments: ics('CANCEL') };
+    }
+    case 'updated': {
+      const m = layout('Booking details updated', 'Please review the latest details. Use the attached calendar file to update your calendar.', c, manage);
+      return { to: c.booking.email, subject: `Updated: ${c.title}`, ...m, attachments: ics() };
+    }
+    case 'rescheduled': {
+      const m = layout('Booking moved', 'Your booking has a new time. Import the attached calendar file to update your calendar.', c, manage);
+      return { to: c.booking.email, subject: `New time: ${c.title} — ${c.when}`, ...m, attachments: ics() };
+    }
+    case 'reminder': {
+      const m = layout('Coming up soon', 'A quick reminder about your booking.', c, manage);
+      return { to: c.booking.email, subject: `Reminder: ${c.title} — ${c.when}`, ...m };
+    }
+    case 'staff-new': {
+      const pending = c.booking.status === 'pending';
+      const who = [c.booking.name, c.booking.email, c.booking.phone].filter(Boolean).join(' · ');
+      const answers = Object.entries(c.booking.answers).map(([k, v]) => `${k}: ${v}`).join('\n');
+      const m = layout(pending ? 'New request to approve' : 'New booking', `${who}${answers ? `\n${answers}` : ''}`, c, { href: c.manageUrl, label: pending ? 'Review in the admin' : 'Open in the admin' });
+      return { to: [], subject: `${pending ? 'Approve' : 'New booking'}: ${c.title} — ${c.when}`, ...m, replyTo: c.booking.email || undefined };
+    }
+  }
+}

package/src/lib/booking/forms.ts

@@ -0,0 +1,77 @@
+// Form ⇄ data helpers for the admin booking screens (plain HTML forms, no
+// island): weekly hours rows, date overrides, questions, comma lists.
+import { WEEKDAYS, type BookingQuestion, type DateOverride, type TimeRange, type WeeklyHours } from '../schema';
+import { QUESTION_TYPES } from '../schema';
+
+export const DAY_LABELS: Record<(typeof WEEKDAYS)[number], string> = { su: 'Sun', mo: 'Mon', tu: 'Tue', we: 'Wed', th: 'Thu', fr: 'Fri', sa: 'Sat' };
+// Monday-first reads naturally in an hours editor
+export const DAY_ORDER = ['mo', 'tu', 'we', 'th', 'fr', 'sa', 'su'] as const;
+
+const hhmm = (v: FormDataEntryValue | null) => {
+  const s = String(v ?? '').trim();
+  return /^\d{2}:\d{2}$/.test(s) ? s : '';
+};
+
+// hours_<day>_on, hours_<day>_s1/e1, hours_<day>_s2/e2 (second range optional)
+export function hoursFromForm(form: FormData, prefix = 'hours'): WeeklyHours {
+  const out = {} as WeeklyHours;
+  for (const d of WEEKDAYS) {
+    const ranges: TimeRange[] = [];
+    if (form.get(`${prefix}_${d}_on`)) {
+      for (const n of [1, 2]) {
+        const start = hhmm(form.get(`${prefix}_${d}_s${n}`));
+        const end = hhmm(form.get(`${prefix}_${d}_e${n}`));
+        if (start && end && (end > start || end === '00:00')) ranges.push({ start, end });
+      }
+    }
+    out[d] = ranges;
+  }
+  return out;
+}
+
+export function overridesFromForm(form: FormData): DateOverride[] {
+  const out: DateOverride[] = [];
+  for (let i = 0; i < 60; i++) {
+    const date = String(form.get(`ov_${i}_date`) ?? '');
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
+    const endDate = String(form.get(`ov_${i}_end`) ?? '');
+    const closed = Boolean(form.get(`ov_${i}_closed`));
+    const s = hhmm(form.get(`ov_${i}_s`));
+    const e = hhmm(form.get(`ov_${i}_e`));
+    out.push({
+      date,
+      endDate: /^\d{4}-\d{2}-\d{2}$/.test(endDate) && endDate > date ? endDate : '',
+      ranges: closed || !s || !e ? [] : [{ start: s, end: e }],
+      label: String(form.get(`ov_${i}_label`) ?? '').slice(0, 80),
+    });
+  }
+  return out.sort((a, b) => a.date.localeCompare(b.date));
+}
+
+export function questionsFromForm(form: FormData): BookingQuestion[] {
+  const out: BookingQuestion[] = [];
+  for (let i = 0; i < 30; i++) {
+    const label = String(form.get(`qq_${i}_label`) ?? '').trim().slice(0, 200);
+    if (!label) continue;
+    const type = (QUESTION_TYPES as readonly string[]).includes(String(form.get(`qq_${i}_type`))) ? (String(form.get(`qq_${i}_type`)) as BookingQuestion['type']) : 'text';
+    out.push({
+      id: String(form.get(`qq_${i}_id`) || '') || crypto.randomUUID().slice(0, 8),
+      label, type,
+      required: Boolean(form.get(`qq_${i}_required`)),
+      options: type === 'select' ? list(String(form.get(`qq_${i}_options`) ?? '')) : [],
+      help: String(form.get(`qq_${i}_help`) ?? '').slice(0, 300),
+    });
+  }
+  return out;
+}
+
+export const list = (s: string) => [...new Set(s.split(/[,\n]/).map((x) => x.trim()).filter(Boolean))];
+export const int = (v: FormDataEntryValue | null, min: number, max: number, fallback: number) => {
+  if (v === null || String(v).trim() === '') return fallback;
+  const n = Math.round(Number(v));
+  return Number.isFinite(n) ? Math.min(max, Math.max(min, n)) : fallback;
+};
+export const DEFAULT_HOURS: WeeklyHours = {
+  su: [], mo: [{ start: '09:00', end: '17:00' }], tu: [{ start: '09:00', end: '17:00' }], we: [{ start: '09:00', end: '17:00' }],
+  th: [{ start: '09:00', end: '17:00' }], fr: [{ start: '09:00', end: '17:00' }], sa: [],
+};