@acms-subir/core 0.3.33 → 0.3.35

package/src/lib/announcements/api.ts

@@ -8,14 +8,14 @@ import { siteOrigin } from '../seo';
 import { pageQuery, queryParams } from '../mobile/http';
 import { localeOnlyQuery, localeQuery, mobileLocale } from '../mobile/locale';
 import { PUSH } from '../push/config';
-import { deviceLocale, knownTopics, pushTopics, siteOriginOf } from '../push/service';
+import { deviceLocale, knownTopics, pushTopics, siteOriginOf, sitePath } from '../push/service';
 import { linkTargets } from '../push/api';
 import { ANNOUNCEMENTS } from './config';
 import { announcementJson, isLive, publishAnnouncement, type PublishOptions } from './service';
 import { announcementStrings } from './words';
 import { ANNOUNCEMENT_KINDS, AnnouncementInput, AnnouncementKind, LIMITS, type Announcement, type AnnouncementWords } from './types';
 
-const DAY = 86_400_000;
+const HOUR = 3_600_000, DAY = 24 * HOUR;
 export function requireAnnouncements() {
   if (!ANNOUNCEMENTS.enabled) throw new ApiError(404, 'Announcements are off on this site.');
 }
@@ -70,18 +70,20 @@ export function defaultAudience(known: Set<string>): Record<AnnouncementKind, st
 export async function adminAnnouncementsState(repo: ContentRepository, url: URL) {
   const now = Date.now();
   const settings = await repo.getSettings();
-  const [announcements, topics, known, stats, links, sentThisWeek] = await Promise.all([
+  const [announcements, topics, known, stats, links, sentThisWeek, changes] = await Promise.all([
     repo.announcements.list(),
     PUSH.enabled ? pushTopics(repo) : Promise.resolve([]),
     PUSH.enabled ? knownTopics(repo) : Promise.resolve(new Set<string>()),
     PUSH.enabled ? repo.push.stats(now) : Promise.resolve(null),
     linkTargets(repo),
     PUSH.enabled ? repo.push.countSent(['manual', 'announcement'], now - 7 * DAY) : Promise.resolve(0),
+    PUSH.enabled ? repo.push.sentSince('change', now - 2 * HOUR) : Promise.resolve([]),
   ]);
   const main = I18N.enabled ? I18N.defaultLocale : (settings.locale || 'en');
+  const origin = siteOriginOf(settings, url.origin);
   return {
     now,
-    site: { name: settings.siteTitle, icon: settings.siteFavicon, origin: siteOriginOf(settings, url.origin), timezone: settings.timezone || 'UTC' },
+    site: { name: settings.siteTitle, icon: settings.siteFavicon, origin, timezone: settings.timezone || 'UTC' },
     languages: { main: { code: main, name: localeName(main) }, extra: extraLanguages().map((code) => ({ code, name: localeName(code) })) },
     kinds: ANNOUNCEMENT_KINDS.map((id) => ({ id, label: announcementStrings('en').kinds[id] })),
     limits: LIMITS,
@@ -98,6 +100,8 @@ export async function adminAnnouncementsState(repo: ContentRepository, url: URL)
     // the push audience each kind starts with in the composer (['*'] = everyone)
     defaultAudience: defaultAudience(known),
     links,
+    // automatic event-change notices of the last 2 hours: a push whose button opens the same event repeats one
+    recentChanges: changes.map((n) => ({ path: sitePath(n.url, origin), at: n.createdAt, title: n.title })).filter((c) => c.path),
     announcements,
   };
 }

package/src/lib/announcements/store.ts

@@ -68,6 +68,10 @@ export class AnnouncementStore {
   async due(now: number, limit = 10): Promise<Announcement[]> {
     return (await this.all(`SELECT * FROM announcements WHERE status='scheduled' AND COALESCE(publish_at,0)<=? ORDER BY publish_at LIMIT ?`, [now, limit])).map(announcement);
   }
+  /** Ones that went up with a push since `since` (an event-change notice about the same event is skipped). */
+  async pushedSince(since: number): Promise<Announcement[]> {
+    return (await this.all(`SELECT * FROM announcements WHERE notification_id IS NOT NULL AND published_at>=? ORDER BY published_at DESC LIMIT 50`, [since])).map(announcement);
+  }
   /** Published ones past their end: they come down. */
   async endExpired(now: number): Promise<number> {
     return (await this.all(`UPDATE announcements SET status='ended', updated_at=? WHERE status='published' AND show_until IS NOT NULL AND show_until<=? RETURNING id`, [now, now])).length;

package/src/lib/cache/policy.ts

@@ -8,6 +8,12 @@ import { I18N } from '../i18n';
 
 export const PRIVATE_CACHE_CONTROL = 'private, no-store';
 export const publicCacheControl = () => `public, s-maxage=${CACHE.maxAge}, stale-while-revalidate=${CACHE.staleWhileRevalidate}`;
+// The public app API: browsers (Expo web, web apps) revalidate by ETag every
+// time, since stale-while-revalidate would hand them an old /site without a
+// feature the app just got. CDNs that read CDN-Cache-Control (RFC 9213, e.g.
+// Cloudflare) still serve it stale while they refresh, like pages; others fall
+// back to s-maxage.
+export const apiCacheControl = () => `public, max-age=0, s-maxage=${CACHE.maxAge}`;
 // publicResponse's own header: browsers/apps always revalidate by ETag. The
 // policy upgrades it with s-maxage so a CDN can share it.
 export const API_REVALIDATE = 'public, max-age=0, must-revalidate';
@@ -64,12 +70,13 @@ export function applyCachePolicy(request: Request, response: Response, pathname
   if (!CACHE.enabled) return response;
   if (OWN_HEADERS.test(pathname)) return response;
   const current = response.headers.get('cache-control');
-  const set = (value: string) => {
-    try { response.headers.set('Cache-Control', value); return response; }
+  const set = (value: string, cdn?: string) => {
+    const write = (h: Headers) => { h.set('Cache-Control', value); if (cdn) h.set('CDN-Cache-Control', cdn); };
+    try { write(response.headers); return response; }
     catch {
       // immutable headers (a proxied/fetched response): copy it
       const copy = new Response(response.body, response);
-      copy.headers.set('Cache-Control', value);
+      write(copy.headers);
       return copy;
     }
   };
@@ -85,5 +92,6 @@ export function applyCachePolicy(request: Request, response: Response, pathname
     warnCookie(pathname);
     return set(PRIVATE_CACHE_CONTROL);
   }
+  if (pathname.startsWith('/api/v1/')) return set(apiCacheControl(), publicCacheControl());
   return set(publicCacheControl());
 }

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/legal/app-privacy.ts

@@ -29,7 +29,7 @@ export function appPrivacyAnswers(f: LegalFacts, privacyUrl: string): AppPrivacy
     google: 'Personal info → Email address. Collected, not shared. Purpose: App functionality, Account management. Optional.',
   });
   if (f.push.enabled) rows.push({
-    data: 'Push token, platform, language and chosen topics', when: 'When someone turns on notifications',
+    data: 'Push token, platform, language, chosen topics and Android notification channels', when: 'When someone turns on notifications',
     apple: 'Identifiers → Device ID. Purpose: App Functionality. Linked to the user. Not used for tracking.',
     google: 'Device or other IDs. Collected, not shared (Expo, Apple and Google deliver on your behalf). Purpose: App functionality, Developer communications. Optional.',
   });

package/src/lib/legal/facts.ts

@@ -3,6 +3,7 @@ import type { ContentRepository } from '../repo/types';
 import type { Settings } from '../schema';
 import { CALENDAR, bookingsEnabled } from '../calendar/config';
 import { PUSH } from '../push/config';
+import { ANNOUNCEMENTS } from '../announcements/config';
 import { AUTH } from '../auth/config';
 import { EDITOR } from '../editor/config';
 import { SITE_ROLES } from '../roles';
@@ -39,6 +40,8 @@ export interface LegalFacts {
   /** maps provider name, or '' */
   maps: string;
   live: boolean;
+  /** acms({ announcements }): urgent ones reach every device; read and closed state stays in the app */
+  announcements: boolean;
   analytics: { umami: boolean; replay: boolean; meta: boolean; tiktok: boolean };
   ai: boolean;
   offsiteBackups: boolean;
@@ -79,6 +82,7 @@ export async function legalFacts(repo: ContentRepository, settings: Settings, lo
     email: email && !email.error && email.provider !== 'none' && email.config.enabled ? EMAIL_NAMES[email.provider] ?? email.provider : '',
     maps: (() => { const m = mapsStatus(locals); return m.enabled ? m.label.replace(/ \(self-hosted\)$/, '') : ''; })(),
     live: settings.live.mode !== 'off',
+    announcements: ANNOUNCEMENTS.enabled,
     analytics: {
       umami: a.umami.enabled && !!a.umami.websiteId,
       replay: a.umami.enabled && !!a.umami.websiteId && a.umami.replay.enabled,

package/src/lib/legal/text-en.ts

@@ -52,8 +52,8 @@ export function privacyEn(f: LegalFacts, country: string): PolicySection[] {
     'To see your bookings in our app, you can sign in with your email address. We email you a six-digit code that expires after 10 minutes. We keep your email address and that sign-in on your device until you sign out or don’t use it for 90 days.',
   ] });
   if (f.push.enabled) s.push({ id: 'push', title: 'Our app and notifications', text: [
-    'If you turn on notifications in our app, we store a push token for your device (an identifier that lets Apple or Google deliver notifications to it), whether it’s iOS or Android, your language and the topics you choose. We use them only to send the notifications you asked for, in your language. Notifications are delivered through Expo’s push service (expo.dev), Apple Push Notification service and Firebase Cloud Messaging.',
-    `You choose the topics in the app and can change them at any time; we never add a topic without asking you. To stop, turn notifications off in the app or in your phone’s settings. Turning them off in the app removes your device from our list right away. Devices that haven’t opened the app for ${days(f.push.retentionDays)}, and devices whose app was removed, are deleted automatically. We keep a record of each notification sent (its text, link and number of recipients, not who received it) for one year. The app works fully without notifications.`,
+    'If you turn on notifications in our app, we store a push token for your device (an identifier that lets Apple or Google deliver notifications to it), whether it’s iOS or Android, your language, the topics you choose and, on Android, which notification channels the app created (such as one for urgent notices). We use them only to send the notifications you asked for, in your language. Notifications are delivered through Expo’s push service (expo.dev), Apple Push Notification service and Firebase Cloud Messaging.',
+    `You choose the topics in the app and can change them at any time; we never add a topic without asking you. ${f.announcements ? 'Urgent announcements, such as cancellations, go to every device with notifications turned on, whatever topics it chose.' : 'Important notices, such as cancellations, may go to every device with notifications turned on, whatever topics it chose.'} To stop, turn notifications off in the app or in your phone’s settings. Turning them off in the app removes your device from our list right away. Devices that haven’t opened the app for ${days(f.push.retentionDays)}, and devices whose app was removed, are deleted automatically. We keep a record of each notification sent (its text, link and number of recipients, not who received it) for one year. The app works fully without notifications.`,
   ] });
   if (f.email) s.push({ id: 'email', title: 'Email', text: [
     `We send email through ${f.email}, which processes your email address and the message. We keep a delivery record (recipient and status) for 30 days, and keep addresses that bounce or report our email as spam on a list so we stop writing to them.`,
@@ -79,7 +79,9 @@ export function privacyEn(f: LegalFacts, country: string): PolicySection[] {
   ] });
   s.push({ id: 'cookies', title: 'Cookies and storage on your device', text: [
     `${f.auth === 'clerk' ? 'Clerk’s sign-in cookies' : 'A sign-in cookie (up to seven days)'} for people who sign in; a preview cookie only for staff previews and design share links (up to 30 days); and, in your browser, your light or dark mode choice, the announcements you close and, for one visit, the live video notices you close.${pixels ? ` ${pixelNames} ${f.analytics.meta && f.analytics.tiktok ? 'set their' : 'sets its'} own advertising cookies.` : ' We don’t use cookies for advertising.'}`,
-    ...(app ? ['Our app may keep the content it last loaded on your phone so it works offline, and remembers your notification choice there.'] : []),
+    ...(app ? [f.announcements
+      ? 'Our app may keep the content it last loaded on your phone so it works offline, and remembers there your notification choice and which announcements you’ve read or closed. That stays on your phone and is never sent to us.'
+      : 'Our app may keep the content it last loaded on your phone so it works offline, and remembers your notification choice there.'] : []),
   ] });
   s.push({ id: 'sharing', title: 'Who receives your information', text: [
     `We don’t sell your personal information${pixels ? '' : ' or share it for advertising'}. These service providers process it on our behalf and only for the purposes above: ${list(processors(f))}. They must protect it at least as this notice describes. Some of them may store it outside your country, including in the United States.`,

package/src/lib/legal/text-es.ts

@@ -53,8 +53,8 @@ export function privacyEs(f: LegalFacts, country: string): PolicySection[] {
     'Para ver sus reservaciones en nuestra app, puede iniciar sesión con su correo electrónico. Le enviamos un código de seis dígitos que vence a los 10 minutos. Guardamos su correo y esa sesión en su dispositivo hasta que la cierre o pasen 90 días sin usarla.',
   ] });
   if (f.push.enabled) s.push({ id: 'push', title: 'Nuestra app y las notificaciones', text: [
-    'Si activa las notificaciones en nuestra app, guardamos un identificador de notificaciones de su dispositivo (que permite a Apple o Google entregárselas), si es iOS o Android, su idioma y los temas que elija. Solo los usamos para enviarle las notificaciones que pidió, en su idioma. Las notificaciones se entregan a través del servicio de Expo (expo.dev), Apple Push Notification service y Firebase Cloud Messaging.',
-    `Usted elige los temas en la app y puede cambiarlos cuando quiera; nunca agregamos un tema sin preguntarle. Para dejar de recibirlas, desactive las notificaciones en la app o en los ajustes de su teléfono. Al desactivarlas en la app, su dispositivo se elimina de nuestra lista de inmediato. Los dispositivos que no han abierto la app en ${days(f.push.retentionDays)}, y aquellos en los que se borró la app, se eliminan automáticamente. Guardamos un registro de cada notificación enviada (su texto, su enlace y el número de destinatarios, no quiénes la recibieron) durante un año. La app funciona por completo sin notificaciones.`,
+    'Si activa las notificaciones en nuestra app, guardamos un identificador de notificaciones de su dispositivo (que permite a Apple o Google entregárselas), si es iOS o Android, su idioma, los temas que elija y, en Android, qué canales de notificación creó la app (por ejemplo, uno para avisos urgentes). Solo los usamos para enviarle las notificaciones que pidió, en su idioma. Las notificaciones se entregan a través del servicio de Expo (expo.dev), Apple Push Notification service y Firebase Cloud Messaging.',
+    `Usted elige los temas en la app y puede cambiarlos cuando quiera; nunca agregamos un tema sin preguntarle. ${f.announcements ? 'Los anuncios urgentes, como una cancelación, llegan a todos los dispositivos con las notificaciones activadas, sin importar los temas que eligieron.' : 'Los avisos importantes, como una cancelación, pueden llegar a todos los dispositivos con las notificaciones activadas, sin importar los temas que eligieron.'} Para dejar de recibirlas, desactive las notificaciones en la app o en los ajustes de su teléfono. Al desactivarlas en la app, su dispositivo se elimina de nuestra lista de inmediato. Los dispositivos que no han abierto la app en ${days(f.push.retentionDays)}, y aquellos en los que se borró la app, se eliminan automáticamente. Guardamos un registro de cada notificación enviada (su texto, su enlace y el número de destinatarios, no quiénes la recibieron) durante un año. La app funciona por completo sin notificaciones.`,
   ] });
   if (f.email) s.push({ id: 'email', title: 'Correo electrónico', text: [
     `Enviamos correos a través de ${f.email}, que trata su dirección de correo y el mensaje. Guardamos un registro de entrega (destinatario y estado) durante 30 días, y mantenemos en una lista las direcciones que rebotan o marcan nuestros correos como spam para dejar de escribirles.`,
@@ -80,7 +80,9 @@ export function privacyEs(f: LegalFacts, country: string): PolicySection[] {
   ] });
   s.push({ id: 'cookies', title: 'Cookies y almacenamiento en su dispositivo', text: [
     `${f.auth === 'clerk' ? 'Las cookies de inicio de sesión de Clerk' : 'Una cookie de inicio de sesión (hasta siete días)'} para quienes inician sesión; una cookie de vista previa solo para las vistas previas del personal y los enlaces para compartir diseños (hasta 30 días); y, en su navegador, su preferencia de modo claro u oscuro, los anuncios que cierra y, durante una visita, los avisos de video en vivo que cierra.${pixels ? ` ${pixelNames} ${both ? 'guardan sus propias' : 'guarda sus propias'} cookies de publicidad.` : ' No usamos cookies con fines publicitarios.'}`,
-    ...(app ? ['Nuestra app puede guardar en su teléfono el contenido que cargó por última vez para funcionar sin conexión, y recuerda ahí su preferencia de notificaciones.'] : []),
+    ...(app ? [f.announcements
+      ? 'Nuestra app puede guardar en su teléfono el contenido que cargó por última vez para funcionar sin conexión, y recuerda ahí su preferencia de notificaciones y qué anuncios leyó o cerró. Eso se queda en su teléfono y nunca se nos envía.'
+      : 'Nuestra app puede guardar en su teléfono el contenido que cargó por última vez para funcionar sin conexión, y recuerda ahí su preferencia de notificaciones.'] : []),
   ] });
   s.push({ id: 'sharing', title: 'Quién recibe sus datos', text: [
     `No vendemos sus datos personales${pixels ? '' : ' ni los compartimos con fines publicitarios'}. Estos proveedores los tratan por cuenta nuestra y solo para los fines descritos: ${list(processors(f))}. Deben protegerlos al menos como lo describe este aviso. Algunos pueden guardarlos fuera de su país, incluido Estados Unidos.`,

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