@acms-subir/core 0.3.34 → 0.3.36

package/src/lib/push/service.ts

@@ -1,18 +1,21 @@
 // Push notifications: topics, audiences, the Expo sender pipeline, automatic
-// notices (first publish of a post/event, "starting soon", "we're live") and receipts.
+// notices (first publish of a post/event, "starting soon", "we're live", event
+// changes) and receipts.
 import type { ContentRepository } from '../repo/types';
 import type { CalEvent, Calendar, Post, Settings } from '../schema';
 import { CONTENT, collectionUrl } from '../content';
 import { CALENDAR, eventUrl } from '../calendar/config';
-import { eventIsListed, eventTimeZone, expandEvents } from '../calendar/events';
-import { I18N } from '../i18n';
+import { eventIsListed, eventTimeZone, expandEvents, findOccurrence, type Occurrence } from '../calendar/events';
+import { tzParts } from '../calendar/ics';
+import { I18N, stripLocale } from '../i18n';
 import { localizeDoc } from '../translations';
 import { localizedUrl } from '../mobile/locale';
 import { effectiveSnapshot } from '../live/service';
+import { ANNOUNCEMENTS } from '../announcements/config';
 import type { LiveSnapshot } from '../live/types';
 import { PUSH } from './config';
 import { expoOptions, fetchReceipts, isGone, sendMessages, type ExpoMessage, type ExpoOptions } from './expo';
-import type { PushNotification, PushSource, PushTopic } from './types';
+import { EventSnapshot, type PushAuto, type PushNotification, type PushSource, type PushTopic } from './types';
 
 const MINUTE = 60_000, HOUR = 60 * MINUTE, DAY = 24 * HOUR;
 /** automatic notices queued longer ago than this are skipped, never sent late */
@@ -22,13 +25,14 @@ export const RECEIPT_DELAY = 15 * MINUTE;
 
 // ---- topics ------------------------------------------------------------------
 
-// names of the built-in topics; other languages show English
-const TOPIC_WORDS: Record<string, { news: string; events: string; live: string }> = {
-  en: { news: 'News', events: 'Events', live: 'Live video' },
-  es: { news: 'Noticias', events: 'Eventos', live: 'Video en vivo' },
-  fr: { news: 'Actualités', events: 'Événements', live: 'Vidéo en direct' },
-  de: { news: 'Neuigkeiten', events: 'Veranstaltungen', live: 'Live-Video' },
-  pt: { news: 'Notícias', events: 'Eventos', live: 'Vídeo ao vivo' },
+// names of the built-in topics; other languages show English. `eventsChanges`
+// names `events` while event-change notices go to it.
+const TOPIC_WORDS: Record<string, { news: string; events: string; eventsChanges: string; live: string }> = {
+  en: { news: 'News', events: 'Events', eventsChanges: 'Events and changes', live: 'Live video' },
+  es: { news: 'Noticias', events: 'Eventos', eventsChanges: 'Eventos y cambios', live: 'Video en vivo' },
+  fr: { news: 'Actualités', events: 'Événements', eventsChanges: 'Événements et changements', live: 'Vidéo en direct' },
+  de: { news: 'Neuigkeiten', events: 'Veranstaltungen', eventsChanges: 'Veranstaltungen und Änderungen', live: 'Live-Video' },
+  pt: { news: 'Notícias', events: 'Eventos', eventsChanges: 'Eventos e mudanças', live: 'Vídeo ao vivo' },
 };
 /** A site topic's words in a language: exact code, its base ("es-MX" → "es"), every language ('*'), the site's main language, then any. */
 export function topicWords(words: Record<string, string>, locale: string): string {
@@ -46,17 +50,20 @@ export function topicWords(words: Record<string, string>, locale: string): strin
  * first registration) choose: a new topic never reaches existing devices on its own.
  */
 export async function pushTopics(repo: ContentRepository, locale?: string | null): Promise<PushTopic[]> {
-  const lang = locale || I18N.defaultLocale || (await repo.getSettings()).locale || 'en';
+  const settings = await repo.getSettings();
+  const lang = locale || I18N.defaultLocale || settings.locale || 'en';
   const w = TOPIC_WORDS[lang.toLowerCase().split('-')[0]] ?? TOPIC_WORDS.en;
   const collections = Object.entries(CONTENT.collections);
   const out: PushTopic[] = [{ id: 'news', label: w.news, kind: 'general' }];
   if (collections.length > 1) out.push(...collections.map(([key, c]): PushTopic => ({ id: `collection:${key}`, label: c.plural, kind: 'collection' })));
   if (CALENDAR.enabled) {
-    out.push({ id: 'events', label: w.events, kind: 'general' });
+    const changes = settings.push.auto.eventChanges;
+    // event-change notices go to `events` unless their rule names other topics
+    out.push({ id: 'events', label: changes.calendars.length && !changes.topics.length ? w.eventsChanges : w.events, kind: 'general' });
     const calendars = (await repo.listCalendars()).filter((c) => c.visibility === 'public');
     if (calendars.length > 1) out.push(...calendars.map((c): PushTopic => ({ id: `calendar:${c.slug}`, label: c.name, kind: 'calendar' })));
   }
-  if ((await repo.getSettings()).live.mode !== 'off') out.push({ id: 'live', label: w.live, kind: 'general' });
+  if (settings.live.mode !== 'off') out.push({ id: 'live', label: w.live, kind: 'general' });
   for (const t of PUSH.topics) {
     const description = topicWords(t.description, lang);
     out.push({ id: t.id, label: topicWords(t.label, lang), kind: 'site', ...(description ? { description } : {}) });
@@ -84,12 +91,28 @@ export function deviceLocale(raw: string): string | null {
   return match && match !== I18N.defaultLocale ? match : null;
 }
 
-const STRINGS: Record<string, { startsIn: (m: number) => string; now: string; live: string }> = {
-  en: { startsIn: (m) => `Starts in ${m} min`, now: 'Starting now', live: 'We’re live' },
-  es: { startsIn: (m) => `Empieza en ${m} min`, now: 'Empieza ahora', live: 'Estamos en vivo' },
-  fr: { startsIn: (m) => `Commence dans ${m} min`, now: 'Commence maintenant', live: 'Nous sommes en direct' },
-  de: { startsIn: (m) => `Beginnt in ${m} Min.`, now: 'Beginnt jetzt', live: 'Wir sind live' },
-  pt: { startsIn: (m) => `Começa em ${m} min`, now: 'Começa agora', live: 'Estamos ao vivo' },
+interface Words {
+  startsIn: (m: number) => string; now: string; live: string;
+  // event changes: dates come formatted, `more` ends a list of cancelled dates
+  moved: (to: string, was: string) => string; movedTo: (to: string, place: string) => string; place: (p: string) => string;
+  cancelled: (d: string) => string; cancelledFrom: (d: string) => string; cancelledOn: (d: string) => string; more: (n: number) => string;
+}
+const STRINGS: Record<string, Words> = {
+  en: { startsIn: (m) => `Starts in ${m} min`, now: 'Starting now', live: 'We’re live',
+    moved: (to, was) => `Now ${to} (was ${was})`, movedTo: (to, p) => `Now ${to} · ${p}`, place: (p) => `New place: ${p}`,
+    cancelled: (d) => `Cancelled: ${d}`, cancelledFrom: (d) => `Cancelled: every date from ${d}`, cancelledOn: (d) => `Cancelled on ${d}`, more: (n) => `${n} more` },
+  es: { startsIn: (m) => `Empieza en ${m} min`, now: 'Empieza ahora', live: 'Estamos en vivo',
+    moved: (to, was) => `Ahora ${to} (antes ${was})`, movedTo: (to, p) => `Ahora ${to} · ${p}`, place: (p) => `Nuevo lugar: ${p}`,
+    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas las fechas desde el ${d}`, cancelledOn: (d) => `Cancelado el ${d}`, more: (n) => `${n} más` },
+  fr: { startsIn: (m) => `Commence dans ${m} min`, now: 'Commence maintenant', live: 'Nous sommes en direct',
+    moved: (to, was) => `Désormais ${to} (au lieu de ${was})`, movedTo: (to, p) => `Désormais ${to} · ${p}`, place: (p) => `Nouveau lieu : ${p}`,
+    cancelled: (d) => `Annulé : ${d}`, cancelledFrom: (d) => `Annulé : toutes les dates à partir du ${d}`, cancelledOn: (d) => `Annulé le ${d}`, more: (n) => `${n} autres` },
+  de: { startsIn: (m) => `Beginnt in ${m} Min.`, now: 'Beginnt jetzt', live: 'Wir sind live',
+    moved: (to, was) => `Jetzt ${to} (statt ${was})`, movedTo: (to, p) => `Jetzt ${to} · ${p}`, place: (p) => `Neuer Ort: ${p}`,
+    cancelled: (d) => `Abgesagt: ${d}`, cancelledFrom: (d) => `Abgesagt: alle Termine ab ${d}`, cancelledOn: (d) => `Abgesagt am ${d}`, more: (n) => `${n} weitere` },
+  pt: { startsIn: (m) => `Começa em ${m} min`, now: 'Começa agora', live: 'Estamos ao vivo',
+    moved: (to, was) => `Agora ${to} (antes ${was})`, movedTo: (to, p) => `Agora ${to} · ${p}`, place: (p) => `Novo local: ${p}`,
+    cancelled: (d) => `Cancelado: ${d}`, cancelledFrom: (d) => `Cancelado: todas as datas a partir de ${d}`, cancelledOn: (d) => `Cancelado em ${d}`, more: (n) => `mais ${n}` },
 };
 export const pushStrings = (locale: string) => STRINGS[locale.split('-')[0]] ?? STRINGS.en;
 
@@ -97,8 +120,8 @@ const clip = (s: string, n: number) => {
   const t = s.replace(/\s+/g, ' ').trim();
   return t.length > n ? `${t.slice(0, n - 1).trimEnd()}…` : t;
 };
-function when(start: number, allDay: boolean, tz: string, locale: string, timeOnly = false) {
-  const opts: Intl.DateTimeFormatOptions = timeOnly ? { hour: 'numeric', minute: '2-digit' }
+function when(start: number, allDay: boolean, tz: string, locale: string, only?: 'time' | 'monthDay') {
+  const opts: Intl.DateTimeFormatOptions = only === 'time' ? { hour: 'numeric', minute: '2-digit' } : only === 'monthDay' ? { month: 'short', day: 'numeric' }
     : allDay ? { weekday: 'short', month: 'short', day: 'numeric' } : { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit' };
   try { return new Intl.DateTimeFormat(locale, { ...opts, timeZone: tz }).format(start); }
   catch { return new Date(start).toISOString().slice(0, 16).replace('T', ' '); }
@@ -201,6 +224,11 @@ export async function sendNotification(repo: ContentRepository, input: SendInput
 
 const listedCalendars = (calendars: Calendar[]) => new Map(calendars.map((c) => [c.id, c]));
 const inRule = (rule: string[], e: CalEvent) => rule.includes('*') || e.calendarIds.some((id) => rule.includes(id));
+// the change rule: its calendars, and one of its tags when it lists some (any case)
+function inChangeRule(rule: PushAuto['eventChanges'], e: CalEvent) {
+  const tags = new Set(rule.tags.map((t) => t.toLowerCase()));
+  return inRule(rule.calendars, e) && (!tags.size || e.tags.some((t) => tags.has(t.toLowerCase())));
+}
 function eventTopics(e: CalEvent, calendars: Map<string, Calendar>) {
   return ['events', ...e.calendarIds.map((id) => calendars.get(id)).filter((c): c is Calendar => c?.visibility === 'public').map((c) => `calendar:${c.slug}`)];
 }
@@ -224,7 +252,7 @@ export function eventNotice(e: CalEvent, settings: Settings, calendars: Map<stri
     if (soon) {
       const s = pushStrings(locale);
       const mins = Math.max(0, Math.round((soon.start - now) / MINUTE));
-      body = `${mins <= 1 ? s.now : s.startsIn(mins)} · ${when(soon.start, false, tz, locale, true)}${place}`;
+      body = `${mins <= 1 ? s.now : s.startsIn(mins)} · ${when(soon.start, false, tz, locale, 'time')}${place}`;
     } else body = `${when(next.start, next.allDay, tz, locale)}${place}`;
     return { title: clip(ev.title, 120), body: clip(body, 240), url: eventUrl(ev.slug) };
   };
@@ -234,7 +262,159 @@ export function eventNotice(e: CalEvent, settings: Settings, calendars: Map<stri
     localize: (l) => words(localizeDoc(e, l), l) };
 }
 
-/** Sends (or skips) queued first-publish notices. Returns how many were sent. */
+// ---- event changes ---------------------------------------------------------------
+
+/** Edits wait this long after the last one, so a quick fix sends one notice (or none)… */
+export const CHANGE_QUIET = 10 * MINUTE;
+/** …but only this long when the date they touch starts within CHANGE_SOON. */
+export const CHANGE_QUIET_SOON = MINUTE;
+export const CHANGE_SOON = 3 * HOUR;
+
+/** The public fields a change notice compares (staged edits live in `draft` and don't count until applied). */
+export function eventSnapshot(e: CalEvent): EventSnapshot {
+  return { start: e.start, end: e.end, allDay: e.allDay, timezone: e.timezone, rrule: e.rrule, exdates: [...e.exdates].sort(),
+    cancelled: e.cancelled, cancelledDates: [...e.cancelledDates].sort(), location: { name: e.location.name.trim(), address: e.location.address.trim() } };
+}
+function readSnapshot(raw: string | null): EventSnapshot | null {
+  try { const r = EventSnapshot.safeParse(JSON.parse(raw ?? '')); return r.success ? r.data : null; } catch { return null; }
+}
+
+interface Slot { start: number; allDay: boolean }
+export interface EventChange {
+  /** the next date (or its time) moved */
+  moved?: { from: Slot; to: Slot };
+  /** a new place name or address */
+  place?: { from: EventSnapshot['location']; to: EventSnapshot['location'] };
+  /** the whole event was cancelled: its next date */
+  cancelled?: Slot;
+  /** single dates of a repeating event newly cancelled, soonest first */
+  cancelledDates?: Slot[];
+  /** when the soonest date it touches starts (a move: the old or the new time, whichever is sooner) */
+  at: number;
+}
+
+// the next occurrence that hasn't ended and the next that hasn't started
+// (cancelled ones count: cancelling a date isn't a move)
+function slots(e: CalEvent, settings: Pick<Settings, 'timezone'>, now: number): { next: Slot | null; upcoming: Slot | null } {
+  const all = expandEvents([e], settings, { displayTz: settings.timezone || 'UTC', now, windowStartMs: now, windowEndMs: now + 400 * DAY });
+  const slot = (o: Occurrence | undefined) => (o ? { start: o.start, allDay: o.allDay } : null);
+  return { next: slot(all[0]), upcoming: slot(all.find((o) => o.start > now)) };
+}
+
+/**
+ * What people following an event should hear, from what they last knew (`was`)
+ * to the event now: its next date or time moved, a new place, the whole event
+ * cancelled, or single dates cancelled. Null when nothing counts: other fields,
+ * series edits that leave the next date alone, restored dates, un-cancelling,
+ * or it's too late (what it touches has started, or nothing is left to come).
+ */
+export function eventChange(was: EventSnapshot, e: CalEvent, settings: Pick<Settings, 'timezone'>, now: number): EventChange | null {
+  if (was.cancelled) return null;
+  const { upcoming } = slots(e, settings, now);
+  if (!upcoming) return null;
+  if (e.cancelled) return { cancelled: upcoming, at: upcoming.start };
+  const then: CalEvent = { ...e, start: was.start, end: was.end, allDay: was.allDay, timezone: was.timezone, rrule: was.rrule, exdates: was.exdates, cancelledDates: was.cancelledDates };
+  // a date taken out of the series (dragged to its own event) or put back isn't a move
+  const exdates = [...new Set([...was.exdates, ...e.exdates])];
+  const from = slots({ ...then, exdates }, settings, now).next;
+  if (!from) return null;
+  const to = slots({ ...e, exdates }, settings, now).next;
+  const out: Omit<EventChange, 'at'> = {};
+  const starts: number[] = [];
+  // a move matters until the new time starts, even when the old one has passed
+  if (to && to.start > now && (to.start !== from.start || to.allDay !== from.allDay)) { out.moved = { from, to }; starts.push(from.start, to.start); }
+  const place = { name: e.location.name.trim(), address: e.location.address.trim() };
+  if ((place.name || place.address) && (place.name !== was.location.name || place.address !== was.location.address)) {
+    out.place = { from: was.location, to: place };
+    starts.push(upcoming.start);
+  }
+  // only dates people knew as on: one that was already cancelled and moved with its series isn't news
+  const dates = e.cancelledDates.filter((k) => !was.cancelledDates.includes(k) && findOccurrence(then, k, settings)).map((k) => findOccurrence(e, k, settings))
+    .filter((o): o is Occurrence => o !== null && o.start > now).sort((a, b) => a.start - b.start);
+  if (dates.length) {
+    out.cancelledDates = dates.map((o) => ({ start: o.start, allDay: o.allDay }));
+    starts.push(dates[0].start);
+  }
+  return starts.length ? { ...out, at: Math.min(...starts) } : null;
+}
+
+/** Called by eventChanged on every path: queues (or postpones) a change notice when a published event's schedule or place differs. */
+export async function queueEventChange(repo: ContentRepository, before: CalEvent, after: CalEvent, now = Date.now()): Promise<boolean> {
+  // publishing is the "new event" notice; unpublishing says nothing
+  if (!PUSH.enabled || !CALENDAR.enabled || before.status !== 'published' || after.status !== 'published') return false;
+  const was = eventSnapshot(before);
+  if (JSON.stringify(was) === JSON.stringify(eventSnapshot(after))) return false;
+  const [settings, all] = await Promise.all([repo.getSettings(), repo.listCalendars()]);
+  if (!inChangeRule(settings.push.auto.eventChanges, after) || !eventIsListed(after, listedCalendars(all))) return false;
+  const key = `change:${after.id}`;
+  // a change to a date that starts soon waits only a minute (judged from what people last knew)
+  const row = await repo.push.queuedChange(key);
+  const change = eventChange((row?.status === 'pending' && readSnapshot(row.payload)) || was, after, settings, now);
+  const quiet = change && change.at - now < CHANGE_SOON ? CHANGE_QUIET_SOON : CHANGE_QUIET;
+  await repo.push.queueChange(key, after.id, JSON.stringify(was), now, now + quiet);
+  return true;
+}
+
+/** The site path a link opens, without the origin, a non-default locale prefix, query or hash ('' = another site). */
+export function sitePath(link: string, origin: string): string {
+  try {
+    const u = new URL(link, origin || 'https://site.invalid');
+    if (origin && u.origin !== new URL(origin).origin) return '';
+    return stripLocale(u.pathname.replace(/(.)\/+$/, '$1'));
+  } catch { return ''; }
+}
+
+// an announcement pushed in the last hour whose button opens this event already told people
+async function announcedLately(repo: ContentRepository, e: CalEvent, origin: string, now: number): Promise<boolean> {
+  if (!ANNOUNCEMENTS.enabled) return false;
+  const page = eventUrl(e.slug);
+  return (await repo.announcements.pushedSince(now - HOUR)).some((a) => a.link !== '' && sitePath(a.link, origin) === page);
+}
+
+/** `topics`: the rule's own audience; [] = the event's topics. */
+export function eventChangeNotice(e: CalEvent, change: EventChange, settings: Settings, calendars: Map<string, Calendar>, topics: string[] = []): SendInput {
+  const tz = eventTimeZone(e, settings);
+  const siteTz = settings.timezone || 'UTC';
+  // all-day dates start at midnight in the site's zone (how they were expanded)
+  const zone = (x: Slot) => (x.allDay ? siteTz : tz);
+  const dates = change.cancelledDates ?? [];
+  const kind = change.cancelled ? 'cancelled' : change.moved ? 'moved' : change.place ? 'place' : 'dateCancelled';
+  // one cancelled date opens that date (?on= is its day in the site's zone, like calendar links)
+  let on = '';
+  if (kind === 'dateCancelled' && dates.length === 1) {
+    const p = tzParts(dates[0].start, siteTz);
+    on = `?on=${p.y}-${String(p.m).padStart(2, '0')}-${String(p.d).padStart(2, '0')}`;
+  }
+  const words = (ev: CalEvent, locale: string): Composed => {
+    const s = pushStrings(locale);
+    const at = (x: Slot) => when(x.start, x.allDay, zone(x), locale);
+    const day = (x: Slot) => when(x.start, true, zone(x), locale);
+    const parts: string[] = [];
+    if (change.cancelled) parts.push(ev.rrule ? s.cancelledFrom(day(change.cancelled)) : s.cancelled(at(change.cancelled)));
+    else {
+      const loc = { name: ev.location.name.trim(), address: ev.location.address.trim() };
+      // a new name is enough; the same name at a new address needs both
+      const place = !change.place ? '' : change.place.to.name !== change.place.from.name ? loc.name || loc.address : [loc.name, loc.address].filter(Boolean).join(', ');
+      if (change.moved) {
+        const { from, to } = change.moved;
+        const sameDay = !from.allDay && !to.allDay && day(from) === day(to);
+        parts.push(place ? s.movedTo(at(to), place) : s.moved(at(to), sameDay ? when(from.start, false, zone(from), locale, 'time') : at(from)));
+      } else if (place) parts.push(s.place(place));
+      if (dates.length) {
+        const list = dates.length === 1 ? [day(dates[0])] : dates.slice(0, 3).map((x) => when(x.start, true, zone(x), locale, 'monthDay'));
+        if (dates.length > 3) list.push(s.more(dates.length - 3));
+        let joined: string;
+        try { joined = new Intl.ListFormat(locale, { type: 'conjunction' }).format(list); } catch { joined = list.join(', '); }
+        parts.push(s.cancelledOn(joined));
+      }
+    }
+    return { title: clip(ev.title, 120), body: clip(parts.join(' · '), 240), url: `${eventUrl(ev.slug)}${on}` };
+  };
+  return { ...words(e, displayLocale(settings)), audience: topics.length ? topics : eventTopics(e, calendars), source: 'change', sourceKey: `change:${e.id}`,
+    data: { kind: 'event', id: e.id, slug: e.slug, change: kind }, localize: (l) => words(localizeDoc(e, l), l) };
+}
+
+/** Sends (or skips) queued first-publish and event-change notices. Returns how many were sent. */
 export async function processPushQueue(repo: ContentRepository, opts: PushRunOptions = {}): Promise<number> {
   const now = opts.now ?? Date.now();
   if (!PUSH.enabled) { await repo.push.skipPending(now); return 0; }
@@ -254,6 +434,13 @@ export async function processPushQueue(repo: ContentRepository, opts: PushRunOpt
       } else if (row.kind === 'event' && CALENDAR.enabled) {
         const e = await repo.getEvent(row.docId);
         if (e && !e.cancelled && eventIsListed(e, calendars) && inRule(auto.newEvent.calendars, e)) notice = eventNotice(e, settings, calendars, now);
+      } else if (row.kind === 'change' && CALENDAR.enabled) {
+        // compared at send time: edits that cancel out, or come too late, send nothing
+        const e = await repo.getEvent(row.docId);
+        const was = readSnapshot(row.payload);
+        const rule = auto.eventChanges;
+        const change = e && was && eventIsListed(e, calendars) && inChangeRule(rule, e) ? eventChange(was, e, settings, now) : null;
+        if (e && change && !(await announcedLately(repo, e, run.origin, now))) notice = eventChangeNotice(e, change, settings, calendars, rule.topics);
       }
       if (!notice) { await repo.push.markQueue(row.key, 'skipped', null, now); continue; }
       const n = await sendNotification(repo, notice, run);

package/src/lib/push/store.ts

@@ -96,6 +96,10 @@ export class PushStore {
   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]);
   }
+  /** Notifications from one source that went out since `since`, newest first. */
+  async sentSince(source: PushNotification['source'], since: number) {
+    return (await this.all(`SELECT * FROM push_notifications WHERE source=? AND created_at>=? AND status!='failed' ORDER BY created_at DESC LIMIT 100`, [source, since])).map(notification);
+  }
   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; }
 
@@ -120,17 +124,39 @@ export class PushStore {
   }
 
   // ---- automatic notification queue ----
-  /** Claims up to `limit` pending rows (status → sending); rows queued before `staleBefore` are skipped instead. */
+  /**
+   * Claims up to `limit` due pending rows (status → sending); rows queued before
+   * `staleBefore` are skipped instead. A row with `due_at` waits until then and
+   * goes stale from then, so an event still being edited never counts as late.
+   */
   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]);
+    await this.run(`UPDATE push_queue SET status='skipped', updated_at=? WHERE status='pending' AND COALESCE(due_at,created_at)<?`, [now, staleBefore]);
+    const due = await this.all(`SELECT key FROM push_queue WHERE status='pending' AND (due_at IS NULL OR due_at<=?) ORDER BY created_at LIMIT ?`, [now, 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) });
+      const r = await this.all(`UPDATE push_queue SET status='sending', updated_at=? WHERE key=? AND status='pending' AND (due_at IS NULL OR due_at<=?) RETURNING *`, [now, key, now]);
+      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), payload: r[0].payload == null ? null : String(r[0].payload), dueAt: r[0].due_at == null ? null : Number(r[0].due_at) });
     }
     return out;
   }
+  /**
+   * Debounces an event's change notice (key change:<id>) in one statement, so
+   * concurrent saves can't lose an edit: a pending row keeps its snapshot (what
+   * people last knew) and waits until `dueAt` again; any other row (sent,
+   * skipped, failed, or being sent) starts over with this snapshot.
+   */
+  async queueChange(key: string, docId: string, payload: string, now: number, dueAt: number) {
+    await this.run(`INSERT INTO push_queue (key,kind,doc_id,occurrence,status,notification_id,created_at,updated_at,payload,due_at)
+      VALUES (?,'change',?,NULL,'pending',NULL,?,?,?,?) ON CONFLICT(key) DO UPDATE SET
+      payload=CASE WHEN push_queue.status='pending' THEN push_queue.payload ELSE excluded.payload END,
+      created_at=CASE WHEN push_queue.status='pending' THEN push_queue.created_at ELSE excluded.created_at END,
+      status='pending', notification_id=NULL, due_at=excluded.due_at, updated_at=excluded.updated_at`, [key, docId, now, now, payload, dueAt]);
+  }
+  async queuedChange(key: string): Promise<{ status: string; payload: string | null } | null> {
+    const r = (await this.all('SELECT status, payload FROM push_queue WHERE key=?', [key]))[0];
+    return r ? { status: String(r.status), payload: r.payload == null ? null : String(r.payload) } : null;
+  }
   /** 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)
@@ -138,7 +164,8 @@ export class PushStore {
     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]);
+    // a change row an edit queued again while it was sending stays pending
+    await this.run(`UPDATE push_queue SET status=?, notification_id=?, updated_at=? WHERE key=? AND (kind!='change' OR status='sending')`, [status, notificationId, now, key]);
   }
   async skipPending(now: number) { await this.run(`UPDATE push_queue SET status='skipped', updated_at=? WHERE status='pending'`, [now]); }
   /** When a notice of this kind last went out (0 = never). */
@@ -148,13 +175,13 @@ export class PushStore {
   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 and broadcast keys. */
+  /** Devices not seen since `devicesBefore`, log rows older than a year, expired tickets, and old occurrence, broadcast and change 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 IN ('soon','live') AND updated_at<?`, args: [now - 30 * 86400000] },
+      { sql: `DELETE FROM push_queue WHERE kind IN ('soon','live','change') AND updated_at<?`, args: [now - 30 * 86400000] },
     ]);
     return gone.length;
   }

package/src/lib/push/types.ts

@@ -11,11 +11,26 @@ export const PushAuto = z.object({
   startingSoon: z.object({ calendars: keys.default([]), minutes: z.number().int().min(5).max(1440).default(30) }).default({}),
   /** "We're live": once per broadcast that live video detects, to devices on the `live` topic */
   live: z.object({ enabled: z.boolean().default(false) }).default({}),
+  /** a published event's new date, time or place, or a cancellation, once its edits settle */
+  eventChanges: z.object({
+    calendars: keys.default([]),
+    /** only events with one of these tags (any case); [] = every event in the calendars */
+    tags: z.array(z.string().trim().min(1).max(100)).max(20).default([]),
+    /** sent to these topics instead of the event's own (`events` and its calendars) */
+    topics: z.array(z.string().min(1).max(200)).max(10).default([]),
+  }).default({}),
 });
 export type PushAuto = z.infer<typeof PushAuto>;
 export const PushSettings = z.object({ auto: PushAuto.default({}) });
 export type PushSettings = z.infer<typeof PushSettings>;
 
+/** An event's public schedule and place, as people last knew it (the payload of a queued change notice) */
+export const EventSnapshot = z.object({
+  start: z.string(), end: z.string(), allDay: z.boolean(), timezone: z.string(), rrule: z.string(), exdates: z.array(z.string()),
+  cancelled: z.boolean(), cancelledDates: z.array(z.string()), location: z.object({ name: z.string(), address: z.string() }),
+});
+export type EventSnapshot = z.infer<typeof EventSnapshot>;
+
 export type PushPlatform = 'ios' | 'android';
 export interface PushDevice {
   id: string; token: string; platform: PushPlatform; locale: string; topics: string[];
@@ -23,7 +38,7 @@ export interface PushDevice {
   channels: string[];
   createdAt: number; updatedAt: number; lastSeenAt: number;
 }
-export type PushSource = 'manual' | 'post' | 'event' | 'soon' | 'live' | 'announcement';
+export type PushSource = 'manual' | 'post' | 'event' | 'soon' | 'live' | 'announcement' | 'change';
 export interface PushNotification {
   id: string; title: string; body: string; url: string;
   /** ['*'] = everyone */
@@ -35,7 +50,13 @@ export interface PushNotification {
   removed: number;
   error: string; author: string; createdAt: number; finishedAt: number | null;
 }
-export interface PushQueueRow { key: string; kind: 'post' | 'event' | 'soon' | 'live' | 'announcement'; docId: string; occurrence: number | null; status: string; createdAt: number }
+export interface PushQueueRow {
+  key: string; kind: 'post' | 'event' | 'soon' | 'live' | 'announcement' | 'change'; docId: string; occurrence: number | null; status: string; createdAt: number;
+  /** change rows: the EventSnapshot JSON from before the first edit */
+  payload: string | null;
+  /** change rows: not sent before this (null = as soon as possible) */
+  dueAt: number | null;
+}
 export interface PushTopic { id: string; label: string; kind: 'general' | 'collection' | 'calendar' | 'site'; description?: string }
 export interface PushStats {
   devices: number;

package/src/lib/repo/migrations.ts

@@ -679,6 +679,12 @@ export const MIGRATIONS: Migration[] = [
   ] },
   // announcements show on public pages, the banner and the app API
   { version: 58, statements: [...ANNOUNCEMENT_TABLE, ...contentVersionTriggers('announcements', ANNOUNCEMENT_VISIBLE_COLUMNS)] },
+  // event-change notices (PushAuto.eventChanges) wait in push_queue until the
+  // edits settle: payload = the schedule people last knew, due_at = send time
+  { version: 59, statements: [
+    `ALTER TABLE push_queue ADD COLUMN payload TEXT`,
+    `ALTER TABLE push_queue ADD COLUMN due_at INTEGER`,
+  ] },
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.

package/src/lib/schema.ts

@@ -672,7 +672,8 @@ export const Booking = z.object({
   formResponse: FormResponse.optional(),
   notes: z.string().default(''), // staff-only
   manageToken: z.string().default(''),
-  source: z.enum(['web', 'admin', 'api', 'agent']).default('web'),
+  // web: the website; app: the public app API (/api/v1/bookings)
+  source: z.enum(['web', 'app', 'admin', 'api', 'agent']).default('web'),
   reminderSentAt: z.number().nullable().default(null),
   notificationVersion: z.number().default(0),
   createdAt: z.number(),

package/src/lib/search-i18n.ts

@@ -1,7 +1,5 @@
-// UI strings for the search modal and /search page. There is no site-wide
-// translation catalog yet — search is the first public surface with
-// per-locale chrome, so the dict lives here until one exists. Locales fall
-// back to English.
+// UI strings for the search modal and /search page, in the same languages as
+// the rest of the layout (site-words.ts). Locales fall back to English.
 export interface SearchStrings {
   label: string;
   placeholder: string;
@@ -43,6 +41,45 @@ const STRINGS: Record<string, SearchStrings> = {
     results: 'resultados',
     button: 'Buscar',
   },
+  fr: {
+    label: 'Rechercher',
+    placeholder: 'Rechercher des articles, pages, étiquettes et auteurs',
+    posts: 'Articles',
+    pages: 'Pages',
+    events: 'Événements',
+    tags: 'Étiquettes',
+    authors: 'Auteurs',
+    empty: 'Aucun résultat pour',
+    result: 'résultat',
+    results: 'résultats',
+    button: 'Rechercher',
+  },
+  de: {
+    label: 'Suchen',
+    placeholder: 'Beiträge, Seiten, Schlagwörter und Autoren durchsuchen',
+    posts: 'Beiträge',
+    pages: 'Seiten',
+    events: 'Veranstaltungen',
+    tags: 'Schlagwörter',
+    authors: 'Autoren',
+    empty: 'Nichts gefunden für',
+    result: 'Ergebnis',
+    results: 'Ergebnisse',
+    button: 'Suchen',
+  },
+  pt: {
+    label: 'Buscar',
+    placeholder: 'Busque posts, páginas, tags e autores',
+    posts: 'Posts',
+    pages: 'Páginas',
+    events: 'Eventos',
+    tags: 'Tags',
+    authors: 'Autores',
+    empty: 'Nada encontrado para',
+    result: 'resultado',
+    results: 'resultados',
+    button: 'Buscar',
+  },
 };
 
 export const searchStrings = (locale: string): SearchStrings => STRINGS[locale] ?? STRINGS.en;

package/src/lib/site-chrome.ts

@@ -8,6 +8,12 @@
 //   [data-scheme-toggle] flips light/dark (when site.schemeToggle is true)
 //   [data-menu-open]     opens the phone menu sheet (built from site.links)
 //   [data-live-header]   (hidden) becomes the "Live" link during a stream
+//
+// `words` are core's own labels in the page's language (skip link, menu and
+// dark-mode buttons, landmark and footer labels), so a custom header labels
+// its controls the same way the built-in one does.
+import type { SiteStrings } from './site-words';
+
 export interface ChromeLink {
   label: string;
   url: string;
@@ -32,4 +38,6 @@ export interface SiteChrome {
   liveHeader: boolean;
   headerStyle: string; // theme token `header`
   footerStyle: string; // theme token `footer`
+  lang: string; // the page's language, as on <html lang>
+  words: SiteStrings;
 }

package/src/lib/site-words.ts

@@ -0,0 +1,62 @@
+// Words the public layout (Site.astro) shows around every page: the skip
+// link, header and phone-menu controls, the footer's built-in columns and
+// links. Owner-written labels (menus, collections) keep their own words;
+// search, announcements and live video have their own lists. Other languages
+// fall back to English.
+export interface SiteStrings {
+  skip: string;
+  /** landmark labels */
+  main: string;
+  menu: string;
+  language: string;
+  social: string;
+  openMenu: string;
+  closeMenu: string;
+  /** the light/dark button */
+  scheme: string;
+  /** footer column headings (columns footer) */
+  read: string;
+  site: string;
+  /** built-in legal links, added when the site has no menu item for them */
+  privacy: string;
+  terms: string;
+  /** the header's automatic list, when there's no header menu */
+  home: string;
+  links: string;
+  /** code block copy button */
+  copy: string;
+  copied: string;
+  /** gallery lightbox */
+  close: string;
+}
+
+const STRINGS: Record<string, SiteStrings> = {
+  en: {
+    skip: 'Skip to content', main: 'Main', menu: 'Menu', language: 'Language', social: 'Social', openMenu: 'Open menu', closeMenu: 'Close menu',
+    scheme: 'Toggle dark mode', read: 'Read', site: 'Site', privacy: 'Privacy', terms: 'Terms', home: 'Home', links: 'Links',
+    copy: 'Copy', copied: 'Copied', close: 'Close',
+  },
+  es: {
+    skip: 'Saltar al contenido', main: 'Principal', menu: 'Menú', language: 'Idioma', social: 'Redes sociales', openMenu: 'Abrir menú', closeMenu: 'Cerrar menú',
+    scheme: 'Cambiar entre modo claro y oscuro', read: 'Leer', site: 'Sitio', privacy: 'Privacidad', terms: 'Términos', home: 'Inicio', links: 'Enlaces',
+    copy: 'Copiar', copied: 'Copiado', close: 'Cerrar',
+  },
+  fr: {
+    skip: 'Aller au contenu', main: 'Principal', menu: 'Menu', language: 'Langue', social: 'Réseaux sociaux', openMenu: 'Ouvrir le menu', closeMenu: 'Fermer le menu',
+    scheme: 'Basculer entre mode clair et sombre', read: 'Lire', site: 'Site', privacy: 'Confidentialité', terms: 'Conditions', home: 'Accueil', links: 'Liens',
+    copy: 'Copier', copied: 'Copié', close: 'Fermer',
+  },
+  de: {
+    skip: 'Zum Inhalt springen', main: 'Hauptmenü', menu: 'Menü', language: 'Sprache', social: 'Soziale Medien', openMenu: 'Menü öffnen', closeMenu: 'Menü schließen',
+    scheme: 'Hell- und Dunkelmodus umschalten', read: 'Lesen', site: 'Website', privacy: 'Datenschutz', terms: 'Nutzungsbedingungen', home: 'Startseite', links: 'Links',
+    copy: 'Kopieren', copied: 'Kopiert', close: 'Schließen',
+  },
+  pt: {
+    skip: 'Pular para o conteúdo', main: 'Principal', menu: 'Menu', language: 'Idioma', social: 'Redes sociais', openMenu: 'Abrir menu', closeMenu: 'Fechar menu',
+    scheme: 'Alternar entre modo claro e escuro', read: 'Ler', site: 'Site', privacy: 'Privacidade', terms: 'Termos', home: 'Início', links: 'Links',
+    copy: 'Copiar', copied: 'Copiado', close: 'Fechar',
+  },
+};
+
+export const siteStrings = (locale: string | null | undefined): SiteStrings =>
+  STRINGS[(locale || 'en').toLowerCase().split('-')[0]] ?? STRINGS.en;