@acms-subir/core 0.3.31 → 0.3.33

package/src/components/MobileApp.tsx

@@ -35,7 +35,7 @@ function ago(ms: number, now: number) {
     : d.toLocaleDateString([], { month: 'short', day: 'numeric', ...(d.getFullYear() !== new Date(now).getFullYear() ? { year: 'numeric' } : {}) });
 }
 
-const SOURCE: Record<PushNotification['source'], string> = { manual: 'Sent by', post: 'New post', event: 'New event', soon: 'Starting soon', live: 'We’re live' };
+const SOURCE: Record<PushNotification['source'], string> = { manual: 'Sent by', post: 'New post', event: 'New event', soon: 'Starting soon', live: 'We’re live', announcement: 'Announcement by' };
 
 export default function MobileApp() {
   const [state, setState] = useState<AdminPushState | null>(null);

package/src/layouts/Admin.astro

@@ -4,6 +4,7 @@ import { getRepo } from '../lib/repo';
 import { BRAND } from '../lib/brand';
 import { CONTENT } from '../lib/content';
 import { CALENDAR, bookingsEnabled } from '../lib/calendar/config';
+import { ANNOUNCEMENTS } from '../lib/announcements/config';
 import { OWNER_ENV } from '../lib/auth';
 import { validateRequestSession } from '../lib/auth/request';
 import { accessFor } from '../lib/permissions/access';
@@ -78,6 +79,7 @@ const icons: Record<string, string> = {
   resources: 'M3 21V9l9-5 9 5v12M9 21v-6h6v6',
   plug: 'M9 7V3M15 7V3M6 7h12v4a6 6 0 0 1-12 0zM12 17v4',
   phone: 'M7 2.5h10a1.5 1.5 0 0 1 1.5 1.5v16a1.5 1.5 0 0 1-1.5 1.5H7A1.5 1.5 0 0 1 5.5 20V4A1.5 1.5 0 0 1 7 2.5zM10.5 18.5h3',
+  megaphone: 'M3.5 10v4a1 1 0 0 0 1 1H7l7 4.5v-15L7 9H4.5a1 1 0 0 0-1 1zM17.5 9a4 4 0 0 1 0 6M7 15l1.2 5h2.3L9.5 15.6',
 };
 
 // one sidebar entry per configured collection, in config order
@@ -137,6 +139,8 @@ const groups: { id: string; label: string; items: Item[] }[] = [
       { key: 'navigation', label: 'Navigation', href: '/admin/navigation', icon: icons.navigation, count: null },
       { key: 'links', label: 'Links page', href: '/admin/links', icon: icons.links, count: links.length },
       // app access switches (+ push notifications when acms({ mobile: { push } }) is on)
+      // stored announcements: list, banner and push (acms({ announcements }))
+      ...(ANNOUNCEMENTS.enabled && can('services.manage') ? [{ key: 'announcements', label: 'Announcements', href: '/admin/announcements', icon: icons.megaphone, count: null }] : []),
       ...(can('services.manage') ? [{ key: 'mobile', label: 'Mobile app', href: '/admin/mobile', icon: icons.phone, count: null }] : []),
     ],
   },

package/src/layouts/Site.astro

@@ -7,6 +7,9 @@ import { siteLang } from '../lib/dates';
 import { CONTENT } from '../lib/content';
 import { I18N, localeFromPath, localeHomeUrl, localePath, requestLocale, stripLocale } from '../lib/i18n';
 import { LEGAL } from '../lib/legal';
+import { ANNOUNCEMENTS } from '../lib/announcements/config';
+import { announcementPath, localizeAnnouncement } from '../lib/announcements/service';
+import { announcementStrings } from '../lib/announcements/words';
 import { SEARCH } from '../lib/search-config';
 import { searchStrings } from '../lib/search-i18n';
 import { effectiveSettings, effectiveNav, resolvePreview } from '../lib/designPreview';
@@ -127,6 +130,15 @@ const barePath = stripLocale(current);
 const inLang = reqLocale && reqLocale !== I18N.defaultLocale ? reqLocale : '';
 const lnk = (url: string) => (inLang && /^\/(?!\/|media\/|rss\.xml|sitemap|admin|api|_)/.test(url) ? localePath(url, inLang) : url);
 const htmlLang = reqLocale || siteLang(settings);
+// pinned announcements (Admin → Announcements) take the bar's place while
+// they're up, urgent first; each one is closed on its own (remembered per id)
+const annWords = announcementStrings(htmlLang);
+const pinnedBars = !bare && ANNOUNCEMENTS.enabled ? (await repo.announcements.banners(Date.now(), 3)).map((a) => {
+  const w = localizeAnnouncement(a, inLang || null);
+  const target = a.link || announcementPath(a.id);
+  return { id: a.id, urgent: a.kind === 'urgent', kind: annWords.kinds[a.kind], title: w.title, label: a.link ? w.buttonLabel || annWords.more : '', href: target ? lnk(target) : '' };
+}) : [];
+const showSettingsBar = showAnnouncement && !pinnedBars.length;
 // search modal chrome: strings follow the document language, the form's
 // no-JS fallback goes to the (locale-prefixed) /search page
 const showSearch = !bare && SEARCH.enabled;
@@ -253,7 +265,35 @@ const homeJsonLd =
         <button type="button" class="pc-live-x" aria-label="Dismiss live notice">✕</button>
       </div>
     )}
-    {showAnnouncement && (
+    {pinnedBars.map((b) => (
+      <div class="announcement-bar ann-pinned" data-ann-id={b.id} hidden>
+        {b.urgent && <strong class="ann-urgent">{b.kind}</strong>}
+        {b.href ? <a href={b.href}>{b.title}{b.label && <span class="ann-cta"> · {b.label} →</span>}</a> : <span>{b.title}</span>}
+        <button type="button" class="announcement-x" aria-label={annWords.dismiss}>✕</button>
+      </div>
+    ))}
+    {pinnedBars.length > 0 && (
+      <script is:inline>
+        (() => {
+          // show the first pinned announcement this browser hasn't closed; closing it shows the next
+          const closed = (bar) => { try { return localStorage.getItem('acms-ann:' + bar.dataset.annId) === '1'; } catch { return false; } };
+          const next = () => {
+            for (const bar of document.querySelectorAll('.ann-pinned')) {
+              if (closed(bar)) { bar.remove(); continue; }
+              bar.hidden = false;
+              bar.querySelector('.announcement-x')?.addEventListener('click', () => {
+                try { localStorage.setItem('acms-ann:' + bar.dataset.annId, '1'); } catch { /* private mode */ }
+                bar.remove();
+                next();
+              }, { once: true });
+              return;
+            }
+          };
+          next();
+        })();
+      </script>
+    )}
+    {showSettingsBar && (
       <div class="announcement-bar" data-ann-key={ann.dismissible ? annKey : undefined} hidden={ann.dismissible || undefined}>
         {annLink ? <a href={annLink}>{ann.text}</a> : <span>{ann.text}</span>}
         {ann.dismissible && (
@@ -261,7 +301,7 @@ const homeJsonLd =
         )}
       </div>
     )}
-    {showAnnouncement && ann.dismissible && (
+    {showSettingsBar && ann.dismissible && (
       <script is:inline define:vars={{ annKey }}>
         (() => {
           const bar = document.querySelector('.announcement-bar');

package/src/lib/agent-discovery.ts

@@ -5,6 +5,8 @@ import { CALENDAR } from './calendar/config';
 import { EVENT_TOOL_DESCRIPTIONS, EVENT_TOOL_NAMES } from './calendar/agent-schema';
 import { BOOKING_TOOL_DESCRIPTIONS, BOOKING_TOOL_NAMES, BOOKING_WRITE_TOOLS } from './booking/agent';
 import { SECTION_TOOL_DESCRIPTIONS } from './sections-agent';
+import { ANNOUNCEMENT_TOOL_DESCRIPTIONS, ANNOUNCEMENT_TOOL_NAMES } from './announcements/agent';
+import { ANNOUNCEMENTS } from './announcements/config';
 
 const descriptions: Record<string, string> = {
   list_content: 'List posts or pages, including unpublished content. Supports pagination and title/slug search.',
@@ -15,8 +17,9 @@ const descriptions: Record<string, string> = {
   ...EVENT_TOOL_DESCRIPTIONS,
   ...BOOKING_TOOL_DESCRIPTIONS,
   ...SECTION_TOOL_DESCRIPTIONS,
+  ...ANNOUNCEMENT_TOOL_DESCRIPTIONS,
 };
-const READ_ONLY = ['list_content', 'get_content', 'list_events', 'get_event', 'list_calendars', 'list_resources', 'check_availability', 'list_bookings', 'list_section_types', 'get_page_layout'];
+const READ_ONLY = ['list_content', 'get_content', 'list_events', 'get_event', 'list_calendars', 'list_resources', 'check_availability', 'list_bookings', 'list_section_types', 'get_page_layout', 'list_announcements'];
 const DESTRUCTIVE = ['update_content', 'publish_content', 'update_event', 'publish_event', 'update_booking', 'set_page_layout', 'update_section_data'];
 const PUBLISH = ['publish_content', 'publish_event', ...BOOKING_WRITE_TOOLS];
 const SECTION_WRITES = ['set_page_layout', 'update_section_data'];
@@ -28,7 +31,8 @@ export function agentTools(allowPublish: boolean, allowSections = false) {
     .filter((tool) => allowPublish || !PUBLISH.includes(tool.name))
     .filter((tool) => allowSections || !SECTION_WRITES.includes(tool.name))
     .filter((tool) => CALENDAR.enabled || !(EVENT_TOOL_NAMES as readonly string[]).includes(tool.name))
-    .filter((tool) => (CALENDAR.enabled && CALENDAR.bookings) || !(BOOKING_TOOL_NAMES as readonly string[]).includes(tool.name));
+    .filter((tool) => (CALENDAR.enabled && CALENDAR.bookings) || !(BOOKING_TOOL_NAMES as readonly string[]).includes(tool.name))
+    .filter((tool) => ANNOUNCEMENTS.enabled || !(ANNOUNCEMENT_TOOL_NAMES as readonly string[]).includes(tool.name));
 }
 export function agentDiscovery(origin: string, allowPublish: boolean, allowSections = false) {
   return {

package/src/lib/agent.ts

@@ -11,6 +11,7 @@ import { EventToolInputs } from './calendar/agent-schema';
 import { runEventTool, type AgentContext, type EventToolInput } from './calendar/agent';
 import { BookingToolInputs, BOOKING_TOOL_NAMES, runBookingTool } from './booking/agent';
 import { SectionToolInputs, SECTION_TOOL_NAMES, runSectionTool } from './sections-agent';
+import { AnnouncementToolInputs, ANNOUNCEMENT_TOOL_NAMES, runAnnouncementTool } from './announcements/agent';
 
 const Kind = z.enum(['posts', 'pages']);
 const fields = {
@@ -35,6 +36,7 @@ export const AgentInput = z.discriminatedUnion('tool', [
   ...EventToolInputs,
   ...BookingToolInputs,
   ...SectionToolInputs,
+  ...AnnouncementToolInputs,
 ]);
 export function renderAgentMarkdown(markdown: string): string {
   const html = sanitizeHtml(renderMarkdown(markdown), {
@@ -53,6 +55,9 @@ export async function runAgentTool(repo: ContentRepository, raw: unknown, allowP
   if ((SECTION_TOOL_NAMES as readonly string[]).includes(parsed.tool)) {
     return runSectionTool(repo, parsed as never, allowPublish);
   }
+  if ((ANNOUNCEMENT_TOOL_NAMES as readonly string[]).includes(parsed.tool)) {
+    return runAnnouncementTool(repo, parsed as never);
+  }
   if ((BOOKING_TOOL_NAMES as readonly string[]).includes(parsed.tool)) {
     return runBookingTool(repo, parsed as never, allowPublish, ctx);
   }

package/src/lib/announcements/agent.ts

@@ -0,0 +1,49 @@
+// Agent / MCP tools for announcements: read them, and draft one for a person
+// to review. Agents never schedule or push: putting one up stays in the admin.
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import { cleanTranslations, requireAnnouncements } from './api';
+import { AnnouncementKind, AnnouncementWords, announcementLink, type Announcement } from './types';
+
+export const AnnouncementToolInputs = [
+  z.object({ tool: z.literal('list_announcements'), arguments: z.object({
+    status: z.enum(['draft', 'scheduled', 'published', 'ended', 'archived']).optional(),
+    limit: z.number().int().min(1).max(100).default(25),
+  }).strict() }).strict(),
+  z.object({ tool: z.literal('draft_announcement'), arguments: AnnouncementWords.extend({
+    kind: AnnouncementKind.default('info'),
+    title: z.string().trim().min(1).max(80),
+    link: announcementLink.optional(),
+    // words in another site language, e.g. { es: { title, message, details, buttonLabel } }
+    translations: z.record(z.string().regex(/^[a-z]{2,3}(-[a-z0-9]{2,8})?$/i), AnnouncementWords).optional(),
+  }).strict() }).strict(),
+] as const;
+
+export const ANNOUNCEMENT_TOOL_NAMES = ['list_announcements', 'draft_announcement'] as const;
+export const ANNOUNCEMENT_TOOL_DESCRIPTIONS: Record<(typeof ANNOUNCEMENT_TOOL_NAMES)[number], string> = {
+  list_announcements: 'List announcements (newest first) with their status, kind, where they show and when they go up and come down.',
+  draft_announcement: 'Draft an announcement (kind: event, registration, help, info or urgent; title ≤ 80, message ≤ 240 = the push text, optional details, button label and link, translations per language). Saved as a draft for staff to review, schedule and push in Admin → Announcements. Never publishes or pushes.',
+};
+
+type Input = z.infer<(typeof AnnouncementToolInputs)[number]>;
+const summary = (a: Announcement) => ({
+  id: a.id, status: a.status, kind: a.kind, title: a.title, message: a.message, listed: a.listed, push: a.push, pinned: a.pinned,
+  publishAt: a.publishAt && new Date(a.publishAt).toISOString(), showUntil: a.showUntil && new Date(a.showUntil).toISOString(),
+  publishedAt: a.publishedAt && new Date(a.publishedAt).toISOString(), languages: Object.keys(a.translations), editUrl: '/admin/announcements',
+});
+
+export async function runAnnouncementTool(repo: ContentRepository, input: Input) {
+  requireAnnouncements();
+  if (input.tool === 'list_announcements') {
+    const all = await repo.announcements.list();
+    return { items: all.filter((a) => !input.arguments.status || a.status === input.arguments.status).slice(0, input.arguments.limit).map(summary) };
+  }
+  const a = input.arguments;
+  const now = Date.now();
+  const draft = await repo.announcements.create({
+    id: crypto.randomUUID(), kind: a.kind, title: a.title, message: a.message, details: a.details, buttonLabel: a.buttonLabel, link: a.link ?? '',
+    translations: cleanTranslations(a.translations ?? {}), listed: true, push: false, pinned: a.kind === 'urgent', audience: ['*'], status: 'draft',
+    publishAt: null, showUntil: null, publishedAt: null, notificationId: null, author: 'Agent', createdAt: now, updatedAt: now,
+  });
+  return { announcement: summary(draft), next: 'A person reviews it in Admin → Announcements, chooses push and timing, then schedules it.' };
+}

package/src/lib/announcements/api.ts

@@ -0,0 +1,222 @@
+// Public reads (/api/v1/announcements) and the admin state/actions behind
+// Admin → Announcements (/api/announcements).
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import { ApiError } from '../api';
+import { I18N, localeName } from '../i18n';
+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 { 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;
+export function requireAnnouncements() {
+  if (!ANNOUNCEMENTS.enabled) throw new ApiError(404, 'Announcements are off on this site.');
+}
+
+// ---- public ------------------------------------------------------------------
+
+export const announcementsQuery = z.object({
+  locale: localeQuery,
+  kind: AnnouncementKind.optional(),
+  /** true = only the banners (pinned), urgent first */
+  pinned: z.enum(['true']).optional(),
+  ...pageQuery,
+}).strict();
+
+export async function listAnnouncements(repo: ContentRepository, url: URL) {
+  requireAnnouncements();
+  const q = announcementsQuery.parse(queryParams(url));
+  const locale = mobileLocale(q.locale);
+  const origin = siteOrigin(await repo.getSettings(), url);
+  const rows = await repo.announcements.live(Date.now(), { kind: q.kind, pinned: q.pinned === 'true', limit: q.limit + 1, offset: (q.page - 1) * q.limit });
+  return {
+    locale, announcements: rows.slice(0, q.limit).map((a) => announcementJson(a, locale, origin)),
+    pagination: { page: q.page, limit: q.limit, nextPage: rows.length > q.limit ? q.page + 1 : null },
+  };
+}
+
+export async function getAnnouncement(repo: ContentRepository, url: URL, id: string) {
+  requireAnnouncements();
+  const locale = mobileLocale(localeOnlyQuery.parse(queryParams(url)).locale);
+  const a = id && id.length <= 100 ? await repo.announcements.get(id) : null;
+  if (!a || !isLive(a, Date.now()) || !(a.listed || a.pinned)) throw new ApiError(404, 'Announcement not found.');
+  return { ...announcementJson(a, locale, siteOrigin(await repo.getSettings(), url)), locale };
+}
+
+// ---- admin -------------------------------------------------------------------
+
+const extraLanguages = () => (I18N.enabled ? I18N.locales.filter((l) => l !== I18N.defaultLocale) : []);
+
+// a topic named after the kind, when the site has one
+const CONVENTION: Record<Exclude<AnnouncementKind, 'urgent'>, string[]> = {
+  event: ['events'], registration: ['registrations', 'registration'], help: ['help'], info: ['info'],
+};
+/** The audience each kind starts with in the composer: acms({ announcements: { topics } }), a topic named after the kind, else everyone. */
+export function defaultAudience(known: Set<string>): Record<AnnouncementKind, string[]> {
+  const pick = (kind: Exclude<AnnouncementKind, 'urgent'>) => {
+    const id = [ANNOUNCEMENTS.topics[kind], ...CONVENTION[kind]].find((t) => t && known.has(t));
+    return id ? [id] : ['*'];
+  };
+  return { event: pick('event'), registration: pick('registration'), help: pick('help'), info: pick('info'), urgent: ['*'] };
+}
+
+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([
+    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),
+  ]);
+  const main = I18N.enabled ? I18N.defaultLocale : (settings.locale || 'en');
+  return {
+    now,
+    site: { name: settings.siteTitle, icon: settings.siteFavicon, origin: siteOriginOf(settings, url.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,
+    // the built-in pages ('' = acms({ announcements: { pages: false } }))
+    base: ANNOUNCEMENTS.pages ? ANNOUNCEMENTS.base : '',
+    // Settings → Announcement bar: a pinned announcement shows instead while it's up
+    bar: settings.announcement.enabled && settings.announcement.text.trim().length > 0,
+    push: {
+      enabled: PUSH.enabled, devices: stats?.devices ?? 0, topicCounts: stats?.topics ?? {},
+      topics: topics.map((t) => ({ id: t.id, label: t.label, kind: t.kind })),
+      // manual and announcement pushes in the last 7 days
+      sentThisWeek,
+    },
+    // the push audience each kind starts with in the composer (['*'] = everyone)
+    defaultAudience: defaultAudience(known),
+    links,
+    announcements,
+  };
+}
+export type AdminAnnouncementsState = Awaited<ReturnType<typeof adminAnnouncementsState>>;
+
+const id = z.string().min(1).max(100);
+const audience = z.array(z.string().min(1).max(200)).min(1, 'Choose who gets the push.').max(50);
+export const AdminAnnouncementAction = z.discriminatedUnion('action', [
+  z.object({ action: z.literal('save'), id: id.optional(), intent: z.enum(['draft', 'schedule']), announcement: AnnouncementInput }).strict(),
+  z.object({ action: z.literal('count'), audience, kind: AnnouncementKind.optional() }).strict(),
+  z.object({ action: z.literal('archive'), id }).strict(),
+  z.object({ action: z.literal('restore'), id }).strict(),
+  z.object({ action: z.literal('delete'), id }).strict(),
+]);
+export type AdminAnnouncementAction = z.infer<typeof AdminAnnouncementAction>;
+
+/** Phones in an audience, per site language (each phone's language mapped as pushes are). */
+export async function countRecipients(repo: ContentRepository, list: string[]) {
+  const settings = await repo.getSettings();
+  const main = I18N.enabled ? I18N.defaultLocale : (settings.locale || 'en');
+  const raw = await repo.push.audienceLocales(list);
+  const counts = new Map<string, number>([[main, 0], ...extraLanguages().map((l): [string, number] => [l, 0])]);
+  for (const [locale, n] of Object.entries(raw)) {
+    const code = deviceLocale(locale) ?? main;
+    counts.set(code, (counts.get(code) ?? 0) + n);
+  }
+  const languages = [...counts].map(([code, count]) => ({ code, name: localeName(code), count }));
+  return { total: languages.reduce((sum, l) => sum + l.count, 0), languages };
+}
+
+async function checkAudience(repo: ContentRepository, list: string[]) {
+  if (list.includes('*')) return ['*'];
+  const known = await knownTopics(repo);
+  const bad = list.find((t) => !known.has(t));
+  if (bad) throw new ApiError(400, `Unknown topic: ${bad}.`);
+  return [...new Set(list)];
+}
+
+const blank = (w: AnnouncementWords) => !w.title && !w.message && !w.details && !w.buttonLabel;
+/** Only the site's extra languages, and only ones with words. */
+export function cleanTranslations(input: Record<string, AnnouncementWords>) {
+  const allowed = new Set(extraLanguages());
+  return Object.fromEntries(Object.entries(input).filter(([code, w]) => allowed.has(code) && !blank(w)));
+}
+
+/** What stops an announcement from going up (null = ready). */
+export function scheduleProblem(a: Pick<Announcement, 'title' | 'message' | 'listed' | 'push' | 'pinned' | 'publishAt' | 'showUntil'>, now: number): string | null {
+  if (!a.title) return 'Add a title.';
+  if (a.push && !a.message) return 'Add the short message: it’s the text of the push.';
+  if (!a.listed && !a.push && !a.pinned) return 'Choose where it shows: the list, a push or the banner.';
+  if (a.showUntil !== null && a.showUntil <= Math.max(now, a.publishAt ?? 0)) return 'The end has to be after the start.';
+  return null;
+}
+
+export interface AdminContext extends PublishOptions { url: URL; author: string }
+
+export async function adminAnnouncementAction(repo: ContentRepository, input: AdminAnnouncementAction, ctx: AdminContext) {
+  requireAnnouncements();
+  const now = ctx.now ?? Date.now();
+  if (input.action === 'count') {
+    if (!PUSH.enabled) return { recipients: { total: 0, languages: [] } };
+    return { recipients: await countRecipients(repo, input.kind === 'urgent' ? ['*'] : await checkAudience(repo, input.audience)) };
+  }
+  if (input.action === 'save') return save(repo, input, ctx, now);
+  const a = await repo.announcements.get(input.id);
+  if (!a) throw new ApiError(404, 'Announcement not found.');
+  if (input.action === 'archive') {
+    if (a.status === 'archived') return { announcement: a };
+    // a scheduled one is cancelled: its push never goes out
+    return { announcement: await repo.announcements.update(a.id, { status: 'archived', updatedAt: now }) };
+  }
+  if (input.action === 'restore') {
+    if (a.status !== 'archived') return { announcement: a };
+    // back up without a new push (the push ledger already has it); never published = back to drafts
+    const status = a.publishedAt === null ? 'draft' : isLive({ ...a, status: 'published' }, now) ? 'published' : 'ended';
+    return { announcement: await repo.announcements.update(a.id, { status, updatedAt: now }) };
+  }
+  if (a.status === 'published' || a.status === 'scheduled') throw new ApiError(409, 'Take it down (archive) before deleting it.');
+  await repo.announcements.delete(a.id);
+  return { deleted: a.id };
+}
+
+async function save(repo: ContentRepository, input: Extract<AdminAnnouncementAction, { action: 'save' }>, ctx: AdminContext, now: number) {
+  const body = input.announcement;
+  const existing = input.id ? await repo.announcements.get(input.id) : null;
+  if (input.id && !existing) throw new ApiError(404, 'Announcement not found.');
+  const wentUp = existing !== null && existing.publishedAt !== null;
+  if (body.push && !PUSH.enabled && !wentUp) throw new ApiError(400, 'Push notifications are off on this site (acms({ mobile: { push } })).');
+  const fields = {
+    kind: body.kind, title: body.title, message: body.message, details: body.details, buttonLabel: body.buttonLabel, link: body.link,
+    translations: cleanTranslations(body.translations), listed: body.listed, pinned: body.pinned, showUntil: body.showUntil,
+  };
+  if (wentUp) {
+    // already went up: words, link, placement and the end can change; the push went out once and stays as it was
+    const next = { ...existing, ...fields, kind: existing.kind === 'urgent' || fields.kind === 'urgent' ? existing.kind : fields.kind };
+    const problem = scheduleProblem({ ...next, push: false, publishAt: null, showUntil: next.showUntil !== null && next.showUntil <= now ? null : next.showUntil }, now);
+    if (problem && problem !== 'Choose where it shows: the list, a push or the banner.') throw new ApiError(400, problem);
+    const status = existing.status === 'archived' ? 'archived' : isLive({ ...next, status: 'published' }, now) ? 'published' : 'ended';
+    return { announcement: await repo.announcements.update(existing.id, { ...fields, kind: next.kind, status, updatedAt: now }) };
+  }
+  const pushAudience = body.kind === 'urgent' ? ['*'] : body.push && PUSH.enabled ? await checkAudience(repo, body.audience) : body.audience.includes('*') ? ['*'] : [...new Set(body.audience)];
+  const draft: Announcement = {
+    id: existing?.id ?? crypto.randomUUID(), ...fields, push: body.push, audience: pushAudience,
+    status: input.intent === 'draft' ? 'draft' : 'scheduled',
+    // "now" = whenever it's scheduled
+    publishAt: body.publishAt !== null && body.publishAt > now ? body.publishAt : null,
+    publishedAt: null, notificationId: null, author: existing?.author || ctx.author,
+    createdAt: existing?.createdAt ?? now, updatedAt: now,
+  };
+  if (existing?.status === 'archived') draft.status = 'archived';
+  if (draft.status === 'scheduled') {
+    const problem = scheduleProblem(draft, now);
+    if (problem) throw new ApiError(400, problem);
+  }
+  const saved = existing ? await repo.announcements.update(existing.id, draft) : await repo.announcements.create(draft);
+  if (!saved) throw new ApiError(409, 'It changed while you were editing. Reload and try again.');
+  if (saved.status === 'scheduled' && saved.publishAt === null) {
+    const result = await publishAnnouncement(repo, saved, { ...ctx, now, origin: ctx.origin ?? siteOriginOf(await repo.getSettings(), ctx.url.origin) });
+    if (result) return result;
+  }
+  return { announcement: saved };
+}

package/src/lib/announcements/config.ts

@@ -0,0 +1,8 @@
+import { userConfig } from 'virtual:acms-config';
+
+// acms({ announcements }) config (integration.mjs resolves it): off unless a
+// site turns it on. `pages: false` keeps the API and the admin but drops the
+// built-in /announcements pages, so a site can build its own. `topics` maps a
+// kind to the push topic it starts with in the composer.
+export const ANNOUNCEMENTS: { enabled: boolean; base: string; pages: boolean; topics: Partial<Record<'event' | 'registration' | 'help' | 'info', string>> } =
+  { enabled: false, base: '/announcements', pages: true, topics: {}, ...userConfig.announcements };

package/src/lib/announcements/migration.ts

@@ -0,0 +1,21 @@
+// v58: announcements (Admin → Announcements), and the Android channels an app
+// created (push_devices.channels), so urgent announcements use a
+// high-importance channel only on phones that have one: Android drops a push
+// sent to a channel the app never created.
+export const ANNOUNCEMENT_TABLE = [
+  `CREATE TABLE announcements (
+    id TEXT PRIMARY KEY, kind TEXT NOT NULL DEFAULT 'info',
+    title TEXT NOT NULL DEFAULT '', message TEXT NOT NULL DEFAULT '', details TEXT NOT NULL DEFAULT '',
+    button_label TEXT NOT NULL DEFAULT '', link TEXT NOT NULL DEFAULT '', translations TEXT NOT NULL DEFAULT '{}',
+    listed INTEGER NOT NULL DEFAULT 1, push INTEGER NOT NULL DEFAULT 0, pinned INTEGER NOT NULL DEFAULT 0,
+    audience TEXT NOT NULL DEFAULT '["*"]', status TEXT NOT NULL DEFAULT 'draft',
+    publish_at INTEGER, show_until INTEGER, published_at INTEGER, notification_id TEXT,
+    author TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+  )`,
+  `CREATE INDEX announcements_status ON announcements (status, published_at)`,
+  `ALTER TABLE push_devices ADD COLUMN channels TEXT NOT NULL DEFAULT '[]'`,
+];
+// what visitors see: the words, the kind, where it shows and when it's up.
+// Left out: the push choices, the author and bookkeeping.
+export const ANNOUNCEMENT_VISIBLE_COLUMNS = ['id', 'kind', 'title', 'message', 'details', 'button_label', 'link', 'translations',
+  'listed', 'pinned', 'status', 'show_until', 'published_at'];

package/src/lib/announcements/pages.ts

@@ -0,0 +1,54 @@
+// What the built-in /announcements pages show: each announcement in the
+// visitor's language with its links, grouped Today / This week / Earlier.
+import { I18N, localePath } from '../i18n';
+import { announcementPath, localizeAnnouncement, paragraphs } from './service';
+import { announcementStrings } from './words';
+import type { Announcement } from './types';
+
+const DAY = 86_400_000;
+// "2026-10-19" in a timezone (Intl falls back to UTC for an unknown zone)
+function dayIn(ms: number, timeZone: string) {
+  try { return new Intl.DateTimeFormat('en-CA', { timeZone, year: 'numeric', month: '2-digit', day: '2-digit' }).format(ms); }
+  catch { return new Date(ms).toISOString().slice(0, 10); }
+}
+function dateLabel(ms: number, lang: string, timeZone: string, withYear: boolean) {
+  const opts: Intl.DateTimeFormatOptions = { weekday: 'short', month: 'short', day: 'numeric', ...(withYear ? { year: 'numeric' } : {}) };
+  try { return new Intl.DateTimeFormat(lang, { ...opts, timeZone }).format(ms); }
+  catch { return new Date(ms).toISOString().slice(0, 10); }
+}
+
+/** One announcement as the website shows it. `locale` = the request's language ('' or the main one = main words). */
+export function announcementView(a: Announcement, locale: string, lang: string, timeZone: string, now: number) {
+  const extra = locale && locale !== I18N.defaultLocale ? locale : null;
+  const w = localizeAnnouncement(a, extra);
+  const t = announcementStrings(lang);
+  const at = a.publishedAt ?? a.updatedAt;
+  const local = (href: string) => (href.startsWith('/') ? localePath(href, locale) : href);
+  return {
+    id: a.id, kind: a.kind, kindLabel: t.kinds[a.kind], urgent: a.kind === 'urgent', pinned: a.pinned,
+    title: w.title, message: w.message, details: paragraphs(w.details),
+    button: a.link ? { label: w.buttonLabel || t.more, href: local(a.link), external: !a.link.startsWith('/') } : null,
+    href: local(announcementPath(a.id)),
+    date: dateLabel(at, lang, timeZone, new Date(at).getUTCFullYear() !== new Date(now).getUTCFullYear()),
+    iso: new Date(at).toISOString(),
+    until: a.showUntil ? t.until(dateLabel(a.showUntil, lang, timeZone, false)) : '',
+    publishedAt: at,
+  };
+}
+export type AnnouncementView = ReturnType<typeof announcementView>;
+
+/** Today, this week (the last 7 days), earlier; empty groups left out. */
+export function groupByWhen(list: AnnouncementView[], lang: string, timeZone: string, now: number) {
+  const t = announcementStrings(lang);
+  const today = dayIn(now, timeZone);
+  const groups = [
+    { key: 'today', label: t.today, items: [] as AnnouncementView[] },
+    { key: 'week', label: t.thisWeek, items: [] as AnnouncementView[] },
+    { key: 'earlier', label: t.earlier, items: [] as AnnouncementView[] },
+  ];
+  for (const v of list) {
+    const i = dayIn(v.publishedAt, timeZone) === today ? 0 : now - v.publishedAt < 7 * DAY ? 1 : 2;
+    groups[i].items.push(v);
+  }
+  return groups.filter((g) => g.items.length);
+}