@acms-subir/core 0.1.0 → 0.3.0

package/src/lib/repo/types.ts

@@ -1,4 +1,8 @@
-import type { Page, Post, Link, Media, NavItem, Redirect, Settings, 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>;
@@ -36,6 +59,12 @@ export interface ContentRepository {
       blocks?: WidgetInstance[];
     }
   ): Promise<void>;
+  // pending edits on a live page: save stages into the `draft` JSON column
+  // (live columns untouched), apply copies staged → live and clears, discard
+  // just clears. See lib/drafts.ts for the snapshot shape.
+  savePageDraft(id: string, data: Omit<Parameters<ContentRepository['updatePage']>[1], 'status'>): Promise<void>;
+  applyPageDraft(id: string): Promise<void>;
+  discardPageDraft(id: string): Promise<void>;
   deletePage(id: string): Promise<void>;
 
   // posts
@@ -60,10 +89,91 @@ export interface ContentRepository {
       >
     >
   ): Promise<void>;
+  // pending edits on a live post — same contract as the page variants above
+  savePostDraft(id: string, data: Omit<Parameters<ContentRepository['updatePost']>[1], 'status' | 'scheduledAt'>): Promise<void>;
+  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>;
@@ -98,13 +208,18 @@ export interface ContentRepository {
   // auto-register any names missing from the registry (called on post save)
   ensureTags(names: string[]): Promise<void>;
 
+  // snippets — named, reusable editor-content fragments
+  listSnippets(): Promise<Snippet[]>;
+  createSnippet(data: { name: string; contentJson: string }): Promise<Snippet>;
+  deleteSnippet(id: string): Promise<void>;
+
   // users — passHash stays inside the repo; getUserAuth is for login only
   listUsers(): Promise<User[]>;
   getUser(id: string): Promise<User | null>;
   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
@@ -133,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.
@@ -144,5 +266,20 @@ export interface ContentRepository {
   // settings & dashboard
   getSettings(): Promise<Settings>;
   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' | '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 -------------------------------------------------------------
@@ -78,6 +80,8 @@ export const Page = z.object({
   seoDesc: z.string().default(''),
   // theme template name (templates/page-<name>.astro); empty = default layout
   template: z.string().default(''),
+  // pending edits on a live page (see lib/drafts.ts); null = none staged
+  draft: z.record(z.any()).nullable().default(null),
   createdAt: z.number(),
   updatedAt: z.number(),
 });
@@ -110,6 +114,8 @@ export const Post = z.object({
   authorIds: z.array(z.string()).default([]),
   // theme template name (templates/post-<name>.astro); empty = default layout
   template: z.string().default(''),
+  // pending edits on a live post (see lib/drafts.ts); null = none staged
+  draft: z.record(z.any()).nullable().default(null),
   publishedAt: z.number().nullable(),
   scheduledAt: z.number().nullable().default(null),
   createdAt: z.number(),
@@ -152,6 +158,17 @@ export const Tag = z.object({
 });
 export type Tag = z.infer<typeof Tag>;
 
+// Snippets: named, reusable fragments of editor content, saved from a
+// selection and re-inserted from the "/" menu. contentJson is a JSON array of
+// ProseMirror nodes.
+export const Snippet = z.object({
+  id: z.string(),
+  name: z.string(),
+  contentJson: z.string(),
+  createdAt: z.number(),
+});
+export type Snippet = z.infer<typeof Snippet>;
+
 export const Role = z.enum(['owner', 'editor']);
 export type Role = z.infer<typeof Role>;
 
@@ -221,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();
@@ -246,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
@@ -268,11 +590,51 @@ export const Settings = z.object({
       dismissible: z.boolean().default(true),
     })
     .default({}),
+  // analytics providers, rendered into the public <head> by lib/analytics.ts
+  // (owner-only; IDs are re-validated there before any markup is built)
+  analytics: z
+    .object({
+      umami: z
+        .object({
+          enabled: z.boolean().default(false),
+          websiteId: z.string().default(''),
+          scriptUrl: z.string().default('https://cloud.umami.is/script.js'),
+          // session replay (Umami v3.1+): a second recorder.js tag, derived
+          // from scriptUrl. Defaults mirror Umami's own dashboard defaults.
+          replay: z
+            .object({
+              enabled: z.boolean().default(false),
+              sampleRate: z.number().min(0.01).max(1).default(0.15),
+              maskLevel: z.enum(['moderate', 'strict']).default('moderate'),
+              maxDuration: z.number().int().positive().default(300000),
+            })
+            .default({}),
+        })
+        .default({}),
+      metaPixel: z
+        .object({
+          enabled: z.boolean().default(false),
+          pixelId: z.string().default(''),
+        })
+        .default({}),
+      // experimental: same code path as the others, but not verified live yet
+      tiktokPixel: z
+        .object({
+          enabled: z.boolean().default(false),
+          pixelId: z.string().default(''),
+        })
+        .default({}),
+    })
+    .default({}),
   // 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
+  draftDesign: z.record(z.any()).nullable().default(null),
 });
 export type Settings = z.infer<typeof Settings>;
 

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',