@acms-subir/core 0.2.0 → 0.3.0

package/src/lib/repo/types.ts

@@ -1,4 +1,8 @@
-import type { Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Role, WidgetInstance } from '../schema';
+import type { BookingRequest } from '../backup/content';
+import type { EmailStore } from '../email/store';
+export interface DesignVersion { id: string; createdAt: number; author: string; summary: string; snapshot: Record<string, unknown> }
+
+import type { Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Role, WidgetInstance, Calendar, CalEvent, ApiKey, ApiScope, Webhook, WebhookDelivery, Resource, BookingLink, Booking, BookingStatus } from '../schema';
 
 export interface Stats {
   publishedPages: number;
@@ -16,13 +20,32 @@ export interface SearchHit<T> {
 export interface SearchResults {
   posts: SearchHit<Post>[];
   pages: SearchHit<Page>[];
+  // published events; callers still apply calendar visibility (a private
+  // calendar's event must not surface publicly)
+  events: SearchHit<CalEvent>[];
   tags: { tag: Tag; count: number }[];
   authors: User[];
 }
 
+export type EventUpdate = Partial<
+  Pick<
+    CalEvent,
+    | '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'
+    | 'publishedAt' | 'scheduledAt'
+  >
+>;
+
 // The single contract both backends implement. The app only ever imports
 // this — never a concrete adapter.
 export interface ContentRepository {
+  readonly email: EmailStore;
+  // Bounded public catalog; fetch limit + 1 IDs without loading every body.
+  listPublicContent(options: { page: number; limit: number; kind?: 'post' | 'page'; collection?: string; locale?: string; collections: string[]; defaultLocale: string }): Promise<{ id: string; kind: 'post' | 'page' }[]>;
+  exportBookingState(): Promise<{ bookings: Booking[]; bookingRequests: BookingRequest[] }>;
+  getBookingRequest(keyHash: string): Promise<{ requestHash: string; bookingId: string } | null>;
   // pages
   listPages(): Promise<Page[]>;
   getPage(id: string): Promise<Page | null>;
@@ -71,9 +94,86 @@ export interface ContentRepository {
   applyPostDraft(id: string): Promise<void>;
   discardPostDraft(id: string): Promise<void>;
   deletePost(id: string): Promise<void>;
-  // flips scheduled posts whose time has passed to published; returns count
+  // flips scheduled posts AND events whose time has passed to published;
+  // returns the combined count
   publishDuePosts(now: number): Promise<number>;
 
+  // calendars — native calendars group events; feed calendars mirror an ICS
+  // URL live (their events are never stored). Deleting a calendar removes it
+  // from every event's calendarIds; the events themselves stay.
+  listCalendars(): Promise<Calendar[]>;
+  getCalendar(id: string): Promise<Calendar | null>;
+  getCalendarBySlug(slug: string): Promise<Calendar | null>;
+  createCalendar(data: Partial<Pick<Calendar, 'color' | 'description' | 'kind' | 'feedUrl' | 'visibility'>> & { name: string; slug: string }): Promise<Calendar>;
+  updateCalendar(id: string, data: Partial<Pick<Calendar, 'name' | 'slug' | 'color' | 'description' | 'feedUrl' | 'visibility' | 'feedToken'>>): Promise<void>;
+  reorderCalendars(ids: string[]): Promise<void>;
+  deleteCalendar(id: string): Promise<void>;
+
+  // events — same draft/publish contract as posts (live events stage edits
+  // until Update). startAt/endAt are derived from the wall-clock fields and
+  // the event (or site) timezone on every write.
+  listEvents(): Promise<CalEvent[]>;
+  listPublishedEvents(): Promise<CalEvent[]>;
+  getEvent(id: string): Promise<CalEvent | null>;
+  getEventBySlug(slug: string): Promise<CalEvent | null>;
+  createEvent(data: Partial<Omit<CalEvent, 'id' | 'draft' | 'startAt' | 'endAt' | 'createdAt' | 'updatedAt'>> & { title: string; slug: string; start: string }): Promise<CalEvent>;
+  updateEvent(id: string, data: EventUpdate): Promise<void>;
+  saveEventDraft(id: string, data: Omit<EventUpdate, 'status' | 'scheduledAt' | 'publishedAt'>): Promise<void>;
+  applyEventDraft(id: string): Promise<void>;
+  discardEventDraft(id: string): Promise<void>;
+  deleteEvent(id: string): Promise<void>;
+
+  // resources (rooms, people, vans…) and their booking links. Deleting a
+  // resource deletes its links; its bookings stay as history.
+  listResources(): Promise<Resource[]>;
+  getResource(id: string): Promise<Resource | null>;
+  getResourceBySlug(slug: string): Promise<Resource | null>;
+  createResource(data: Partial<Omit<Resource, 'id' | 'createdAt' | 'updatedAt' | 'order' | 'feedToken'>> & { name: string; slug: string }): Promise<Resource>;
+  updateResource(id: string, data: Partial<Omit<Resource, 'id' | 'createdAt' | 'updatedAt' | 'order'>>): Promise<void>;
+  reorderResources(ids: string[]): Promise<void>;
+  deleteResource(id: string): Promise<void>;
+  listBookingLinks(resourceId?: string): Promise<BookingLink[]>;
+  getBookingLink(id: string): Promise<BookingLink | null>;
+  getBookingLinkBySlug(resourceId: string, slug: string): Promise<BookingLink | null>;
+  createBookingLink(data: Partial<Omit<BookingLink, 'id' | 'createdAt' | 'updatedAt' | 'order'>> & { resourceId: string; name: string; slug: string }): Promise<BookingLink>;
+  updateBookingLink(id: string, data: Partial<Omit<BookingLink, 'id' | 'resourceId' | 'createdAt' | 'updatedAt'>>): Promise<void>;
+  deleteBookingLink(id: string): Promise<void>;
+
+  // bookings (+ staff blocks and event RSVPs). createBooking is the only
+  // 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[]>;
+  getBooking(id: string): Promise<Booking | null>;
+  getBookingByToken(token: string): Promise<Booking | null>;
+  createBooking(
+    data: Omit<Booking, 'id' | 'createdAt' | 'updatedAt' | 'reminderSentAt' | 'notificationVersion'>,
+    guard?: { capacity?: number; idempotency?: { keyHash: string; requestHash: string } }
+  ): Promise<Booking | null>;
+  // moves a booking only if the new held range is free (reschedule)
+  moveBooking(id: string, times: { start: number; end: number; holdStart: number; holdEnd: number }): Promise<boolean>;
+  updateBooking(id: string, data: Partial<Pick<Booking, 'status' | 'notes' | 'name' | 'email' | 'phone' | 'answers' | 'reminderSentAt'>> & { notificationMessage?: string }): Promise<void>;
+  deleteBooking(id: string): Promise<void>;
+  // confirmed bookings starting in [from, to) that haven't had a reminder
+  listDueReminders(from: number, to: number): Promise<Booking[]>;
+
+  // scoped API keys — only the SHA-256 hash is stored; findApiKeyByHash
+  // also stamps lastUsedAt
+  listApiKeys(): Promise<ApiKey[]>;
+  createApiKey(data: { name: string; prefix: string; keyHash: string; scopes: ApiScope[] }): Promise<ApiKey>;
+  findApiKeyByHash(keyHash: string): Promise<ApiKey | null>;
+  deleteApiKey(id: string): Promise<void>;
+
+  // webhooks + their delivery queue (lib/webhooks.ts drives both)
+  listWebhooks(): Promise<Webhook[]>;
+  createWebhook(data: { url: string; secret: string; events: string[] }): Promise<Webhook>;
+  updateWebhook(id: string, data: Partial<Pick<Webhook, 'url' | 'events' | 'active' | 'secret'>>): Promise<void>;
+  deleteWebhook(id: string): Promise<void>;
+  createDeliveries(rows: Omit<WebhookDelivery, 'attempts' | 'responseCode' | 'deliveredAt'>[]): Promise<void>;
+  listDueDeliveries(now: number, limit: number): Promise<WebhookDelivery[]>;
+  listDeliveries(webhookId: string, limit: number): Promise<WebhookDelivery[]>;
+  recordDelivery(id: string, data: Pick<WebhookDelivery, 'status' | 'attempts' | 'nextAt' | 'responseCode' | 'deliveredAt'>): Promise<void>;
+
   // media
   listMedia(): Promise<Media[]>;
   getMedia(id: string): Promise<Media | null>;
@@ -119,7 +219,7 @@ export interface ContentRepository {
   createUser(data: { name: string; email: string; role: Role; passHash: string }): Promise<User>;
   updateUser(id: string, data: { name?: string; email?: string; role?: Role; passHash?: string; bio?: string; avatar?: string; slug?: string }): Promise<void>;
   deleteUser(id: string): Promise<void>;
-  getUserAuth(email: string): Promise<{ user: User; passHash: string } | null>;
+  getUserAuth(email: string): Promise<{ user: User; passHash: string; sessionVersion: number } | null>;
 
   // navigation — managed header/footer/social items; empty header falls back
   // to the legacy auto-list of published pages in Site.astro
@@ -148,6 +248,13 @@ export interface ContentRepository {
     navItems: NavItem[];
     users: User[];
     redirects: Redirect[];
+    // added with the calendar module; older backups restore with none
+    calendars?: Calendar[];
+    events?: CalEvent[];
+    resources?: Resource[];
+    bookingLinks?: BookingLink[];
+    bookings?: Booking[];
+    bookingRequests?: BookingRequest[];
   }): Promise<void>;
 
   // redirects — exact-path forwards, consulted when a request would 404.
@@ -161,8 +268,18 @@ export interface ContentRepository {
   updateSettings(data: Partial<Settings>): Promise<void>;
   // Design-screen staging: save stages into settings.draftDesign, apply
   // copies staged → live design fields and clears, discard just clears
-  saveDesignDraft(data: Partial<Pick<Settings, 'activeTheme' | 'designOverrides' | 'siteLogo' | 'siteFavicon' | 'siteCover'>>): Promise<void>;
-  applyDesignDraft(): Promise<void>;
+  saveDesignDraft(data: Partial<Pick<Settings, 'activeTheme' | 'designOverrides' | 'siteLogo' | 'siteFavicon' | 'siteCover' | 'sectionPages'>> & {
+    navItems?: { id: string; label: string; url: string; area: NavItem['area'] }[];
+    shareEpoch?: string;
+  }): Promise<void>;
+  // replace the whole staged draft (null clears it) — per-change undo, restore
+  setDesignDraft(draft: Record<string, unknown> | null, expectedRevision?: number, actor?: string): Promise<void>;
+  listDesignAudit(): Promise<Record<string, unknown>[]>;
+  // publish: snapshot the outgoing live design into design_versions (last 20
+  // kept), apply the draft's settings + staged navigation, clear the draft
+  applyDesignDraft(opts?: { author?: string; summary?: string; expectedRevision?: number }): Promise<void>;
   discardDesignDraft(): Promise<void>;
+  listDesignVersions(limit?: number): Promise<DesignVersion[]>;
+  getDesignVersion(id: string): Promise<DesignVersion | null>;
   getStats(): Promise<Stats>;
 }

package/src/lib/scheduler.ts

@@ -0,0 +1,25 @@
+import type { ContentRepository } from './repo/types';
+import { processDueDeliveries } from './webhooks';
+import { dispatchEmail } from './email/service';
+import { sendDueReminders } from './booking/service';
+
+// All work is awaited on both hosts. Traffic-triggered fallbacks do not mark
+// this heartbeat: monitoring must prove the independent scheduler ran.
+export async function runScheduledTasks(repo: ContentRepository, locals?: unknown) {
+  const startedAt = Date.now();
+  const settings = await repo.getSettings();
+  const jobs = {
+    publish: () => repo.publishDuePosts(startedAt),
+    webhooks: () => processDueDeliveries(repo),
+    reminders: () => sendDueReminders(repo, { origin: settings.siteUrl, locals, now: startedAt }),
+    email: () => dispatchEmail(repo, locals, 10),
+  };
+  const results: Record<string, { ok: boolean; count?: number }> = {};
+  for (const [name, run] of Object.entries(jobs)) {
+    try { results[name] = { ok: true, count: await run() }; }
+    catch { results[name] = { ok: false }; }
+  }
+  const report = { startedAt, finishedAt: Date.now(), ok: Object.values(results).every(r => r.ok), jobs: results };
+  await repo.email.recordScheduler(report);
+  return report;
+}

package/src/lib/schema.ts

@@ -1,3 +1,5 @@
+import { SectionPages } from '../theme-sdk/contract.mjs';
+import { AiConfig, AgentConfig } from './ai-schema';
 import { z } from 'zod';
 
 // ---- Widgets -------------------------------------------------------------
@@ -236,6 +238,309 @@ export const Redirect = z.object({
 });
 export type Redirect = z.infer<typeof Redirect>;
 
+// ---- Calendar ------------------------------------------------------------
+// Calendars group events. `native` calendars hold events authored in the
+// admin; `feed` calendars mirror an external ICS feed (Google, Apple,
+// Outlook, any .ics) live, read-only. Visibility decides where a calendar's
+// events surface: `public` = listed on the calendar page + the all-calendars
+// feed; `unlisted` = event pages and its own feed work, but it's not listed;
+// `private` = admin-only, plus a secret-token feed for staff subscriptions.
+export const CalendarKind = z.enum(['native', 'feed']);
+export type CalendarKind = z.infer<typeof CalendarKind>;
+export const CalendarVisibility = z.enum(['public', 'unlisted', 'private']);
+export type CalendarVisibility = z.infer<typeof CalendarVisibility>;
+
+export const Calendar = z.object({
+  id: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  color: z.string().default('#4f46e5'),
+  description: z.string().default(''),
+  kind: CalendarKind.default('native'),
+  // feed calendars only: the normalized ICS URL
+  feedUrl: z.string().default(''),
+  visibility: CalendarVisibility.default('public'),
+  // secret for /calendar/<slug>.ics?t=… on private calendars (rotatable)
+  feedToken: z.string().default(''),
+  order: z.number().default(0),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+export type Calendar = z.infer<typeof Calendar>;
+
+// Times are stored as WALL-CLOCK strings in the event's timezone — that's
+// what recurrence is defined against (a 10am weekly service stays at 10am
+// across DST). Timed: 'YYYY-MM-DDTHH:mm'. All-day: 'YYYY-MM-DD', with `end`
+// the INCLUSIVE last day (how people think about it; ICS output converts to
+// the exclusive form). `timezone` '' = the site timezone. startAt/endAt are
+// the derived UTC instants of the first occurrence, kept for sorting.
+export const EventLocation = z.object({
+  name: z.string().default(''),
+  address: z.string().default(''),
+  // a map link or an online-meeting URL
+  url: z.string().default(''),
+});
+export type EventLocation = z.infer<typeof EventLocation>;
+
+export const EventCta = z.object({
+  label: z.string().default(''),
+  href: z.string().default(''),
+  style: z.enum(['primary', 'outline']).default('primary'),
+});
+export type EventCta = z.infer<typeof EventCta>;
+
+export const CalEvent = z.object({
+  id: z.string(),
+  slug: z.string(),
+  title: z.string(),
+  bodyJson: z.string().default(''),
+  bodyHtml: z.string().default(''),
+  excerpt: z.string().default(''),
+  cover: z.string().default(''),
+  coverAlt: z.string().default(''),
+  seoTitle: z.string().default(''),
+  seoDesc: z.string().default(''),
+  status: Status,
+  featured: z.boolean().default(false),
+  tags: z.array(z.string()).default([]),
+  template: z.string().default(''),
+  start: z.string(),
+  end: z.string().default(''),
+  allDay: z.boolean().default(false),
+  timezone: z.string().default(''),
+  // RFC 5545 RRULE body without the "RRULE:" prefix; '' = one-off
+  rrule: z.string().default(''),
+  // wall-clock starts (same format as `start`) of skipped occurrences
+  exdates: z.array(z.string()).default([]),
+  // a cancelled event stays visible (struck through) so people aren't left
+  // wondering where it went; feeds emit STATUS:CANCELLED
+  cancelled: z.boolean().default(false),
+  location: EventLocation.default({}),
+  cta: EventCta.default({}),
+  calendarIds: z.array(z.string()).default([]),
+  // values for acms({ calendar.eventFields }) custom fields, keyed by field key
+  fields: z.record(z.string()).default({}),
+  // UID of the feed event this was imported from ('' = authored here)
+  sourceUid: z.string().default(''),
+  // RSVP: seats per occurrence (0 = unlimited) and whether RSVPs confirm at
+  // once; RSVPs are stored as bookings of kind 'rsvp'
+  rsvp: z.object({
+    enabled: z.boolean().default(false),
+    capacity: z.number().int().default(0),
+    autoConfirm: z.boolean().default(true),
+    maxSeats: z.number().int().default(4),
+  }).default({}),
+  startAt: z.number(),
+  endAt: z.number(),
+  draft: z.record(z.any()).nullable().default(null),
+  publishedAt: z.number().nullable().default(null),
+  scheduledAt: z.number().nullable().default(null),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+export type CalEvent = z.infer<typeof CalEvent>;
+
+// ---- Bookings --------------------------------------------------------------
+// A Resource is anything people reserve: a room, a person's time, a van. Its
+// weekly hours + date overrides are the outer bound; each BookingLink narrows
+// them and adds its own rules (length, buffers, notice, questions, whether it
+// confirms automatically). Every link of a resource subtracts the same
+// Bookings, so links can never double-book the resource. Times: weekly hours
+// and overrides are wall-clock in the resource's zone; bookings store UTC.
+
+export const TimeRange = z.object({
+  start: z.string().regex(/^\d{2}:\d{2}$/),
+  end: z.string().regex(/^\d{2}:\d{2}$/),
+});
+export type TimeRange = z.infer<typeof TimeRange>;
+
+export const WEEKDAYS = ['su', 'mo', 'tu', 'we', 'th', 'fr', 'sa'] as const;
+export type Weekday = (typeof WEEKDAYS)[number];
+export const WeeklyHours = z.object({
+  su: z.array(TimeRange).default([]),
+  mo: z.array(TimeRange).default([]),
+  tu: z.array(TimeRange).default([]),
+  we: z.array(TimeRange).default([]),
+  th: z.array(TimeRange).default([]),
+  fr: z.array(TimeRange).default([]),
+  sa: z.array(TimeRange).default([]),
+});
+export type WeeklyHours = z.infer<typeof WeeklyHours>;
+
+// a date (or inclusive date span) with replacement hours; [] = closed
+export const DateOverride = z.object({
+  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  endDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).default(''),
+  ranges: z.array(TimeRange).default([]),
+  label: z.string().default(''),
+});
+export type DateOverride = z.infer<typeof DateOverride>;
+
+export const Resource = z.object({
+  id: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  // a free label: Room, Person, Vehicle, Equipment… (acms({ calendar.resourceKinds }) suggests values)
+  kind: z.string().default('Room'),
+  description: z.string().default(''),
+  photo: z.string().default(''),
+  capacity: z.number().int().nullable().default(null),
+  amenities: z.array(z.string()).default([]),
+  timezone: z.string().default(''),
+  hours: WeeklyHours.default({}),
+  overrides: z.array(DateOverride).default([]),
+  // external ICS feeds whose events block time (a person's Google calendar)
+  busyFeeds: z.array(z.string()).default([]),
+  notifyEmails: z.array(z.string()).default([]),
+  // public = listed in /book; unlisted = reachable by link only
+  visibility: z.enum(['public', 'unlisted']).default('public'),
+  // confirmed bookings show on the public calendar as "Reserved" blocks
+  showOnCalendar: z.boolean().default(false),
+  // secret for the staff feed /book/<slug>.ics?t=… (bookings with names)
+  feedToken: z.string().default(''),
+  order: z.number().default(0),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+export type Resource = z.infer<typeof Resource>;
+
+export const QUESTION_TYPES = ['text', 'textarea', 'email', 'phone', 'number', 'select', 'checkbox', 'date'] as const;
+export const BookingQuestion = z.object({
+  id: z.string(),
+  label: z.string(),
+  type: z.enum(QUESTION_TYPES).default('text'),
+  required: z.boolean().default(false),
+  options: z.array(z.string()).default([]),
+  help: z.string().default(''),
+});
+export type BookingQuestion = z.infer<typeof BookingQuestion>;
+
+export const BookingMode = z.enum(['slots', 'range', 'day']);
+export type BookingMode = z.infer<typeof BookingMode>;
+
+export const BookingLink = z.object({
+  id: z.string(),
+  resourceId: z.string(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string().default(''),
+  // slots: fixed length; range: choose a length from `lengths`; day: whole days
+  mode: BookingMode.default('slots'),
+  duration: z.number().int().default(60), // minutes (slots)
+  lengths: z.array(z.number().int()).default([]), // minutes (range) — chips
+  minDays: z.number().int().default(1), // day mode
+  maxDays: z.number().int().default(1),
+  step: z.number().int().default(30), // minutes between start times
+  bufferBefore: z.number().int().default(0),
+  bufferAfter: z.number().int().default(0),
+  minNotice: z.number().int().default(120), // minutes
+  maxAdvance: z.number().int().default(90), // days
+  perDayCap: z.number().int().default(0), // 0 = unlimited
+  // narrows the resource's hours; null = use the resource's hours as-is
+  hours: WeeklyHours.nullable().default(null),
+  // confirmed at once (and on the calendar) vs. held as pending for approval
+  autoConfirm: z.boolean().default(true),
+  visibility: z.enum(['public', 'unlisted']).default('public'),
+  askPhone: z.boolean().default(false),
+  questions: z.array(BookingQuestion).default([]),
+  confirmMessage: z.string().default(''),
+  redirectUrl: z.string().default(''),
+  active: z.boolean().default(true),
+  order: z.number().default(0),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+export type BookingLink = z.infer<typeof BookingLink>;
+
+export const BookingStatus = z.enum(['pending', 'confirmed', 'declined', 'cancelled']);
+export type BookingStatus = z.infer<typeof BookingStatus>;
+
+export const Booking = z.object({
+  id: z.string(),
+  // booking = someone reserved it; block = staff closed the time; rsvp = a
+  // seat at an event occurrence (resourceId/linkId empty, eventId set)
+  kind: z.enum(['booking', 'block', 'rsvp']).default('booking'),
+  resourceId: z.string().default(''),
+  linkId: z.string().default(''),
+  eventId: z.string().default(''),
+  status: BookingStatus,
+  start: z.number(),
+  end: z.number(),
+  // start/end widened by the link's buffers — what actually blocks the resource
+  holdStart: z.number(),
+  holdEnd: z.number(),
+  timezone: z.string().default(''),
+  name: z.string().default(''),
+  email: z.string().default(''),
+  phone: z.string().default(''),
+  seats: z.number().int().default(1),
+  answers: z.record(z.string()).default({}),
+  notes: z.string().default(''), // staff-only
+  manageToken: z.string().default(''),
+  source: z.enum(['web', 'admin', 'api', 'agent']).default('web'),
+  reminderSentAt: z.number().nullable().default(null),
+  notificationVersion: z.number().default(0),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+export type Booking = z.infer<typeof Booking>;
+
+// ---- Integrations: scoped API keys + signed webhooks ----------------------
+// Keys are shown once at creation; only a SHA-256 hash is stored. The agent
+// key from Settings → AI & agents keeps working and counts as every scope.
+export const API_SCOPES = [
+  'events:read', 'events:write',
+  'bookings:read', 'bookings:write',
+  'resources:read', 'resources:write',
+  'design:read', 'design:write-draft', 'design:publish', 'media:read', 'media:write',
+] as const;
+export const ApiScope = z.enum(API_SCOPES);
+export type ApiScope = z.infer<typeof ApiScope>;
+
+export const ApiKey = z.object({
+  id: z.string(),
+  name: z.string(),
+  // first characters of the key, shown in lists so owners can tell keys apart
+  prefix: z.string(),
+  scopes: z.array(ApiScope).default([]),
+  lastUsedAt: z.number().nullable().default(null),
+  createdAt: z.number(),
+});
+export type ApiKey = z.infer<typeof ApiKey>;
+
+export const WEBHOOK_EVENTS = [
+  'event.published', 'event.updated', 'event.unpublished', 'event.deleted',
+  'booking.created', 'booking.confirmed', 'booking.declined', 'booking.cancelled', 'booking.rescheduled',
+] as const;
+export type WebhookEventType = (typeof WEBHOOK_EVENTS)[number];
+
+export const Webhook = z.object({
+  id: z.string(),
+  url: z.string(),
+  // HMAC-SHA256 signing secret (X-Acms-Signature)
+  secret: z.string(),
+  events: z.array(z.string()).default([]),
+  active: z.boolean().default(true),
+  lastStatus: z.number().nullable().default(null),
+  lastAt: z.number().nullable().default(null),
+  createdAt: z.number(),
+});
+export type Webhook = z.infer<typeof Webhook>;
+
+export const WebhookDelivery = z.object({
+  id: z.string(),
+  webhookId: z.string(),
+  event: z.string(),
+  payload: z.string(),
+  status: z.enum(['pending', 'delivered', 'failed']),
+  attempts: z.number().default(0),
+  nextAt: z.number().nullable().default(null),
+  responseCode: z.number().nullable().default(null),
+  createdAt: z.number(),
+  deliveredAt: z.number().nullable().default(null),
+});
+export type WebhookDelivery = z.infer<typeof WebhookDelivery>;
+
 // normalize a redirect path: leading slash, no trailing slash, no origin
 export function normalizeRedirectPath(input: string): string {
   let p = input.trim();
@@ -261,6 +566,8 @@ export const Settings = z.object({
   // overrides from the Design screen layered on top of the theme's defaults
   activeTheme: z.string().default(''),
   designOverrides: z.record(z.any()).default({}),
+  sectionPages: SectionPages.default({}),
+  designRevision: z.number().int().nonnegative().default(0),
   siteLogo: z.string().default(''),
   // SEO foundation: canonical origin for absolute URLs (sitemap, feeds, OG
   // tags — empty falls back to the request origin), favicon, and the default
@@ -322,6 +629,8 @@ export const Settings = z.object({
   // external drafts API: bearer key for POST /api/drafts (empty = endpoint
   // off) and the browser origins allowed to call it ('*' entry allows all,
   // 'http://localhost:*' matches any port). Managed in /admin/settings.
+  ai: AiConfig,
+  agent: AgentConfig,
   draftsApiKey: z.string().default(''),
   draftsAllowedOrigins: z.array(z.string()).default([]),
   // staged Design-screen changes (see lib/drafts.ts); null = none pending

package/src/lib/search-i18n.ts

@@ -7,6 +7,7 @@ export interface SearchStrings {
   placeholder: string;
   posts: string;
   pages: string;
+  events: string;
   tags: string;
   authors: string;
   empty: string;
@@ -21,6 +22,7 @@ const STRINGS: Record<string, SearchStrings> = {
     placeholder: 'Search posts, pages, tags and authors',
     posts: 'Posts',
     pages: 'Pages',
+    events: 'Events',
     tags: 'Tags',
     authors: 'Authors',
     empty: 'Nothing found for',
@@ -33,6 +35,7 @@ const STRINGS: Record<string, SearchStrings> = {
     placeholder: 'Busca artículos, páginas, etiquetas y autores',
     posts: 'Artículos',
     pages: 'Páginas',
+    events: 'Eventos',
     tags: 'Etiquetas',
     authors: 'Autores',
     empty: 'No hay resultados para',

package/src/lib/socialIcons.ts

@@ -0,0 +1,32 @@
+// Brand glyphs for social links, matched by URL host. Used by the site footer
+// and the /links profile row. Unknown hosts return null and the caller falls
+// back to the item's text label. Paths are 24×24, filled with currentColor.
+
+const ICONS: [RegExp, string][] = [
+  [/(^|\.)(x|twitter)\.com$/, 'M17.8 3h3.1l-6.8 7.7L22 21h-6.2l-4.9-6.4L5.3 21H2.2l7.2-8.3L2 3h6.4l4.4 5.8L17.8 3Zm-1.1 16.2h1.7L7.4 4.7H5.6l11.1 14.5Z'],
+  [/(^|\.)github\.com$/, 'M12 2.5a9.5 9.5 0 0 0-3 18.5c.5.1.7-.2.7-.5v-1.7c-2.7.6-3.2-1.2-3.2-1.2-.4-1.1-1.1-1.4-1.1-1.4-.9-.6.1-.6.1-.6 1 .1 1.5 1 1.5 1 .9 1.5 2.3 1.1 2.9.8.1-.6.3-1.1.6-1.3-2.1-.2-4.4-1.1-4.4-4.7 0-1 .4-1.9 1-2.6-.1-.2-.4-1.2.1-2.5 0 0 .8-.3 2.6 1a9 9 0 0 1 4.8 0c1.8-1.3 2.6-1 2.6-1 .5 1.3.2 2.3.1 2.5.6.7 1 1.6 1 2.6 0 3.7-2.3 4.5-4.4 4.7.3.3.6.9.6 1.8v2.6c0 .3.2.6.7.5A9.5 9.5 0 0 0 12 2.5Z'],
+  [/(^|\.)linkedin\.com$/, 'M5 3.5a2 2 0 1 1 0 4 2 2 0 0 1 0-4ZM3.3 9h3.4v11.5H3.3V9Zm5.6 0h3.3v1.6c.5-.9 1.6-1.9 3.4-1.9 3.6 0 4.2 2.3 4.2 5.4v6.4h-3.4v-5.7c0-1.4 0-3.1-1.9-3.1s-2.2 1.5-2.2 3v5.8H8.9V9Z'],
+  [/(^|\.)instagram\.com$/, 'M12 7.4a4.6 4.6 0 1 0 0 9.2 4.6 4.6 0 0 0 0-9.2Zm0 7.6a3 3 0 1 1 0-6 3 3 0 0 1 0 6Zm5.9-7.8a1.1 1.1 0 1 1-2.2 0 1.1 1.1 0 0 1 2.2 0ZM12 4.3c2.5 0 2.8 0 3.8.1 2.6.1 3.7 1.3 3.8 3.8.1 1 .1 1.3.1 3.8s0 2.8-.1 3.8c-.1 2.5-1.3 3.7-3.8 3.8-1 .1-1.3.1-3.8.1s-2.8 0-3.8-.1c-2.6-.1-3.7-1.3-3.8-3.8-.1-1-.1-1.3-.1-3.8s0-2.8.1-3.8c.1-2.5 1.3-3.7 3.8-3.8 1-.1 1.3-.1 3.8-.1Zm0-1.7c-2.6 0-2.9 0-3.9.1-3.5.2-5.4 2.1-5.6 5.6-.1 1-.1 1.3-.1 3.9s0 2.9.1 3.9c.2 3.5 2.1 5.4 5.6 5.6 1 .1 1.3.1 3.9.1s2.9 0 3.9-.1c3.5-.2 5.4-2.1 5.6-5.6.1-1 .1-1.3.1-3.9s0-2.9-.1-3.9c-.2-3.5-2.1-5.4-5.6-5.6-1-.1-1.3-.1-3.9-.1Z'],
+  [/(^|\.)(youtube\.com|youtu\.be)$/, 'M21.6 7.2a2.5 2.5 0 0 0-1.8-1.8C18.2 5 12 5 12 5s-6.2 0-7.8.4A2.5 2.5 0 0 0 2.4 7.2C2 8.8 2 12 2 12s0 3.2.4 4.8a2.5 2.5 0 0 0 1.8 1.8c1.6.4 7.8.4 7.8.4s6.2 0 7.8-.4a2.5 2.5 0 0 0 1.8-1.8c.4-1.6.4-4.8.4-4.8s0-3.2-.4-4.8ZM10 15V9l5.2 3L10 15Z'],
+  [/(^|\.)(facebook\.com|fb\.com)$/, 'M13.5 21v-7.6h2.6l.4-3h-3V8.5c0-.9.2-1.5 1.5-1.5h1.6V4.3c-.3 0-1.2-.1-2.3-.1-2.3 0-3.9 1.4-3.9 4v2.2H7.8v3h2.6V21h3.1Z'],
+  [/(^|\.)tiktok\.com$/, 'M16.6 3h-3.1v12.3a2.6 2.6 0 1 1-2.6-2.6c.3 0 .5 0 .8.1V9.6a5.8 5.8 0 1 0 4.9 5.7V9.1a7.3 7.3 0 0 0 4.3 1.4V7.4a4.3 4.3 0 0 1-4.3-4.4Z'],
+];
+
+const RSS = 'M5 3a16 16 0 0 1 16 16h-3A13 13 0 0 0 5 6V3Zm0 6a10 10 0 0 1 10 10h-3a7 7 0 0 0-7-7V9Zm1.5 6.5a2 2 0 1 1 0 4 2 2 0 0 1 0-4Z';
+const MAIL = 'M3 5h18a1 1 0 0 1 1 1v12a1 1 0 0 1-1 1H3a1 1 0 0 1-1-1V6a1 1 0 0 1 1-1Zm1.5 2v.3l7.5 5.2 7.5-5.2V7h-15Zm15 2.7-7.5 5.2-7.5-5.2V17h15V9.7Z';
+
+// the SVG path for a social URL, or null when the host isn't recognised
+export function socialIconPath(url: string): string | null {
+  if (url.startsWith('mailto:')) return MAIL;
+  if (/\/rss\.xml$|\/feed\/?$/.test(url)) return RSS;
+  let host = '';
+  try {
+    host = new URL(url).hostname.replace(/^www\./, '');
+  } catch {
+    return null;
+  }
+  return ICONS.find(([re]) => re.test(host))?.[1] ?? null;
+}
+
+export const socialIconSvg = (path: string) =>
+  `<svg viewBox="0 0 24 24" width="16" height="16" fill="currentColor" aria-hidden="true"><path d="${path}"/></svg>`;

package/src/lib/tagColor.ts

@@ -0,0 +1,11 @@
+// Tag marker colors. Labels render as a small rounded-square marker + text
+// (never a filled pill); each tag gets a stable hue hashed from its name, so
+// the same tag is the same color on every page without any stored setting.
+// Mid-tone hues chosen to read on both light and dark canvases.
+const PALETTE = ['#3a86d6', '#2f9e6e', '#d9822b', '#8a6cf0', '#d45a8a', '#0c8599', '#c2872a', '#6b7fd7'];
+
+export function tagColor(name: string): string {
+  let h = 0;
+  for (const c of name.toLowerCase()) h = (h * 31 + c.charCodeAt(0)) >>> 0;
+  return PALETTE[h % PALETTE.length];
+}