@acms-subir/core 0.3.34 → 0.3.35

package/src/lib/calendar/hooks.ts

@@ -1,10 +1,12 @@
 // Side effects when an event changes live: a 301 when a published event's
-// slug moves, and the matching webhook (event.published / event.updated /
+// slug moves, a queued "event changed" app notice when its schedule or place
+// moves, and the matching webhook (event.published / event.updated /
 // event.unpublished). Shared by the editor actions, the list's bulk actions
 // and the agent tools so every path behaves the same.
 import type { ContentRepository } from '../repo/types';
 import type { CalEvent } from '../schema';
 import { emitWebhook } from '../webhooks';
+import { queueEventChange } from '../push/service';
 import { eventToJson } from './api';
 import { eventUrl } from './config';
 
@@ -18,6 +20,8 @@ export async function eventChanged(
     await repo.createRedirect({ fromPath: eventUrl(before.slug), toPath: eventUrl(after.slug) }).catch(() => {});
     opts.onRedirect?.();
   }
+  // the scheduler sends it once the edits settle, if the rule still applies
+  await queueEventChange(repo, before, after).catch((e) => console.error('acms push: event change not queued', e));
   let type: 'event.published' | 'event.updated' | 'event.unpublished' | null = null;
   if (before.status !== 'published' && after.status === 'published') type = 'event.published';
   else if (before.status === 'published' && after.status !== 'published') type = 'event.unpublished';

package/src/lib/live/view.ts

@@ -1,8 +1,9 @@
 import type { PublicLiveSnapshot } from './types';
+import { fill, liveStrings, type LiveStrings } from './words';
 
 // Display text for a live snapshot. Pure and DOM-free: LiveCard renders it on
 // the server and the browser re-applies it on every status change, so both
-// always agree.
+// always agree. Both pass the page's words and language (English by default).
 
 export const PROVIDER_NAMES: Record<string, string> = { youtube: 'YouTube', twitch: 'Twitch', facebook: 'Facebook', other: '' };
 
@@ -23,6 +24,7 @@ export interface LiveView {
 }
 
 const MIN = 60_000, HOUR = 60 * MIN, DAY = 24 * HOUR;
+const EN = liveStrings('en');
 
 export function compactCount(n: number): string {
   if (n < 1000) return String(n);
@@ -30,49 +32,51 @@ export function compactCount(n: number): string {
   return `${v < 10 ? Math.floor(v * 10) / 10 : Math.floor(v)}${unit}`;
 }
 
-export function ago(ms: number): string {
-  if (ms < MIN) return 'just now';
-  if (ms < HOUR) return `${Math.floor(ms / MIN)} min ago`;
+export function ago(ms: number, w: LiveStrings = EN): string {
+  if (ms < MIN) return w.justNow;
+  if (ms < HOUR) return fill(w.ago, { time: `${Math.floor(ms / MIN)} min` });
   const h = Math.floor(ms / HOUR), m = Math.floor((ms % HOUR) / MIN);
-  return m ? `${h} h ${m} min ago` : `${h} h ago`;
+  return fill(w.ago, { time: m ? `${h} h ${m} min` : `${h} h` });
 }
 
-export function until(ms: number): string {
-  if (ms < MIN) return 'starting now';
-  if (ms < HOUR) return `in ${Math.ceil(ms / MIN)} min`;
-  if (ms < DAY) return `in ${Math.round(ms / HOUR)} h`;
+export function until(ms: number, w: LiveStrings = EN): string {
+  if (ms < MIN) return w.startingNow;
+  if (ms < HOUR) return fill(w.in, { time: `${Math.ceil(ms / MIN)} min` });
+  if (ms < DAY) return fill(w.in, { time: `${Math.round(ms / HOUR)} h` });
   const d = Math.round(ms / DAY);
-  return `in ${d} day${d === 1 ? '' : 's'}`;
+  return fill(w.in, { time: fill(d === 1 ? w.day : w.days, { n: String(d) }) });
 }
 
-export function when(ts: number, now: number): string {
-  const d = new Date(ts);
-  const time = d.toLocaleTimeString(undefined, { hour: 'numeric', minute: '2-digit' });
-  if (ts - now < 6 * DAY) return `${d.toLocaleDateString(undefined, { weekday: 'short' })} ${time}`;
-  return `${d.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })} ${time}`;
+// a bad language tag formats like the runtime default rather than failing the page
+export function when(ts: number, now: number, locale?: string): string {
+  const format = (o: Intl.DateTimeFormatOptions) => {
+    try { return new Intl.DateTimeFormat(locale, o).format(ts); } catch { return new Intl.DateTimeFormat(undefined, o).format(ts); }
+  };
+  const time = format({ hour: 'numeric', minute: '2-digit' });
+  return `${format(ts - now < 6 * DAY ? { weekday: 'short' } : { month: 'short', day: 'numeric' })} ${time}`;
 }
 
-export function liveView(s: PublicLiveSnapshot | null, now: number): LiveView | null {
+export function liveView(s: PublicLiveSnapshot | null, now: number, w: LiveStrings = EN, locale?: string): LiveView | null {
   if (!s || (s.status !== 'live' && s.status !== 'upcoming' && s.status !== 'offline')) return null;
   const name = PROVIDER_NAMES[s.provider] ?? '';
   const channel = s.channel?.trim() ?? '';
   const base = { status: s.status, provider: s.provider, title: s.title, watchUrl: s.watchUrl, thumbUrl: s.thumbUrl };
   if (s.status === 'offline') {
-    return { ...base, tag: '', kicker: '', meta: channel, viewers: '', thumbUrl: '', watchLabel: 'Watch our channel ↗' };
+    return { ...base, tag: '', kicker: '', meta: channel, viewers: '', thumbUrl: '', watchLabel: w.watchChannel };
   }
-  const watchLabel = name ? `Watch on ${name} ↗` : 'Watch now ↗';
+  const watchLabel = name ? fill(w.watchOn, { provider: name }) : w.watchNow;
   if (s.status === 'upcoming') {
-    const start = s.startedAt > 0 ? `${when(s.startedAt, now)} · ${until(s.startedAt - now)}` : '';
+    const start = s.startedAt > 0 ? `${when(s.startedAt, now, locale)} · ${until(s.startedAt - now, w)}` : '';
     return {
-      ...base, tag: start || 'UPCOMING', kicker: name ? `UPCOMING ON ${name.toUpperCase()}` : 'UPCOMING',
-      meta: [channel, name && 'scheduled'].filter(Boolean).join(' · '), viewers: '', watchLabel: name ? `Open on ${name} ↗` : 'Open ↗',
+      ...base, tag: start || w.upcoming, kicker: name ? fill(w.upcomingOn, { provider: name.toUpperCase() }) : w.upcoming,
+      meta: [channel, name && w.scheduled].filter(Boolean).join(' · '), viewers: '', watchLabel: name ? fill(w.openOn, { provider: name }) : w.open,
     };
   }
-  const started = s.startedAt > 0 && s.startedAt <= now ? `started ${ago(now - s.startedAt)}` : '';
+  const started = s.startedAt > 0 && s.startedAt <= now ? fill(w.started, { time: ago(now - s.startedAt, w) }) : '';
   return {
-    ...base, tag: 'LIVE', kicker: name ? `LIVE ON ${name.toUpperCase()}` : 'LIVE NOW',
+    ...base, tag: w.tag, kicker: name ? fill(w.liveOn, { provider: name.toUpperCase() }) : w.liveNow,
     meta: [channel, started].filter(Boolean).join(' · '),
-    viewers: typeof s.viewers === 'number' ? `${compactCount(s.viewers)} watching` : '',
+    viewers: typeof s.viewers === 'number' ? fill(w.watching, { count: compactCount(s.viewers) }) : '',
     watchLabel,
   };
 }

package/src/lib/live/words.ts

@@ -0,0 +1,94 @@
+// Words the website's live surfaces show: the live card (view.ts, LiveCard)
+// and the site-wide bar, header marker and dock (Site.astro). Plain strings
+// with {provider}, {time}, {count}, {n} and {title} slots, so LiveCard can
+// hand them to its browser script as JSON. Spanish matches the app's words
+// (packages/native strings.ts) where they overlap. Other languages fall back
+// to English.
+export interface LiveStrings {
+  /** poster tag while live */
+  tag: string;
+  /** above the title: without a provider name, then with it (upper-cased) */
+  liveNow: string;
+  liveOn: string;
+  upcoming: string;
+  upcomingOn: string;
+  watchOn: string;
+  watchNow: string;
+  openOn: string;
+  open: string;
+  watchChannel: string;
+  /** after the channel name of an upcoming broadcast */
+  scheduled: string;
+  /** after the channel name while live: "started {time}" with {time} from `ago` */
+  started: string;
+  justNow: string;
+  ago: string;
+  startingNow: string;
+  in: string;
+  day: string;
+  days: string;
+  watching: string;
+  notLive: string;
+  /** the card's label and the player's title when the stream has none */
+  video: string;
+  playHere: string;
+  play: string;
+  /** under the in-page player button; {provider} falls back to `platform` */
+  privacy: string;
+  platform: string;
+  /** site-wide signals */
+  bar: string;
+  watch: string;
+  dismissBar: string;
+  marker: string;
+  dismissDock: string;
+}
+
+const STRINGS: Record<string, LiveStrings> = {
+  en: {
+    tag: 'LIVE', liveNow: 'LIVE NOW', liveOn: 'LIVE ON {provider}', upcoming: 'UPCOMING', upcomingOn: 'UPCOMING ON {provider}',
+    watchOn: 'Watch on {provider} ↗', watchNow: 'Watch now ↗', openOn: 'Open on {provider} ↗', open: 'Open ↗', watchChannel: 'Watch our channel ↗',
+    scheduled: 'scheduled', started: 'started {time}', justNow: 'just now', ago: '{time} ago', startingNow: 'starting now', in: 'in {time}', day: '{n} day', days: '{n} days',
+    watching: '{count} watching', notLive: 'Not live right now', video: 'Live video', playHere: 'Play here', play: 'Play {title} here',
+    privacy: 'Playing loads video from {provider}.', platform: 'the platform',
+    bar: 'Live now', watch: 'Watch →', dismissBar: 'Dismiss live notice', marker: 'Live', dismissDock: 'Dismiss live player',
+  },
+  es: {
+    tag: 'EN VIVO', liveNow: 'EN VIVO AHORA', liveOn: 'EN VIVO EN {provider}', upcoming: 'PRÓXIMAMENTE', upcomingOn: 'PRÓXIMAMENTE EN {provider}',
+    watchOn: 'Ver en {provider} ↗', watchNow: 'Ver ahora ↗', openOn: 'Abrir en {provider} ↗', open: 'Abrir ↗', watchChannel: 'Ver nuestro canal ↗',
+    scheduled: 'programado', started: 'empezó {time}', justNow: 'hace un momento', ago: 'hace {time}', startingNow: 'empieza ahora', in: 'en {time}', day: '{n} día', days: '{n} días',
+    watching: '{count} viendo', notLive: 'No estamos en vivo ahora', video: 'Video en vivo', playHere: 'Reproducir aquí', play: 'Reproducir {title} aquí',
+    privacy: 'Al reproducir, el video se carga desde {provider}.', platform: 'la plataforma',
+    bar: 'En vivo', watch: 'Ver →', dismissBar: 'Cerrar aviso', marker: 'En vivo', dismissDock: 'Cerrar reproductor',
+  },
+  fr: {
+    tag: 'EN DIRECT', liveNow: 'EN DIRECT', liveOn: 'EN DIRECT SUR {provider}', upcoming: 'À VENIR', upcomingOn: 'BIENTÔT SUR {provider}',
+    watchOn: 'Regarder sur {provider} ↗', watchNow: 'Regarder ↗', openOn: 'Ouvrir sur {provider} ↗', open: 'Ouvrir ↗', watchChannel: 'Voir notre chaîne ↗',
+    scheduled: 'programmé', started: 'a commencé {time}', justNow: 'à l’instant', ago: 'il y a {time}', startingNow: 'commence maintenant', in: 'dans {time}', day: '{n} jour', days: '{n} jours',
+    watching: '{count} spectateurs', notLive: 'Pas en direct pour le moment', video: 'Vidéo en direct', playHere: 'Lire ici', play: 'Lire {title} ici',
+    privacy: 'La lecture charge la vidéo depuis {provider}.', platform: 'la plateforme',
+    bar: 'En direct', watch: 'Regarder →', dismissBar: 'Fermer l’avis', marker: 'En direct', dismissDock: 'Fermer le lecteur',
+  },
+  de: {
+    tag: 'LIVE', liveNow: 'JETZT LIVE', liveOn: 'LIVE AUF {provider}', upcoming: 'DEMNÄCHST', upcomingOn: 'DEMNÄCHST AUF {provider}',
+    watchOn: 'Auf {provider} ansehen ↗', watchNow: 'Jetzt ansehen ↗', openOn: 'Auf {provider} öffnen ↗', open: 'Öffnen ↗', watchChannel: 'Zu unserem Kanal ↗',
+    scheduled: 'geplant', started: 'begann {time}', justNow: 'gerade eben', ago: 'vor {time}', startingNow: 'beginnt jetzt', in: 'in {time}', day: '{n} Tag', days: '{n} Tagen',
+    watching: '{count} Zuschauer', notLive: 'Gerade nicht live', video: 'Livevideo', playHere: 'Hier abspielen', play: '{title} hier abspielen',
+    privacy: 'Beim Abspielen wird das Video von {provider} geladen.', platform: 'der Plattform',
+    bar: 'Jetzt live', watch: 'Ansehen →', dismissBar: 'Hinweis schließen', marker: 'Live', dismissDock: 'Player schließen',
+  },
+  pt: {
+    tag: 'AO VIVO', liveNow: 'AO VIVO AGORA', liveOn: 'AO VIVO NO {provider}', upcoming: 'EM BREVE', upcomingOn: 'EM BREVE NO {provider}',
+    watchOn: 'Assistir no {provider} ↗', watchNow: 'Assistir agora ↗', openOn: 'Abrir no {provider} ↗', open: 'Abrir ↗', watchChannel: 'Ver nosso canal ↗',
+    scheduled: 'agendado', started: 'começou {time}', justNow: 'agora mesmo', ago: 'há {time}', startingNow: 'começando agora', in: 'em {time}', day: '{n} dia', days: '{n} dias',
+    watching: '{count} assistindo', notLive: 'Não estamos ao vivo agora', video: 'Vídeo ao vivo', playHere: 'Reproduzir aqui', play: 'Reproduzir {title} aqui',
+    privacy: 'Ao reproduzir, o vídeo é carregado de {provider}.', platform: 'uma plataforma externa',
+    bar: 'Ao vivo', watch: 'Assistir →', dismissBar: 'Fechar aviso', marker: 'Ao vivo', dismissDock: 'Fechar player',
+  },
+};
+
+export const liveStrings = (locale: string | null | undefined): LiveStrings =>
+  STRINGS[(locale || 'en').toLowerCase().split('-')[0]] ?? STRINGS.en;
+
+/** "Watch on {provider}" → "Watch on YouTube"; unknown slots stay as written */
+export const fill = (template: string, values: Record<string, string>) => template.replace(/\{(\w+)\}/g, (m, k: string) => values[k] ?? m);

package/src/lib/push/api.ts

@@ -101,10 +101,11 @@ export async function adminPushState(repo: ContentRepository, url: URL, locals?:
   const now = Date.now();
   const settings = await repo.getSettings();
   const expo = expoOptions(locals);
-  const [stats, topics, calendars, links, log] = await Promise.all([
+  const [stats, topics, calendars, links, log, tags] = await Promise.all([
     repo.push.stats(now), pushTopics(repo),
     CALENDAR.enabled ? repo.listCalendars() : Promise.resolve([]),
     linkTargets(repo), repo.push.listNotifications(50),
+    CALENDAR.enabled ? repo.listTags() : Promise.resolve([]),
   ]);
   return {
     enabled: PUSH.enabled, retentionDays: PUSH.retentionDays,
@@ -115,6 +116,8 @@ export async function adminPushState(repo: ContentRepository, url: URL, locals?:
     // "we're live" needs live video on (Integrations → Live video)
     liveMode: settings.live.mode,
     calendars: calendars.filter((c) => c.visibility === 'public').map((c) => ({ id: c.id, slug: c.slug, name: c.name, color: c.color })),
+    // suggestions for the event-change rule's "Only events tagged"
+    tags: tags.map((t) => t.name),
     expo: { accessToken: Boolean(expo.accessToken), customEndpoint: expo.base !== EXPO_PUSH_BASE },
   };
 }
@@ -152,11 +155,20 @@ export async function adminPushAction(repo: ContentRepository, input: z.infer<ty
       const collections = new Set(Object.keys(CONTENT.collections));
       const calendars = new Set((CALENDAR.enabled ? await repo.listCalendars() : []).filter((c) => c.visibility === 'public').map((c) => c.id));
       const cals = (ids: string[]) => [...new Set(ids)].filter((id) => id === '*' || calendars.has(id));
+      const changes = input.auto.eventChanges;
+      const tags = changes?.tags ?? [];
+      const known = await knownTopics(repo);
       const auto = {
         newPost: { collections: [...new Set(input.auto.newPost.collections)].filter((k) => collections.has(k)) },
         newEvent: { calendars: CALENDAR.enabled ? cals(input.auto.newEvent.calendars) : [] },
         startingSoon: { calendars: CALENDAR.enabled ? cals(input.auto.startingSoon.calendars) : [], minutes: input.auto.startingSoon.minutes },
         live: { enabled: input.auto.live?.enabled === true },
+        eventChanges: CALENDAR.enabled ? {
+          calendars: cals(changes?.calendars ?? []),
+          // one of each tag, whatever its case (matching ignores case too)
+          tags: tags.filter((t, i) => tags.findIndex((x) => x.toLowerCase() === t.toLowerCase()) === i),
+          topics: [...new Set(changes?.topics ?? [])].filter((t) => known.has(t)),
+        } : { calendars: [], tags: [], topics: [] },
       };
       await repo.updateSettings({ push: { auto } });
       return { auto };

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);