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

package/src/lib/push/store.ts

@@ -0,0 +1,144 @@
+import type { SqlDriver } from '../repo/sql';
+import type { PushDevice, PushNotification, PushQueueRow, PushStats, PushPlatform } from './types';
+
+type Row = Record<string, unknown>;
+const list = (raw: unknown): string[] => { try { const v = JSON.parse(String(raw ?? '[]')); return Array.isArray(v) ? v.map(String) : []; } catch { return []; } };
+function device(r: Row): PushDevice {
+  return { id: String(r.id), token: String(r.token), platform: r.platform as PushPlatform, locale: String(r.locale ?? ''), topics: list(r.topics),
+    createdAt: Number(r.created_at), updatedAt: Number(r.updated_at), lastSeenAt: Number(r.last_seen_at) };
+}
+function notification(r: Row): PushNotification {
+  return { id: String(r.id), title: String(r.title), body: String(r.body ?? ''), url: String(r.url ?? ''), topics: list(r.topics),
+    source: r.source as PushNotification['source'], sourceKey: String(r.source_key ?? ''), status: r.status as PushNotification['status'],
+    recipients: Number(r.recipients), sent: Number(r.sent), ok: Number(r.ok), failed: Number(r.failed), removed: Number(r.removed ?? 0),
+    error: String(r.error ?? ''), author: String(r.author ?? ''), createdAt: Number(r.created_at), finishedAt: r.finished_at == null ? null : Number(r.finished_at) };
+}
+// audience filter: ['*'] = every device, otherwise any shared topic
+function audienceWhere(topics: string[]): { sql: string; args: unknown[] } {
+  if (topics.includes('*')) return { sql: '1', args: [] };
+  if (!topics.length) return { sql: '0', args: [] };
+  return { sql: `EXISTS (SELECT 1 FROM json_each(push_devices.topics) t WHERE t.value IN (${topics.map(() => '?').join(',')}))`, args: topics };
+}
+
+// Storage for devices, the delivery log, Expo tickets and the automatic
+// notification queue. Shared by the D1 and libSQL adapters (plain SQLite).
+export class PushStore {
+  constructor(private driver: () => Promise<SqlDriver>) {}
+  private async all(sql: string, args: unknown[] = []) { return (await this.driver()).all(sql, args); }
+  private async run(sql: string, args: unknown[] = []) { return (await this.driver()).run(sql, args); }
+
+  // ---- devices ----
+  /** Register or refresh. `topics` undefined keeps a known device's topics (new devices start with none). */
+  async upsertDevice(d: { id: string; token: string; platform: PushPlatform; locale: string; topics?: string[] }, now: number): Promise<{ device: PushDevice; created: boolean }> {
+    const topics = d.topics === undefined ? null : JSON.stringify(d.topics);
+    // RETURNING also yields the previous row's created_at on the update branch,
+    // so "created" is exact: only the insert branch writes created_at = now.
+    const rows = await this.all(`INSERT INTO push_devices (id,token,platform,locale,topics,created_at,updated_at,last_seen_at) VALUES (?,?,?,?,COALESCE(?,'[]'),?,?,?)
+      ON CONFLICT(id) DO UPDATE SET platform=excluded.platform, locale=excluded.locale, topics=COALESCE(?,push_devices.topics),
+      updated_at=excluded.updated_at, last_seen_at=excluded.last_seen_at RETURNING *`, [d.id, d.token, d.platform, d.locale, topics, now, now, now, topics]);
+    const row = device(rows[0]);
+    return { device: row, created: row.createdAt === now };
+  }
+  async updateDevice(id: string, data: { locale?: string; topics?: string[] }, now: number): Promise<PushDevice | null> {
+    const rows = await this.all(`UPDATE push_devices SET locale=COALESCE(?,locale), topics=COALESCE(?,topics), updated_at=?, last_seen_at=? WHERE id=? RETURNING *`,
+      [data.locale ?? null, data.topics ? JSON.stringify(data.topics) : null, now, now, id]);
+    return rows[0] ? device(rows[0]) : null;
+  }
+  async getDevice(id: string) { const r = await this.all('SELECT * FROM push_devices WHERE id=?', [id]); return r[0] ? device(r[0]) : null; }
+  async deleteDevices(ids: string[]) {
+    for (let i = 0; i < ids.length; i += 90) {
+      const chunk = ids.slice(i, i + 90);
+      await this.run(`DELETE FROM push_devices WHERE id IN (${chunk.map(() => '?').join(',')})`, chunk);
+    }
+  }
+  async audience(topics: string[]): Promise<PushDevice[]> {
+    const w = audienceWhere(topics);
+    return (await this.all(`SELECT * FROM push_devices WHERE ${w.sql} ORDER BY created_at`, w.args)).map(device);
+  }
+  async countAudience(topics: string[]): Promise<number> {
+    const w = audienceWhere(topics);
+    return Number((await this.all(`SELECT COUNT(*) AS n FROM push_devices WHERE ${w.sql}`, w.args))[0]?.n ?? 0);
+  }
+  async stats(now: number): Promise<PushStats> {
+    const [totals, topics] = await Promise.all([
+      this.all(`SELECT COUNT(*) AS n, SUM(platform='ios') AS ios, SUM(platform='android') AS android, SUM(last_seen_at>=?) AS active FROM push_devices`, [now - 30 * 86400000]),
+      this.all(`SELECT t.value AS topic, COUNT(*) AS n FROM push_devices, json_each(push_devices.topics) t GROUP BY t.value`),
+    ]);
+    const t = totals[0] ?? {};
+    return { devices: Number(t.n ?? 0), platforms: { ios: Number(t.ios ?? 0), android: Number(t.android ?? 0) }, active30: Number(t.active ?? 0),
+      topics: Object.fromEntries(topics.map((r) => [String(r.topic), Number(r.n)])) };
+  }
+
+  // ---- delivery log ----
+  async createNotification(n: PushNotification) {
+    await this.run(`INSERT INTO push_notifications (id,title,body,url,topics,source,source_key,status,recipients,sent,ok,failed,removed,error,author,created_at,finished_at)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, [n.id, n.title, n.body, n.url, JSON.stringify(n.topics), n.source, n.sourceKey, n.status,
+      n.recipients, n.sent, n.ok, n.failed, n.removed, n.error, n.author, n.createdAt, n.finishedAt]);
+  }
+  async finishNotification(id: string, d: Pick<PushNotification, 'status' | 'sent' | 'ok' | 'failed' | 'removed' | 'error' | 'finishedAt'>) {
+    await this.run('UPDATE push_notifications SET status=?,sent=?,ok=?,failed=?,removed=?,error=?,finished_at=? WHERE id=?',
+      [d.status, d.sent, d.ok, d.failed, d.removed, d.error, d.finishedAt, id]);
+  }
+  /** a later receipt turned an accepted ticket into a failure */
+  async receiptFailed(counts: Map<string, { failed: number; removed: number }>) {
+    for (const [id, c] of counts) await this.run('UPDATE push_notifications SET ok=MAX(ok-?,0), failed=failed+?, removed=removed+? WHERE id=?', [c.failed, c.failed, c.removed, id]);
+  }
+  async listNotifications(limit = 50) { return (await this.all('SELECT * FROM push_notifications ORDER BY created_at DESC LIMIT ?', [limit])).map(notification); }
+  async getNotification(id: string) { const r = await this.all('SELECT * FROM push_notifications WHERE id=?', [id]); return r[0] ? notification(r[0]) : null; }
+
+  // ---- Expo tickets awaiting receipts ----
+  async addTickets(rows: { id: string; notificationId: string; deviceId: string }[], now: number) {
+    // D1 allows 100 bound parameters per statement: 4 per row
+    for (let i = 0; i < rows.length; i += 25) {
+      const chunk = rows.slice(i, i + 25);
+      await this.run(`INSERT OR IGNORE INTO push_tickets (id,notification_id,device_id,created_at) VALUES ${chunk.map(() => '(?,?,?,?)').join(',')}`,
+        chunk.flatMap((t) => [t.id, t.notificationId, t.deviceId, now]));
+    }
+  }
+  async dueTickets(before: number, limit: number) {
+    return (await this.all('SELECT * FROM push_tickets WHERE created_at<=? ORDER BY created_at LIMIT ?', [before, limit]))
+      .map((r) => ({ id: String(r.id), notificationId: String(r.notification_id), deviceId: String(r.device_id), createdAt: Number(r.created_at) }));
+  }
+  async deleteTickets(ids: string[]) {
+    for (let i = 0; i < ids.length; i += 90) {
+      const chunk = ids.slice(i, i + 90);
+      await this.run(`DELETE FROM push_tickets WHERE id IN (${chunk.map(() => '?').join(',')})`, chunk);
+    }
+  }
+
+  // ---- automatic notification queue ----
+  /** Claims up to `limit` pending rows (status → sending); rows queued before `staleBefore` are skipped instead. */
+  async claimPending(now: number, staleBefore: number, limit: number): Promise<PushQueueRow[]> {
+    await this.run(`UPDATE push_queue SET status='skipped', updated_at=? WHERE status='pending' AND created_at<?`, [now, staleBefore]);
+    const due = await this.all(`SELECT key FROM push_queue WHERE status='pending' ORDER BY created_at LIMIT ?`, [limit]);
+    const out: PushQueueRow[] = [];
+    for (const { key } of due) {
+      const r = await this.all(`UPDATE push_queue SET status='sending', updated_at=? WHERE key=? AND status='pending' RETURNING *`, [now, key]);
+      if (r[0]) out.push({ key: String(r[0].key), kind: r[0].kind as PushQueueRow['kind'], docId: String(r[0].doc_id), occurrence: r[0].occurrence == null ? null : Number(r[0].occurrence), status: 'sending', createdAt: Number(r[0].created_at) });
+    }
+    return out;
+  }
+  /** Inserts a new key as `sending`; false when it already exists (dedupe for "starting soon"). */
+  async claimKey(key: string, kind: PushQueueRow['kind'], docId: string, occurrence: number | null, now: number): Promise<boolean> {
+    const r = await this.all(`INSERT INTO push_queue (key,kind,doc_id,occurrence,status,notification_id,created_at,updated_at)
+      VALUES (?,?,?,?,'sending',NULL,?,?) ON CONFLICT(key) DO NOTHING RETURNING key`, [key, kind, docId, occurrence, now, now]);
+    return r.length > 0;
+  }
+  async markQueue(key: string, status: 'sent' | 'skipped' | 'failed', notificationId: string | null, now: number) {
+    await this.run('UPDATE push_queue SET status=?, notification_id=?, updated_at=? WHERE key=?', [status, notificationId, now, key]);
+  }
+  async skipPending(now: number) { await this.run(`UPDATE push_queue SET status='skipped', updated_at=? WHERE status='pending'`, [now]); }
+  async queueStatus(key: string) { return (await this.all('SELECT status FROM push_queue WHERE key=?', [key]))[0]?.status as string | undefined; }
+
+  // ---- retention ----
+  /** Devices not seen since `devicesBefore`, log rows older than a year, expired tickets and old occurrence keys. */
+  async purge(now: number, devicesBefore: number): Promise<number> {
+    const gone = await this.all('DELETE FROM push_devices WHERE last_seen_at<? RETURNING id', [devicesBefore]);
+    await (await this.driver()).batch([
+      { sql: 'DELETE FROM push_notifications WHERE created_at<?', args: [now - 365 * 86400000] },
+      { sql: 'DELETE FROM push_tickets WHERE created_at<?', args: [now - 86400000] },
+      { sql: `DELETE FROM push_queue WHERE kind='soon' AND updated_at<?`, args: [now - 30 * 86400000] },
+    ]);
+    return gone.length;
+  }
+}

package/src/lib/push/types.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+
+// '*' in a calendars list = every public event
+const keys = z.array(z.string().min(1).max(200)).max(100);
+export const PushAuto = z.object({
+  /** collection keys whose first publish sends a notification */
+  newPost: z.object({ collections: keys.default([]) }).default({}),
+  /** calendar ids (or '*') whose events notify on first publish */
+  newEvent: z.object({ calendars: keys.default([]) }).default({}),
+  /** "starting soon" reminders, sent `minutes` before each occurrence */
+  startingSoon: z.object({ calendars: keys.default([]), minutes: z.number().int().min(5).max(1440).default(30) }).default({}),
+});
+export type PushAuto = z.infer<typeof PushAuto>;
+export const PushSettings = z.object({ auto: PushAuto.default({}) });
+export type PushSettings = z.infer<typeof PushSettings>;
+
+export type PushPlatform = 'ios' | 'android';
+export interface PushDevice {
+  id: string; token: string; platform: PushPlatform; locale: string; topics: string[];
+  createdAt: number; updatedAt: number; lastSeenAt: number;
+}
+export type PushSource = 'manual' | 'post' | 'event' | 'soon';
+export interface PushNotification {
+  id: string; title: string; body: string; url: string;
+  /** ['*'] = everyone */
+  topics: string[];
+  source: PushSource; sourceKey: string;
+  status: 'sending' | 'sent' | 'failed';
+  recipients: number; sent: number; ok: number; failed: number;
+  /** devices removed because Expo said they are no longer registered */
+  removed: number;
+  error: string; author: string; createdAt: number; finishedAt: number | null;
+}
+export interface PushQueueRow { key: string; kind: 'post' | 'event' | 'soon'; docId: string; occurrence: number | null; status: string; createdAt: number }
+export interface PushTopic { id: string; label: string; kind: 'general' | 'collection' | 'calendar' }
+export interface PushStats {
+  devices: number;
+  platforms: Record<PushPlatform, number>;
+  /** devices per topic id */
+  topics: Record<string, number>;
+  /** devices whose app checked in during the last 30 days */
+  active30: number;
+}

package/src/lib/repo/migrations.ts

@@ -2,6 +2,8 @@ import { LIVE_MIGRATION } from '../live/migration';
 import { IMPORT_MIGRATION } from '../import/migration';
 import { EMAIL_MIGRATION } from '../email/migration';
 import { WEBHOOK_MIGRATION } from '../webhook-sql';
+import { PUSH_MIGRATION } from '../push/migration';
+import { EDITOR_MIGRATION, EDITOR_GRACE_MIGRATION } from '../editor/migration';
 // Versioned schema migrations shared by the two SQLite-dialect adapters
 // (D1 and libSQL). Applied versions are recorded in the `migrations` table;
 // each adapter's runner applies whatever is newer, in order, at startup.
@@ -501,6 +503,15 @@ export const MIGRATIONS: Migration[] = [
   WEBHOOK_MIGRATION,
   LIVE_MIGRATION,
   IMPORT_MIGRATION,
+  // translations: per-language words for posts, pages and events (facts stay shared)
+  { version: 36, statements: [
+    `ALTER TABLE posts ADD COLUMN translations TEXT NOT NULL DEFAULT '{}'`,
+    `ALTER TABLE pages ADD COLUMN translations TEXT NOT NULL DEFAULT '{}'`,
+    `ALTER TABLE events ADD COLUMN translations TEXT NOT NULL DEFAULT '{}'`,
+  ] },
+  PUSH_MIGRATION,
+  EDITOR_MIGRATION,
+  EDITOR_GRACE_MIGRATION,
 ];
 
 export const LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;

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),
@@ -138,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),
@@ -233,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; });
   }
 
@@ -466,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); }
@@ -598,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;
@@ -832,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];
@@ -1633,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],
@@ -1818,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 ?? '[]')),
@@ -1834,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));
@@ -1901,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,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'
     | '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>;
@@ -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

@@ -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 },
+  };
+}