@acms-subir/core 0.3.2 → 0.3.3

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, 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 type { ContentRepository, DesignVersion, EventUpdate, ImportRecord, ImportRecordKind, ImportRun, SearchResults, Stats } from './types';
+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,12 +69,26 @@ 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),
   });
 }
+function rowToImportRun(r: Row): ImportRun {
+  let report: Record<string, unknown> = {};
+  try { report = JSON.parse(String(r.report ?? '{}')); } catch { /* keep empty */ }
+  return {
+    id: String(r.id), source: String(r.source), label: String(r.label ?? ''), status: String(r.status) as ImportRun['status'],
+    report, createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
+  };
+}
+function rowToImportRecord(r: Row): ImportRecord {
+  return {
+    runId: String(r.run_id), kind: String(r.kind) as ImportRecordKind, sourceId: String(r.source_id), acmsId: String(r.acms_id),
+    action: String(r.action) as ImportRecord['action'], stamp: Number(r.stamp ?? 0),
+  };
+}
 function rowToSnippet(r: Row): Snippet {
   return Snippet.parse({
     id: r.id, name: r.name, contentJson: r.content_json ?? '[]', createdAt: Number(r.created_at),
@@ -124,7 +145,7 @@ function rowToEvent(r: Row): CalEvent {
     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),
+    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),
@@ -219,10 +240,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; });
   }
 
@@ -452,6 +477,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); }
@@ -584,6 +610,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;
@@ -818,7 +845,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',
     };
     for (const [k, col] of Object.entries(jsonCols)) {
       const v = (data as Record<string, unknown>)[k];
@@ -1577,7 +1604,7 @@ export class SqlRepository implements ContentRepository {
       // Suppression and re-enabling share the restore transaction. A failed
       // restore cannot leave notifications disabled or emit phantom deletes.
       { sql: 'UPDATE webhook_control SET suppressed=1 WHERE id=1' },
-      ...['email_jobs', 'email_attempts', 'email_delivery_events', 'email_tokens', 'posts', 'pages', 'media', 'links', 'tags', 'nav_items', 'users', 'post_authors', 'redirects', 'calendars', 'events', 'resources', 'booking_links', 'bookings', 'mobile_booking_requests'].map((t) => ({
+      ...['email_jobs', 'email_attempts', 'email_delivery_events', 'email_tokens', 'posts', 'pages', 'media', 'links', 'tags', 'nav_items', 'users', 'post_authors', 'redirects', 'calendars', 'events', 'resources', 'booking_links', 'bookings', 'mobile_booking_requests', 'import_runs', 'import_records'].map((t) => ({
         sql: `DELETE FROM ${t}`,
       })),
       ...(content.calendars ?? []).map((c) => ({
@@ -1619,6 +1646,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],
@@ -1656,6 +1687,106 @@ export class SqlRepository implements ContentRepository {
     await this.reindexSearch();
   }
 
+  // ---- imports ----
+  async createImportRun({ id, source, label }: Pick<ImportRun, 'id' | 'source' | 'label'>) {
+    await this.ready;
+    const now = Date.now();
+    await this.driver.run('INSERT INTO import_runs (id, source, label, status, report, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)', [id, source, label, 'running', '{}', now, now]);
+  }
+  async updateImportRun(id: string, data: Partial<Pick<ImportRun, 'status' | 'report'>>) {
+    await this.ready;
+    const sets = ['updated_at = ?'];
+    const args: unknown[] = [Date.now()];
+    if (data.status !== undefined) { sets.push('status = ?'); args.push(data.status); }
+    if (data.report !== undefined) { sets.push('report = ?'); args.push(JSON.stringify(data.report)); }
+    await this.driver.run(`UPDATE import_runs SET ${sets.join(', ')} WHERE id = ?`, [...args, id]);
+  }
+  async listImportRuns() {
+    await this.ready;
+    return (await this.driver.all('SELECT * FROM import_runs ORDER BY created_at DESC')).map(rowToImportRun);
+  }
+  async getImportRun(id: string) {
+    await this.ready;
+    const r = await this.first('SELECT * FROM import_runs WHERE id = ?', [id]);
+    return r ? rowToImportRun(r) : null;
+  }
+  async addImportRecords(records: ImportRecord[]) {
+    await this.ready;
+    const now = Date.now();
+    await this.driver.batch(records.map((r) => ({
+      sql: 'INSERT INTO import_records (run_id, kind, source_id, acms_id, action, stamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(run_id, kind, source_id) DO UPDATE SET acms_id = excluded.acms_id, stamp = excluded.stamp',
+      args: [r.runId, r.kind, r.sourceId, r.acmsId, r.action, r.stamp, now],
+    })));
+  }
+  async listImportRecords(runId: string) {
+    await this.ready;
+    return (await this.driver.all('SELECT * FROM import_records WHERE run_id = ? ORDER BY created_at ASC', [runId])).map(rowToImportRecord);
+  }
+  async findImportRecords(kind: ImportRecordKind, sourceIds: string[]) {
+    await this.ready;
+    if (!sourceIds.length) return [];
+    const out: ImportRecord[] = [];
+    // chunked to stay under SQLite's bound-parameter limit
+    for (let i = 0; i < sourceIds.length; i += 200) {
+      const chunk = sourceIds.slice(i, i + 200);
+      const rows = await this.driver.all(
+        `SELECT r.* FROM import_records r JOIN import_runs u ON u.id = r.run_id
+         WHERE u.status != 'undone' AND r.kind = ? AND r.source_id IN (${chunk.map(() => '?').join(', ')})
+         ORDER BY r.created_at ASC`,
+        [kind, ...chunk]
+      );
+      out.push(...rows.map(rowToImportRecord));
+    }
+    // later runs win
+    return [...new Map(out.map((r) => [r.sourceId, r])).values()];
+  }
+  async writeImported(data: { posts?: Post[]; pages?: Page[]; deletePosts?: string[]; deletePages?: string[] }) {
+    await this.ready;
+    const posts = data.posts ?? [], pages = data.pages ?? [];
+    const stmts: SqlStatement[] = [{ sql: 'UPDATE webhook_control SET suppressed=1 WHERE id=1' }];
+    for (const p of posts) {
+      stmts.push({
+        sql: `INSERT INTO posts (id, collection, slug, title, body, body_json, body_html, excerpt, tags, cover, cover_alt, seo_title, seo_desc, status, featured, author_id, template, draft, published_at, scheduled_at, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET collection = excluded.collection, slug = excluded.slug, title = excluded.title, body = excluded.body,
+            body_json = excluded.body_json, body_html = excluded.body_html, excerpt = excluded.excerpt, tags = excluded.tags, cover = excluded.cover,
+            cover_alt = excluded.cover_alt, seo_title = excluded.seo_title, seo_desc = excluded.seo_desc, status = excluded.status,
+            featured = excluded.featured, author_id = excluded.author_id, template = excluded.template, draft = NULL,
+            published_at = excluded.published_at, scheduled_at = excluded.scheduled_at, updated_at = excluded.updated_at`,
+        args: [p.id, p.collection, p.slug, p.title, p.body, p.bodyJson, p.bodyHtml, p.excerpt, JSON.stringify(p.tags), p.cover, p.coverAlt, p.seoTitle, p.seoDesc, p.status, p.featured ? 1 : 0, p.authorIds[0] ?? null, p.template, null, p.publishedAt, p.scheduledAt, p.createdAt, p.updatedAt],
+      });
+      stmts.push({ sql: 'DELETE FROM post_authors WHERE post_id = ?', args: [p.id] });
+      p.authorIds.forEach((aid, i) => stmts.push({ sql: 'INSERT INTO post_authors (post_id, author_id, ord) VALUES (?, ?, ?)', args: [p.id, aid, i] }));
+    }
+    for (const p of pages) {
+      stmts.push({
+        sql: `INSERT INTO pages (id, slug, title, status, is_home, locale, blocks, body_json, body_html, seo_title, seo_desc, template, draft, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET slug = excluded.slug, title = excluded.title, status = excluded.status, locale = excluded.locale,
+            blocks = excluded.blocks, body_json = excluded.body_json, body_html = excluded.body_html, seo_title = excluded.seo_title,
+            seo_desc = excluded.seo_desc, template = excluded.template, draft = NULL, updated_at = excluded.updated_at`,
+        args: [p.id, p.slug, p.title, p.status, p.isHome ? 1 : 0, p.locale, JSON.stringify(p.blocks), p.bodyJson, p.bodyHtml, p.seoTitle, p.seoDesc, p.template, null, p.createdAt, p.updatedAt],
+      });
+    }
+    for (const id of data.deletePosts ?? []) {
+      stmts.push(
+        { sql: 'DELETE FROM posts WHERE id = ?', args: [id] },
+        { sql: 'DELETE FROM post_authors WHERE post_id = ?', args: [id] },
+        { sql: "DELETE FROM search_index WHERE kind = 'post' AND ref_id = ?", args: [id] },
+      );
+    }
+    for (const id of data.deletePages ?? []) {
+      stmts.push(
+        { sql: 'DELETE FROM pages WHERE id = ?', args: [id] },
+        { sql: "DELETE FROM search_index WHERE kind = 'page' AND ref_id = ?", args: [id] },
+      );
+    }
+    stmts.push({ sql: 'UPDATE webhook_control SET suppressed=0 WHERE id=1' });
+    await this.driver.batch(stmts);
+    for (const p of posts) await this.syncPostIndex(p.id);
+    for (const p of pages) await this.syncPageIndex(p.id);
+  }
+
   // ---- redirects ----
   async listRedirects() {
     await this.ready;
@@ -1704,6 +1835,7 @@ 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 ?? '{}')),
       agent: JSON.parse(String(r?.agent ?? '{}')),
       draftsApiKey: r?.drafts_api_key ?? '',
       draftsAllowedOrigins: JSON.parse(String(r?.drafts_allowed_origins ?? '[]')),
@@ -1720,9 +1852,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',
     };
-    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']);
     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));
@@ -1787,6 +1919,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,11 @@
 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 }
 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';
@@ -34,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'
     | 'publishedAt' | 'scheduledAt'
   >
 >;
@@ -44,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[] }>;
@@ -57,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>;
@@ -87,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>;
@@ -260,6 +267,20 @@ export interface ContentRepository {
     bookingRequests?: BookingRequest[];
   }): Promise<void>;
 
+  // imports (lib/import/apply.ts drives these). writeImported is the
+  // id-preserving bulk write for imported posts/pages: original timestamps
+  // are kept and publication webhooks stay silent (a migration of old posts
+  // is not news), in one transaction with the search index refreshed after.
+  createImportRun(run: Pick<ImportRun, 'id' | 'source' | 'label'>): Promise<void>;
+  updateImportRun(id: string, data: Partial<Pick<ImportRun, 'status' | 'report'>>): Promise<void>;
+  listImportRuns(): Promise<ImportRun[]>;
+  getImportRun(id: string): Promise<ImportRun | null>;
+  addImportRecords(records: ImportRecord[]): Promise<void>;
+  listImportRecords(runId: string): Promise<ImportRecord[]>;
+  // latest record per source id across runs that weren't undone
+  findImportRecords(kind: ImportRecordKind, sourceIds: string[]): Promise<ImportRecord[]>;
+  writeImported(data: { posts?: Post[]; pages?: Page[]; deletePosts?: string[]; deletePages?: string[] }): Promise<void>;
+
   // redirects — exact-path forwards, consulted when a request would 404.
   // createRedirect upserts on fromPath and prunes self/loop entries.
   listRedirects(): Promise<Redirect[]>;
@@ -281,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

@@ -3,6 +3,7 @@ import type { ContentRepository } from './repo/types';
 import { processDueDeliveries } from './webhooks';
 import { dispatchEmail } from './email/service';
 import { 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.
@@ -15,6 +16,8 @@ export async function runScheduledTasks(repo: ContentRepository, locals?: unknow
     reminders: () => sendDueReminders(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.
@@ -334,6 +357,7 @@ export const CalEvent = z.object({
   }).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),
@@ -560,6 +584,8 @@ export function normalizeRedirectPath(input: string): string {
 
 export const Settings = z.object({
   live: LiveConfig.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 },
+  };
+}