@acms-subir/core 0.3.3-next.20260929113209 → 0.3.4

package/src/lib/repo/sql.ts

@@ -1,9 +1,11 @@
 import { LiveStore } from '../live/store';
+import { PushStore } from '../push/store';
+import { EditorStore } from '../editor/store';
 import { LiveConfig } from '../live/types';
 import { ApiError } from '../api';
 import { EmailStore, bookingJobs } from '../email/store';
 import type { ContentRepository, DesignVersion, EventUpdate, ImportRecord, ImportRecordKind, ImportRun, SearchResults, Stats } from './types';
-import { Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, isInternalTag, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
+import { DocTranslations, Page, Post, Link, Media, NavItem, Redirect, Settings, Snippet, Tag, User, Calendar, CalEvent, ApiKey, Webhook, WebhookDelivery, Resource, BookingLink, Booking, isInternalTag, normalizeRedirectPath, publicTags, slugify, type WidgetInstance } from '../schema';
 import { designSnapshot, draftNavItems, pickDesignDraft, pickEventDraft, pickPageDraft, pickPostDraft } from '../drafts';
 import { eventInstants, eventTimeZone, normalizeEventTimes } from '../calendar/events';
 import { cleanRrule } from '../calendar/rrule';
@@ -43,6 +45,11 @@ function parseDraft(raw: unknown): Record<string, unknown> | null {
   }
 }
 
+// translations column: tolerate old rows / junk (never break a page render)
+function parseTranslations(v: unknown) {
+  const parsed = DocTranslations.safeParse(json(v, {}));
+  return parsed.success ? parsed.data : {};
+}
 function rowToPage(r: Row): Page {
   return Page.parse({
     id: r.id, slug: r.slug, title: r.title, status: r.status,
@@ -50,7 +57,7 @@ function rowToPage(r: Row): Page {
     blocks: JSON.parse(String(r.blocks ?? '[]')),
     bodyJson: r.body_json ?? '', bodyHtml: r.body_html ?? '',
     seoTitle: r.seo_title ?? '', seoDesc: r.seo_desc ?? '',
-    template: r.template ?? '', draft: parseDraft(r.draft),
+    template: r.template ?? '', draft: parseDraft(r.draft), translations: parseTranslations(r.translations),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
 }
@@ -62,7 +69,7 @@ function rowToPost(r: Row, authorIds?: string[]): Post {
     seoTitle: r.seo_title ?? '', seoDesc: r.seo_desc ?? '', status: r.status,
     featured: Boolean(r.featured), authorId: r.author_id ?? null,
     authorIds: authorIds ?? (r.author_id ? [String(r.author_id)] : []),
-    template: r.template ?? '', draft: parseDraft(r.draft),
+    template: r.template ?? '', draft: parseDraft(r.draft), translations: parseTranslations(r.translations),
     publishedAt: r.published_at === null ? null : Number(r.published_at),
     scheduledAt: r.scheduled_at === null ? null : Number(r.scheduled_at),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
@@ -137,8 +144,8 @@ function rowToEvent(r: Row): CalEvent {
     start: r.starts, end: r.ends ?? '', allDay: Boolean(r.all_day), timezone: r.timezone ?? '',
     rrule: r.rrule ?? '', exdates: json(r.exdates, []), cancelled: Boolean(r.cancelled),
     location: json(r.location, {}), cta: json(r.cta, {}), calendarIds: json(r.calendar_ids, []),
-    fields: json(r.fields, {}), sourceUid: r.source_uid ?? '', rsvp: json(r.rsvp, {}),
-    startAt: Number(r.start_at), endAt: Number(r.end_at), draft: parseDraft(r.draft),
+    fields: json(r.fields, {}), sourceUid: r.source_uid ?? '', rsvp: json(r.rsvp, {}), roomHold: json(r.room_hold, {}),
+    startAt: Number(r.start_at), endAt: Number(r.end_at), draft: parseDraft(r.draft), translations: parseTranslations(r.translations),
     publishedAt: r.published_at === null || r.published_at === undefined ? null : Number(r.published_at),
     scheduledAt: r.scheduled_at === null || r.scheduled_at === undefined ? null : Number(r.scheduled_at),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
@@ -154,6 +161,14 @@ function rowToResource(r: Row): Resource {
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
   });
 }
+// Callers that still speak the old on/off flag (REST, agent tools, older
+// code) set autoConfirm without an approval mode: map it so "off" really
+// holds bookings. On create, "on" follows the site default (which starts as
+// automatic); on update it pins the link to automatic.
+function legacyApproval<T extends { autoConfirm?: boolean; approval?: BookingLink['approval'] }>(data: T, update = false): T {
+  if (data.approval !== undefined || data.autoConfirm === undefined) return data;
+  return { ...data, approval: data.autoConfirm ? (update ? 'auto' : 'default') : 'manual' };
+}
 function rowToLink2(r: Row): BookingLink {
   return BookingLink.parse({
     id: r.id, resourceId: r.resource_id, slug: r.slug, name: r.name, description: r.description ?? '', mode: r.mode ?? 'slots',
@@ -161,6 +176,7 @@ function rowToLink2(r: Row): BookingLink {
     step: Number(r.step), bufferBefore: Number(r.buffer_before), bufferAfter: Number(r.buffer_after),
     minNotice: Number(r.min_notice), maxAdvance: Number(r.max_advance), perDayCap: Number(r.per_day_cap),
     hours: r.hours ? json(r.hours, null) : null, autoConfirm: Boolean(r.auto_confirm), visibility: r.visibility ?? 'public',
+    approval: r.approval ?? 'default', approvalRules: json(r.approval_rules, {}),
     askPhone: Boolean(r.ask_phone), questions: json(r.questions, []), confirmMessage: r.confirm_message ?? '',
     redirectUrl: r.redirect_url ?? '', active: Boolean(r.active), order: Number(r.ord ?? 0),
     createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
@@ -233,10 +249,14 @@ export class SqlRepository implements ContentRepository {
   private ready: Promise<void>;
   readonly email: EmailStore;
   readonly live: LiveStore;
+  readonly push: PushStore;
+  readonly editor: EditorStore;
 
   constructor(driver: SqlDriver | (() => Promise<SqlDriver>)) {
     this.ready = this.init(driver);
     this.live = new LiveStore(async () => { await this.ready; return this.driver; });
+    this.push = new PushStore(async () => { await this.ready; return this.driver; });
+    this.editor = new EditorStore(async () => { await this.ready; return this.driver; });
     this.email = new EmailStore(async () => { await this.ready; return this.driver; });
   }
 
@@ -466,6 +486,7 @@ export class SqlRepository implements ContentRepository {
     if (data.seoTitle !== undefined) { sets.push('seo_title = ?'); args.push(data.seoTitle); }
     if (data.seoDesc !== undefined) { sets.push('seo_desc = ?'); args.push(data.seoDesc); }
     if (data.template !== undefined) { sets.push('template = ?'); args.push(data.template); }
+    if (data.translations !== undefined) { sets.push('translations = ?'); args.push(JSON.stringify(data.translations)); }
     if (data.blocks !== undefined) { sets.push('blocks = ?'); args.push(JSON.stringify(data.blocks)); }
     if (data.bodyJson !== undefined) { sets.push('body_json = ?'); args.push(data.bodyJson); }
     if (data.bodyHtml !== undefined) { sets.push('body_html = ?'); args.push(data.bodyHtml); }
@@ -598,6 +619,7 @@ export class SqlRepository implements ContentRepository {
     if (data.seoDesc !== undefined) { sets.push('seo_desc = ?'); args.push(data.seoDesc); }
     if (data.featured !== undefined) { sets.push('featured = ?'); args.push(data.featured ? 1 : 0); }
     if (data.template !== undefined) { sets.push('template = ?'); args.push(data.template); }
+    if (data.translations !== undefined) { sets.push('translations = ?'); args.push(JSON.stringify(data.translations)); }
     // authorIds is the source of truth; author_id mirrors the first entry.
     // Main row, join rows and webhook notifications share one transaction.
     let authorJoin: string[] | null = null;
@@ -798,8 +820,8 @@ export class SqlRepository implements ContentRepository {
     await this.driver.run(
       `INSERT INTO events (id, slug, title, body_json, body_html, excerpt, cover, cover_alt, seo_title, seo_desc, status, featured, tags, template,
         starts, ends, all_day, timezone, rrule, exdates, cancelled, location, cta, calendar_ids, fields, source_uid, start_at, end_at,
-        published_at, scheduled_at, created_at, updated_at, rsvp)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        published_at, scheduled_at, created_at, updated_at, rsvp, room_hold)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         id, data.slug, data.title, data.bodyJson ?? '', data.bodyHtml ?? '', data.excerpt ?? '', data.cover ?? '', data.coverAlt ?? '',
         data.seoTitle ?? '', data.seoDesc ?? '', data.status ?? 'draft', data.featured ? 1 : 0, JSON.stringify(data.tags ?? []), data.template ?? '',
@@ -807,7 +829,7 @@ export class SqlRepository implements ContentRepository {
         data.cancelled ? 1 : 0, JSON.stringify(data.location ?? {}), JSON.stringify(data.cta ?? {}), JSON.stringify(data.calendarIds ?? []),
         JSON.stringify(data.fields ?? {}), data.sourceUid ?? '', startAt, endAt,
         data.publishedAt ?? (data.status === 'published' ? now : null), data.scheduledAt ?? null, now, now,
-        JSON.stringify(data.rsvp ?? {}),
+        JSON.stringify(data.rsvp ?? {}), JSON.stringify(data.roomHold ?? {}),
       ]
     );
     await this.syncEventIndex(id);
@@ -832,7 +854,7 @@ export class SqlRepository implements ContentRepository {
       if (v !== undefined) { sets.push(`${col} = ?`); args.push(v); }
     }
     const jsonCols: Record<string, string> = {
-      tags: 'tags', exdates: 'exdates', location: 'location', cta: 'cta', calendarIds: 'calendar_ids', fields: 'fields', rsvp: 'rsvp',
+      tags: 'tags', exdates: 'exdates', location: 'location', cta: 'cta', calendarIds: 'calendar_ids', fields: 'fields', rsvp: 'rsvp', translations: 'translations', roomHold: 'room_hold',
     };
     for (const [k, col] of Object.entries(jsonCols)) {
       const v = (data as Record<string, unknown>)[k];
@@ -923,10 +945,11 @@ export class SqlRepository implements ContentRepository {
     return {
       sql: `INSERT INTO booking_links (id, resource_id, slug, name, description, mode, duration, lengths, min_days, max_days, step, buffer_before,
         buffer_after, min_notice, max_advance, per_day_cap, hours, auto_confirm, visibility, ask_phone, questions, confirm_message, redirect_url,
-        active, ord, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        active, ord, created_at, updated_at, approval, approval_rules) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [l.id, l.resourceId, l.slug, l.name, l.description, l.mode, l.duration, JSON.stringify(l.lengths), l.minDays, l.maxDays, l.step,
         l.bufferBefore, l.bufferAfter, l.minNotice, l.maxAdvance, l.perDayCap, l.hours ? JSON.stringify(l.hours) : null, l.autoConfirm ? 1 : 0,
-        l.visibility, l.askPhone ? 1 : 0, JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.createdAt, l.updatedAt],
+        l.visibility, l.askPhone ? 1 : 0, JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.createdAt, l.updatedAt,
+        l.approval, JSON.stringify(l.approvalRules)],
     };
   }
   private bookingInsert(b: Booking): SqlStatement {
@@ -1004,7 +1027,7 @@ export class SqlRepository implements ContentRepository {
     await this.ready;
     const now = Date.now();
     const next = await this.first('SELECT COALESCE(MAX(ord), -1) + 1 AS n FROM booking_links WHERE resource_id = ?', [data.resourceId]);
-    const l = BookingLink.parse({ ...data, id: crypto.randomUUID(), order: Number(next?.n ?? 0), createdAt: now, updatedAt: now });
+    const l = BookingLink.parse({ ...legacyApproval(data), id: crypto.randomUUID(), order: Number(next?.n ?? 0), createdAt: now, updatedAt: now });
     const st = this.linkInsert(l);
     await this.driver.run(st.sql, st.args);
     return l;
@@ -1013,14 +1036,14 @@ export class SqlRepository implements ContentRepository {
     await this.ready;
     const cur = await this.getBookingLink(id);
     if (!cur) return;
-    const l = BookingLink.parse({ ...cur, ...data, id, updatedAt: Date.now() });
+    const l = BookingLink.parse({ ...cur, ...legacyApproval(data, true), id, updatedAt: Date.now() });
     await this.driver.run(
       `UPDATE booking_links SET slug = ?, name = ?, description = ?, mode = ?, duration = ?, lengths = ?, min_days = ?, max_days = ?, step = ?,
         buffer_before = ?, buffer_after = ?, min_notice = ?, max_advance = ?, per_day_cap = ?, hours = ?, auto_confirm = ?, visibility = ?,
-        ask_phone = ?, questions = ?, confirm_message = ?, redirect_url = ?, active = ?, ord = ?, updated_at = ? WHERE id = ?`,
+        ask_phone = ?, questions = ?, confirm_message = ?, redirect_url = ?, active = ?, ord = ?, updated_at = ?, approval = ?, approval_rules = ? WHERE id = ?`,
       [l.slug, l.name, l.description, l.mode, l.duration, JSON.stringify(l.lengths), l.minDays, l.maxDays, l.step, l.bufferBefore, l.bufferAfter,
         l.minNotice, l.maxAdvance, l.perDayCap, l.hours ? JSON.stringify(l.hours) : null, l.autoConfirm ? 1 : 0, l.visibility, l.askPhone ? 1 : 0,
-        JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.updatedAt, id]
+        JSON.stringify(l.questions), l.confirmMessage, l.redirectUrl, l.active ? 1 : 0, l.order, l.updatedAt, l.approval, JSON.stringify(l.approvalRules), id]
     );
   }
   async deleteBookingLink(id: string) {
@@ -1035,6 +1058,7 @@ export class SqlRepository implements ContentRepository {
     const args: unknown[] = [];
     if (filter.resourceId) { where.push('resource_id = ?'); args.push(filter.resourceId); }
     if (filter.eventId) { where.push('event_id = ?'); args.push(filter.eventId); }
+    if (filter.email) { where.push('email = ?'); args.push(filter.email.toLowerCase()); }
     if (filter.from !== undefined) { where.push('end_at > ?'); args.push(filter.from); }
     if (filter.to !== undefined) { where.push('start_at < ?'); args.push(filter.to); }
     if (filter.statuses?.length) { where.push(`status IN (${filter.statuses.map(() => '?').join(', ')})`); args.push(...filter.statuses); }
@@ -1601,14 +1625,14 @@ export class SqlRepository implements ContentRepository {
       ...(content.events ?? []).map((e) => ({
         sql: `INSERT INTO events (id, slug, title, body_json, body_html, excerpt, cover, cover_alt, seo_title, seo_desc, status, featured, tags, template,
           starts, ends, all_day, timezone, rrule, exdates, cancelled, location, cta, calendar_ids, fields, source_uid, start_at, end_at,
-          draft, published_at, scheduled_at, created_at, updated_at, rsvp)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          draft, published_at, scheduled_at, created_at, updated_at, rsvp, room_hold)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: [
           e.id, e.slug, e.title, e.bodyJson, e.bodyHtml, e.excerpt, e.cover, e.coverAlt, e.seoTitle, e.seoDesc, e.status, e.featured ? 1 : 0,
           JSON.stringify(e.tags), e.template, e.start, e.end, e.allDay ? 1 : 0, e.timezone, e.rrule, JSON.stringify(e.exdates),
           e.cancelled ? 1 : 0, JSON.stringify(e.location), JSON.stringify(e.cta), JSON.stringify(e.calendarIds), JSON.stringify(e.fields),
           e.sourceUid, e.startAt, e.endAt, e.draft ? JSON.stringify(e.draft) : null, e.publishedAt, e.scheduledAt, e.createdAt, e.updatedAt,
-          JSON.stringify(e.rsvp ?? {}),
+          JSON.stringify(e.rsvp ?? {}), JSON.stringify(e.roomHold ?? {}),
         ],
       })),
       ...(content.resources ?? []).map((r) => this.resourceInsert(r)),
@@ -1633,6 +1657,10 @@ export class SqlRepository implements ContentRepository {
           args: [p.id, aid, i] as unknown[],
         }))
       ),
+      // translations (v36): written after the rows so older backups need no change
+      ...[['pages', content.pages], ['posts', content.posts], ['events', content.events ?? []]].flatMap(([table, rows]) =>
+        (rows as { id: string; translations?: Record<string, unknown> }[]).filter((r) => r.translations && Object.keys(r.translations).length)
+          .map((r) => ({ sql: `UPDATE ${table} SET translations = ? WHERE id = ?`, args: [JSON.stringify(r.translations), r.id] as unknown[] }))),
       ...content.media.map((m) => ({
         sql: 'INSERT INTO media (id, key, filename, mime, width, height, size, alt, variants, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
         args: [m.id, m.key, m.filename, m.mime, m.width, m.height, m.size, m.alt, JSON.stringify(m.variants), m.createdAt],
@@ -1818,6 +1846,8 @@ export class SqlRepository implements ContentRepository {
       timezone: r?.timezone ?? '', locale: r?.locale ?? '',
       ai: JSON.parse(String(r?.ai ?? '{}')),
       live: JSON.parse(String(r?.live ?? '{}')),
+      push: JSON.parse(String(r?.push ?? '{}')),
+      calendar: JSON.parse(String(r?.calendar ?? '{}')),
       agent: JSON.parse(String(r?.agent ?? '{}')),
       draftsApiKey: r?.drafts_api_key ?? '',
       draftsAllowedOrigins: JSON.parse(String(r?.drafts_allowed_origins ?? '[]')),
@@ -1834,9 +1864,9 @@ export class SqlRepository implements ContentRepository {
       siteTitle:'site_title', tagline:'tagline', footerText:'footer_text', linksName:'links_name', linksBio:'links_bio', linksAvatar:'links_avatar',
       activeTheme:'active_theme', designOverrides:'design_overrides', sectionPages:'section_pages', siteLogo:'site_logo', siteUrl:'site_url', siteFavicon:'site_favicon', siteCover:'site_cover',
       announcement:'announcement', analytics:'analytics', headCode:'head_code', footerCode:'footer_code', timezone:'timezone', locale:'locale',
-      draftsApiKey:'drafts_api_key', draftsAllowedOrigins:'drafts_allowed_origins', draftDesign:'draft_design', ai:'ai', agent:'agent', live:'live',
+      draftsApiKey:'drafts_api_key', draftsAllowedOrigins:'drafts_allowed_origins', draftDesign:'draft_design', ai:'ai', agent:'agent', live:'live', push:'push', calendar:'calendar',
     };
-    const jsonKeys = new Set(['designOverrides','sectionPages','announcement','analytics','draftsAllowedOrigins','draftDesign','ai','agent','live']);
+    const jsonKeys = new Set(['designOverrides','sectionPages','announcement','analytics','draftsAllowedOrigins','draftDesign','ai','agent','live','push','calendar']);
     const entries = Object.entries(data).filter(([k,v]) => columns[k] && v !== undefined);
     if (!entries.length) return;
     const design = entries.some(([k]) => ['activeTheme','designOverrides','sectionPages','siteLogo','siteFavicon','siteCover','draftDesign'].includes(k));
@@ -1901,6 +1931,21 @@ export class SqlRepository implements ContentRepository {
     } }));
     await this.designWrite(opts.expectedRevision ?? current.designRevision, opts.author ?? 'admin', 'publish', statements);
   }
+  async publishSectionPages(live: Settings['sectionPages'], staged: Settings['sectionPages'] | null, opts: { author?: string; summary?: string; expectedRevision: number }) {
+    const current = await this.getSettings();
+    const liveNav = await this.listNavItems();
+    const draft: Record<string, unknown> = { ...(current.draftDesign ?? {}) };
+    if (staged) draft.sectionPages = staged; else delete draft.sectionPages;
+    // a draft with nothing left to publish goes away entirely
+    const remaining = Object.keys(pickDesignDraft(draft)).length > 0 || Array.isArray(draft.navItems);
+    const statements: SqlStatement[] = [
+      { sql: 'INSERT INTO design_versions (id,created_at,author,summary,snapshot) VALUES (?,?,?,?,?)', args: [crypto.randomUUID(), Date.now(), opts.author ?? '', opts.summary ?? '', JSON.stringify(designSnapshot(current, liveNav))] },
+      { sql: 'DELETE FROM design_versions WHERE id NOT IN (SELECT id FROM design_versions ORDER BY created_at DESC LIMIT 20)' },
+      { sql: 'UPDATE settings SET section_pages=?,draft_design=? WHERE id=1', args: [JSON.stringify(live), remaining ? JSON.stringify({ ...draft, savedAt: Date.now() }) : null] },
+      webhookStatement('design.published', { design: { revision: current.designRevision + 1, activeTheme: current.activeTheme, navigationChanged: false, sectionPageIds: Object.keys(live) } }),
+    ];
+    await this.designWrite(opts.expectedRevision, opts.author ?? 'admin', 'publish', statements);
+  }
   async discardDesignDraft() { await this.setDesignDraft(null); }
   async listDesignVersions(limit = 20) {
     await this.ready;

package/src/lib/repo/types.ts

@@ -1,6 +1,8 @@
 import type { LiveStore } from '../live/store';
 import type { BookingRequest } from '../backup/content';
 import type { EmailStore } from '../email/store';
+import type { PushStore } from '../push/store';
+import type { EditorStore } from '../editor/store';
 export interface ImportRun { id: string; source: string; label: string; status: 'running' | 'done' | 'undone'; report: Record<string, unknown>; createdAt: number; updatedAt: number }
 export type ImportRecordKind = 'post' | 'page' | 'user' | 'tag' | 'media' | 'redirect' | 'nav';
 export interface ImportRecord { runId: string; kind: ImportRecordKind; sourceId: string; acmsId: string; action: 'created' | 'updated'; stamp: number }
@@ -37,7 +39,7 @@ export type EventUpdate = Partial<
     | 'title' | 'slug' | 'bodyJson' | 'bodyHtml' | 'excerpt' | 'cover' | 'coverAlt'
     | 'seoTitle' | 'seoDesc' | 'status' | 'featured' | 'tags' | 'template'
     | 'start' | 'end' | 'allDay' | 'timezone' | 'rrule' | 'exdates' | 'cancelled'
-    | 'location' | 'cta' | 'calendarIds' | 'fields' | 'sourceUid' | 'rsvp'
+    | 'location' | 'cta' | 'calendarIds' | 'fields' | 'sourceUid' | 'rsvp' | 'translations' | 'roomHold'
     | 'publishedAt' | 'scheduledAt'
   >
 >;
@@ -47,6 +49,8 @@ export type EventUpdate = Partial<
 export interface ContentRepository {
   readonly email: EmailStore;
   readonly live: LiveStore;
+  readonly push: PushStore;
+  readonly editor: EditorStore;
   // 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[] }>;
@@ -60,7 +64,7 @@ export interface ContentRepository {
   createPage(data: { title: string; slug: string }): Promise<Page>;
   updatePage(
     id: string,
-    data: Partial<Pick<Page, 'title' | 'slug' | 'status' | 'isHome' | 'locale' | 'seoTitle' | 'seoDesc' | 'bodyJson' | 'bodyHtml' | 'template'>> & {
+    data: Partial<Pick<Page, 'title' | 'slug' | 'status' | 'isHome' | 'locale' | 'seoTitle' | 'seoDesc' | 'bodyJson' | 'bodyHtml' | 'template' | 'translations'>> & {
       blocks?: WidgetInstance[];
     }
   ): Promise<void>;
@@ -90,7 +94,7 @@ export interface ContentRepository {
         | 'title' | 'slug' | 'collection' | 'body' | 'bodyJson' | 'bodyHtml' | 'excerpt'
         | 'tags' | 'cover' | 'coverAlt' | 'seoTitle' | 'seoDesc'
         | 'status' | 'featured' | 'authorId' | 'authorIds' | 'template'
-        | 'publishedAt' | 'scheduledAt'
+        | 'publishedAt' | 'scheduledAt' | 'translations'
       >
     >
   ): Promise<void>;
@@ -148,7 +152,7 @@ export interface ContentRepository {
   // write that can fail on a race: it inserts atomically only if the held
   // range is still free (resource bookings) or seats remain (RSVPs), and
   // returns null when it lost.
-  listBookings(filter?: { resourceId?: string; eventId?: string; from?: number; to?: number; statuses?: BookingStatus[]; kinds?: Booking['kind'][] }): Promise<Booking[]>;
+  listBookings(filter?: { resourceId?: string; eventId?: string; email?: string; from?: number; to?: number; statuses?: BookingStatus[]; kinds?: Booking['kind'][] }): Promise<Booking[]>;
   getBooking(id: string): Promise<Booking | null>;
   getBookingByToken(token: string): Promise<Booking | null>;
   createBooking(
@@ -298,6 +302,8 @@ export interface ContentRepository {
   // 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>;
+  /** publish section layouts only (one section's edits); the rest of the draft stays staged */
+  publishSectionPages(live: Settings['sectionPages'], staged: Settings['sectionPages'] | null, opts: { author?: string; summary?: string; expectedRevision: number }): Promise<void>;
   discardDesignDraft(): Promise<void>;
   listDesignVersions(limit?: number): Promise<DesignVersion[]>;
   getDesignVersion(id: string): Promise<DesignVersion | null>;

package/src/lib/roles.ts

@@ -0,0 +1,5 @@
+import type { Role } from './schema';
+
+export const roleLabels: Record<Role, string> = {
+  contributor: 'Contributor', author: 'Author', editor: 'Editor', administrator: 'Administrator', owner: 'Owner',
+};

package/src/lib/scheduler.ts

@@ -2,7 +2,8 @@ import { syncDueLive } from './live/service';
 import type { ContentRepository } from './repo/types';
 import { processDueDeliveries } from './webhooks';
 import { dispatchEmail } from './email/service';
-import { sendDueReminders } from './booking/service';
+import { decideOverdue, sendDueReminders } from './booking/service';
+import { runPushJobs } from './push/service';
 
 // All work is awaited on both hosts. Traffic-triggered fallbacks do not mark
 // this heartbeat: monitoring must prove the independent scheduler ran.
@@ -13,8 +14,12 @@ export async function runScheduledTasks(repo: ContentRepository, locals?: unknow
     publish: () => repo.publishDuePosts(startedAt),
     webhooks: () => processDueDeliveries(repo),
     reminders: () => sendDueReminders(repo, { origin: settings.siteUrl, locals, now: startedAt }),
+    // pending bookings past their approval deadline (Calendar settings → Bookings)
+    approvals: () => decideOverdue(repo, { origin: settings.siteUrl, locals, now: startedAt }),
     email: () => dispatchEmail(repo, locals, 10),
     live: () => syncDueLive(repo, locals),
+    // queued first-publish notices, starting-soon reminders, receipts, retention
+    push: () => runPushJobs(repo, { locals, now: startedAt }),
   };
   const results: Record<string, { ok: boolean; count?: number }> = {};
   for (const [name, run] of Object.entries(jobs)) {

package/src/lib/schema.ts

@@ -1,4 +1,5 @@
 import { LiveConfig } from './live/types';
+import { PushSettings } from './push/types';
 import { SectionPages } from '../theme-sdk/contract.mjs';
 import { AiConfig, AgentConfig } from './ai-schema';
 import { z } from 'zod';
@@ -64,6 +65,26 @@ export function parseConfig<T extends WidgetType>(type: T, raw: unknown): z.infe
 export const Status = z.enum(['draft', 'scheduled', 'published', 'archived']);
 export type Status = z.infer<typeof Status>;
 
+// Per-language words for a post, page or event (the facts stay shared):
+//   translations: { es: { title, excerpt, bodyHtml, seoTitle, seoDesc, slug,
+//                          locationName, ctaLabel, meta: { title: { state, src } } } }
+// state 'ai' = machine draft (shown, flagged for review), 'reviewed' = a person
+// wrote/approved it; src = hash of the main-language text it was made from.
+export const DocTranslation = z.object({
+  title: z.string().max(1000).default(''),
+  excerpt: z.string().max(5000).default(''),
+  bodyHtml: z.string().max(2_000_000).default(''),
+  seoTitle: z.string().max(1000).default(''),
+  seoDesc: z.string().max(5000).default(''),
+  slug: z.string().max(300).default(''),
+  locationName: z.string().max(500).default(''),
+  ctaLabel: z.string().max(300).default(''),
+  meta: z.record(z.string().max(40), z.object({ state: z.enum(['ai', 'reviewed']), src: z.string().max(20) })).default({}),
+});
+export type DocTranslation = z.infer<typeof DocTranslation>;
+export const DocTranslations = z.record(z.string().regex(/^[a-z]{2,3}(-[a-z0-9]{2,8})?$/), DocTranslation).default({});
+export type DocTranslations = z.infer<typeof DocTranslations>;
+
 export const Page = z.object({
   id: z.string(),
   slug: z.string(),
@@ -83,6 +104,7 @@ export const Page = z.object({
   // 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
+  translations: DocTranslations,
   draft: z.record(z.any()).nullable().default(null),
   createdAt: z.number(),
   updatedAt: z.number(),
@@ -117,6 +139,7 @@ export const Post = z.object({
   // 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
+  translations: DocTranslations,
   draft: z.record(z.any()).nullable().default(null),
   publishedAt: z.number().nullable(),
   scheduledAt: z.number().nullable().default(null),
@@ -171,7 +194,7 @@ export const Snippet = z.object({
 });
 export type Snippet = z.infer<typeof Snippet>;
 
-export const Role = z.enum(['owner', 'editor']);
+export const Role = z.enum(['contributor', 'author', 'editor', 'administrator', 'owner']);
 export type Role = z.infer<typeof Role>;
 
 // Password hashes never leave the repo layer — User is the public shape.
@@ -291,6 +314,17 @@ export const EventCta = z.object({
 });
 export type EventCta = z.infer<typeof EventCta>;
 
+export const RoomHold = z.object({
+  resourceIds: z.array(z.string()).default([]),
+  span: z.enum(['event', 'day']).default('event'),
+  before: z.number().int().min(0).max(1440).default(0), // setup minutes
+  after: z.number().int().min(0).max(1440).default(0), // cleanup minutes
+  whileDraft: z.boolean().default(false),
+  // bookings you chose to keep (share the room): no longer flagged as conflicts
+  keep: z.array(z.string()).default([]),
+});
+export type RoomHold = z.infer<typeof RoomHold>;
+
 export const CalEvent = z.object({
   id: z.string(),
   slug: z.string(),
@@ -332,8 +366,13 @@ export const CalEvent = z.object({
     autoConfirm: z.boolean().default(true),
     maxSeats: z.number().int().default(4),
   }).default({}),
+  // rooms/people this event uses: they can't be booked while it happens (or
+  // all day). Computed into availability, never stored as bookings. Drafts
+  // only hold when whileDraft is on; cancelled events never hold.
+  roomHold: RoomHold.default({}),
   startAt: z.number(),
   endAt: z.number(),
+  translations: DocTranslations,
   draft: z.record(z.any()).nullable().default(null),
   publishedAt: z.number().nullable().default(null),
   scheduledAt: z.number().nullable().default(null),
@@ -420,6 +459,36 @@ export type BookingQuestion = z.infer<typeof BookingQuestion>;
 export const BookingMode = z.enum(['slots', 'range', 'day']);
 export type BookingMode = z.infer<typeof BookingMode>;
 
+// Booking approval: "auto" confirms at once, "manual" holds every booking for
+// a decision, "rules" confirms unless one of the rules flags it. A link can
+// follow the site default ("default") or pick its own. The deadline decides
+// pending bookings nobody answered (0 hours = keep waiting).
+export const ApprovalMode = z.enum(['auto', 'rules', 'manual']);
+export type ApprovalMode = z.infer<typeof ApprovalMode>;
+export const ApprovalRules = z.object({
+  // 0 = rule off
+  longerThan: z.number().int().min(0).default(0), // minutes
+  firstTime: z.boolean().default(false),
+  moreSeats: z.number().int().min(0).default(0),
+  deadlineHours: z.number().int().min(0).max(24 * 60).default(0),
+  deadlineAction: z.enum(['approve', 'decline']).default('approve'),
+});
+export type ApprovalRules = z.infer<typeof ApprovalRules>;
+
+// Site-wide calendar preferences (Calendar settings → Defaults / Bookings)
+export const CalendarSettings = z.object({
+  // first column of every month grid: 0 = Sunday, 1 = Monday
+  weekStart: z.union([z.literal(0), z.literal(1)]).default(0),
+  // calendar new events land in (quick add, New event); '' = none
+  defaultCalendarId: z.string().default(''),
+  // '' = not chosen in the admin yet → acms({ calendar.bookings.approval }) → auto
+  approval: z.union([ApprovalMode, z.literal('')]).default(''),
+  approvalRules: ApprovalRules.default({}),
+  // show bookings on the Schedule grid
+  showBookings: z.boolean().default(true),
+});
+export type CalendarSettings = z.infer<typeof CalendarSettings>;
+
 export const BookingLink = z.object({
   id: z.string(),
   resourceId: z.string(),
@@ -442,6 +511,9 @@ export const BookingLink = z.object({
   hours: WeeklyHours.nullable().default(null),
   // confirmed at once (and on the calendar) vs. held as pending for approval
   autoConfirm: z.boolean().default(true),
+  // supersedes autoConfirm: 'default' follows Calendar settings → Bookings
+  approval: z.union([ApprovalMode, z.literal('default')]).default('default'),
+  approvalRules: ApprovalRules.default({}),
   visibility: z.enum(['public', 'unlisted']).default('public'),
   askPhone: z.boolean().default(false),
   questions: z.array(BookingQuestion).default([]),
@@ -560,6 +632,9 @@ export function normalizeRedirectPath(input: string): string {
 
 export const Settings = z.object({
   live: LiveConfig.default({}),
+  calendar: CalendarSettings.default({}),
+  // push notification automation (lib/push); the feature itself is acms({ mobile: { push } })
+  push: PushSettings.default({}),
   siteTitle: z.string().default('My Site'),
   tagline: z.string().default(''),
   // site-wide footer, markdown allowed; empty falls back to "title — tagline"

package/src/lib/section-ai.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import sanitizeHtml from 'sanitize-html';
+import type { AiConfig } from './ai-schema';
+import { completeText } from './ai';
+import { ApiError } from './api';
+
+// "Help me write" for section fields: rewrite one field's text with the
+// site's configured AI provider. The owner reviews the suggestion before it
+// replaces anything; nothing is saved here.
+
+export const AssistInput = z.object({
+  action: z.enum(['shorter', 'friendlier', 'clearer', 'translate', 'draft']),
+  text: z.string().max(20_000).default(''),
+  label: z.string().max(100),
+  kind: z.enum(['text', 'textarea', 'richtext']).default('text'),
+  hint: z.string().max(300).optional(),
+  maxLength: z.number().int().min(1).max(20_000).optional(),
+  language: z.string().max(40).optional(),
+  // other filled-in fields of the same section, for context ("Heading: Join us")
+  context: z.string().max(4000).optional(),
+}).strict();
+
+const ACTIONS: Record<z.infer<typeof AssistInput>['action'], string> = {
+  shorter: 'Make it noticeably shorter while keeping every fact (names, days, times, places, prices).',
+  friendlier: 'Make it warmer and more welcoming, plain words, no hype or exclamation marks.',
+  clearer: 'Fix spelling and grammar and make it clearer. Change as little as possible.',
+  translate: 'Translate it into the requested language. Keep names of people and places as they are.',
+  draft: 'Write it from scratch for this field, using the other fields as context. Be concrete and plain.',
+};
+
+export async function assistField(config: AiConfig, raw: unknown): Promise<{ text: string }> {
+  const a = AssistInput.parse(raw);
+  if (a.action !== 'draft' && !a.text.trim()) throw new ApiError(400, 'Write something first, or use “Write a first draft”.');
+  if (a.action === 'translate' && !a.language) throw new ApiError(400, 'Choose a language.');
+  const rules = [
+    'You edit short text for a section of a website (for example a church, club or small business homepage).',
+    `The field is “${a.label}”.`,
+    ACTIONS[a.action],
+    a.action === 'translate' ? `Target language: ${a.language}.` : 'Keep the original language.',
+    a.hint ? `The site owner's guidance for this field: ${a.hint}` : '',
+    a.maxLength ? `Stay under ${a.maxLength} characters.` : '',
+    a.kind === 'richtext' ? 'Return simple HTML using only <p>, <strong>, <em>, <a href>, <ul>, <ol>, <li>. Keep existing links.' : 'Return plain text only.',
+    a.kind === 'text' ? 'One line, no line breaks.' : '',
+    'Return only the new text: no quotes, labels, notes or alternatives. Never invent facts, dates, prices or contact details.',
+  ].filter(Boolean).join('\n');
+  const input = [a.context ? `Other fields in this section:\n${a.context}` : '', a.text ? `Current text:\n${a.text}` : 'The field is empty.'].filter(Boolean).join('\n\n');
+  let out = (await completeText(config, rules, input)).replace(/^```\w*\n?|\n?```$/g, '').trim();
+  if (/^["“].*["”]$/s.test(out)) out = out.slice(1, -1).trim();
+  out = a.kind === 'richtext'
+    ? sanitizeHtml(out, { allowedTags: ['p', 'br', 'strong', 'b', 'em', 'i', 'a', 'ul', 'ol', 'li'], allowedAttributes: { a: ['href'] }, allowedSchemes: ['http', 'https', 'mailto', 'tel'] })
+    : sanitizeHtml(out, { allowedTags: [], allowedAttributes: {} }).replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+  if (a.kind === 'text') out = out.replace(/\s*\n+\s*/g, ' ');
+  if (!out) throw new ApiError(502, 'The AI returned nothing useful. Try again.');
+  return { text: out };
+}

package/src/lib/section-targets.ts

@@ -0,0 +1,62 @@
+import type { ContentRepository } from './repo/types';
+import { CONTENT, collectionUrl } from './content';
+import { I18N, extraLocales, localeName } from './i18n';
+import { translationEngine } from './translate';
+import { CALENDAR, bookingLinkUrl, bookingsEnabled, eventUrl } from './calendar/config';
+
+const NAMES: Record<string, string> = { en: 'English', es: 'Spanish', fr: 'French', de: 'German', pt: 'Portuguese', it: 'Italian', nl: 'Dutch', ko: 'Korean', zh: 'Chinese', ja: 'Japanese', tl: 'Tagalog', vi: 'Vietnamese', ar: 'Arabic', ru: 'Russian', uk: 'Ukrainian', pl: 'Polish' };
+// the site's own languages first, then common ones
+const languageNames = () => [...new Set([...(I18N.enabled ? I18N.locales : []).map((l) => NAMES[l.split('-')[0]] ?? l), 'English', 'Spanish', 'French', 'Portuguese', 'Korean', 'Chinese'])];
+
+// Choices for the Design screen's section fields: what a link field can point
+// at (stored as a ref so it follows slug changes) and what a source field can
+// show. Published/public things only — this is what visitors can reach.
+
+export interface LinkTarget { ref: string; label: string; url: string; group: 'Pages' | 'Posts' | 'Events' | 'Booking' }
+export interface SectionTargets {
+  links: LinkTarget[];
+  calendars: { slug: string; name: string }[];
+  collections: { key: string; label: string }[];
+  tags: string[];
+  resources: { slug: string; name: string }[];
+  features: { events: boolean; bookings: boolean };
+  /** AI help for text fields: provider configured + languages to translate into */
+  ai: { enabled: boolean; languages: string[] };
+  /** extra site languages to translate into, and whether machine drafts are available */
+  i18n: { defaultLocale: string; locales: { code: string; name: string }[]; drafts: boolean };
+}
+
+export async function sectionTargets(repo: ContentRepository, locals?: unknown): Promise<SectionTargets> {
+  const bookings = bookingsEnabled();
+  const settings = await repo.getSettings();
+  const [pages, posts, events, calendars, tags, resources, links] = await Promise.all([
+    repo.listPages(),
+    repo.listPublishedPosts(),
+    CALENDAR.enabled ? repo.listPublishedEvents() : Promise.resolve([]),
+    CALENDAR.enabled ? repo.listCalendars() : Promise.resolve([]),
+    repo.listTags(),
+    bookings ? repo.listResources() : Promise.resolve([]),
+    bookings ? repo.listBookingLinks() : Promise.resolve([]),
+  ]);
+  const publicResources = resources.filter((r) => r.visibility === 'public');
+  const bySlug = new Map(resources.map((r) => [r.id, r]));
+  const out: LinkTarget[] = [
+    ...pages.filter((p) => p.status === 'published').map((p): LinkTarget => ({ ref: `page:${p.id}`, label: p.title || p.slug, url: p.isHome ? '/' : `/${p.slug}`, group: 'Pages' })),
+    ...posts.slice(0, 200).map((p): LinkTarget => ({ ref: `post:${p.id}`, label: p.title, url: collectionUrl(p.collection, p.slug), group: 'Posts' })),
+    ...events.slice(0, 200).map((e): LinkTarget => ({ ref: `event:${e.id}`, label: e.title, url: eventUrl(e.slug), group: 'Events' })),
+    ...links.filter((l) => l.active && bySlug.has(l.resourceId)).map((l): LinkTarget => {
+      const r = bySlug.get(l.resourceId)!;
+      return { ref: `booking:${l.id}`, label: `${r.name} · ${l.name}`, url: bookingLinkUrl(r.slug, l.slug), group: 'Booking' };
+    }),
+  ];
+  return {
+    links: out,
+    calendars: calendars.filter((c) => c.visibility !== 'private').map((c) => ({ slug: c.slug, name: c.name })),
+    collections: Object.entries(CONTENT.collections).map(([key, c]) => ({ key, label: c.plural })),
+    tags: [...new Set(tags.map((t) => t.name))].sort((a, b) => a.localeCompare(b)),
+    resources: publicResources.map((r) => ({ slug: r.slug, name: r.name })),
+    features: { events: CALENDAR.enabled, bookings },
+    ai: { enabled: Boolean(settings.ai.enabled && settings.ai.model), languages: languageNames() },
+    i18n: { defaultLocale: I18N.defaultLocale, locales: extraLocales().map((code) => ({ code, name: localeName(code, true) })), drafts: translationEngine(settings.ai, locals) !== null },
+  };
+}