@acms-subir/core 0.3.50 → 0.3.52

package/src/lib/display/screens.ts

@@ -0,0 +1,111 @@
+// Saved screens as the TV and the admin see them: opening one by its key
+// (rate-limited for wrong keys), and the admin state and actions behind
+// Admin → Calendar → Screens (/api/calendar/screens).
+import { z } from 'zod';
+import type { ContentRepository } from '../repo/types';
+import { ApiError } from '../api';
+import { sha256Hex } from '../api-keys';
+import { I18N, localeName } from '../i18n';
+import { siteLang } from '../dates';
+import { roomColor } from '../schema';
+import { safeColor } from '../calendar/events';
+import { canonicalDisplayQuery } from './settings';
+import type { Screen, ScreenInput } from './store';
+
+// Wrong keys, per client address: past this many in the window, further
+// wrong keys from that address are refused without a lookup. A right key
+// always opens its screen, so nobody can lock a church's TVs out by sending
+// bad keys "from" its address (proxies can claim any address). Keys are
+// 256-bit, so guessing gets nowhere either way.
+export const MISS_LIMIT = 60;
+export const MISS_WINDOW = 15 * 60_000;
+const missKey = async (address: string) => `display:miss:${await sha256Hex(address || 'unknown')}`;
+
+export type OpenedScreen = { status: 'ok'; screen: Screen } | { status: 'missing' } | { status: 'limited' };
+
+/** The screen at /display/s/<key>, counting a wrong key against the caller's address. */
+export async function openScreen(repo: ContentRepository, key: string, address: string): Promise<OpenedScreen> {
+  const screen = await repo.screens.byKey(key);
+  if (screen) return { status: 'ok', screen };
+  const limitKey = await missKey(address);
+  if (await repo.email.rateLimited(limitKey, MISS_LIMIT)) return { status: 'limited' };
+  await repo.email.rateHit(limitKey, MISS_WINDOW);
+  return { status: 'missing' };
+}
+
+export const screenPath = (s: Pick<Screen, 'key'>) => `/display/s/${s.key}`;
+
+// ---- admin -----------------------------------------------------------------
+
+const siteLanguages = (mainLang: string) => {
+  const codes = I18N.enabled ? I18N.locales : [mainLang];
+  return codes.map((code) => ({ code, label: localeName(code, true), main: I18N.enabled ? code === I18N.defaultLocale : true }));
+};
+
+/**
+ * What the Screens editor needs: the screens, and what a screen can pick
+ * from. `bookings`: the person may see booker names (Manage bookings), which
+ * private details show.
+ */
+export async function screensState(repo: ContentRepository, origin: string, opts: { bookings: boolean }) {
+  const [screens, site, calendars, resources, events] = await Promise.all([
+    repo.screens.list(), repo.getSettings(), repo.listCalendars(), repo.listResources(), repo.listPublishedEvents(),
+  ]);
+  const tags = [...new Set(events.flatMap((e) => e.tags.map((t) => t.trim()).filter(Boolean)))].sort((a, b) => a.localeCompare(b));
+  return {
+    now: Date.now(),
+    origin,
+    canPrivate: opts.bookings,
+    weekStart: site.calendar.weekStart,
+    timezone: site.timezone || 'UTC',
+    languages: siteLanguages(siteLang(site)),
+    screens: screens.map((s) => ({ ...s, url: s.key ? origin + screenPath(s) : '' })),
+    calendars: calendars.map((c) => ({ slug: c.slug, name: c.name, color: safeColor(c.color), visibility: c.visibility, kind: c.kind })),
+    // public: named on public events, so quick links can show and filter by it
+    rooms: resources.map((r) => ({ slug: r.slug, name: r.name, kind: r.kind, color: roomColor(r), public: r.showOnEvents })),
+    tags,
+  };
+}
+
+const ScreenFields = {
+  name: z.string().trim().min(1, 'Give the screen a name.').max(120),
+  params: z.string().max(4000),
+  locale: z.string().max(20).default(''),
+  privateDetails: z.boolean().default(false),
+};
+export const ScreenAction = z.discriminatedUnion('action', [
+  z.object({ action: z.literal('create'), ...ScreenFields }),
+  z.object({ action: z.literal('save'), id: z.string().min(1), ...ScreenFields }),
+  z.object({ action: z.literal('rotate'), id: z.string().min(1) }),
+  z.object({ action: z.literal('delete'), id: z.string().min(1) }),
+  z.object({ action: z.literal('reorder'), ids: z.array(z.string()).max(500) }),
+]);
+export type ScreenAction = z.infer<typeof ScreenAction>;
+
+function screenInput(a: { name: string; params: string; locale: string; privateDetails: boolean }): ScreenInput {
+  // only a configured extra language; the main one is stored as ''
+  const locale = I18N.enabled && a.locale !== I18N.defaultLocale && I18N.locales.includes(a.locale) ? a.locale : '';
+  return { name: a.name, params: canonicalDisplayQuery(a.params.replace(/^\?/, '')), locale, privateDetails: a.privateDetails };
+}
+
+export async function screenAction(repo: ContentRepository, a: ScreenAction, opts: { bookings: boolean }): Promise<{ screen?: Screen; ok?: true }> {
+  // private details show booker names: only for people who may see bookings
+  if ((a.action === 'create' || a.action === 'save') && a.privateDetails && !opts.bookings) {
+    throw new ApiError(403, 'Showing private calendars and room bookings needs the “Manage bookings” permission.');
+  }
+  const found = (s: Screen | null) => {
+    if (!s) throw new ApiError(404, 'That screen was removed. Reload the page.');
+    return { screen: s };
+  };
+  switch (a.action) {
+    case 'create': return { screen: await repo.screens.create(screenInput(a)) };
+    case 'save': return found(await repo.screens.update(a.id, screenInput(a)));
+    case 'rotate': return found(await repo.screens.rotate(a.id));
+    case 'delete':
+      if (!(await repo.screens.delete(a.id))) throw new ApiError(404, 'That screen was removed. Reload the page.');
+      return { ok: true };
+    case 'reorder':
+      await repo.screens.reorder(a.ids);
+      return { ok: true };
+  }
+}

package/src/lib/display/store.ts

@@ -0,0 +1,113 @@
+// Saved TV screens (Admin → Calendar → Screens). Each one is a name, the
+// display settings as their canonical query (lib/display/settings.ts, the
+// same text a quick link carries), a language, the private-details switch and
+// a long random key: the screen's whole address is /display/s/<key>. The key
+// is kept as is, like a private calendar's feed token, so staff can copy the
+// link again; rotating it stops the old one at once. last_seen_at is the last
+// time the screen fetched its events. Shared by the D1 and libSQL adapters.
+import type { SqlDriver, SqlStatement } from '../repo/sql';
+
+export interface Screen {
+  id: string;
+  name: string;
+  /** the display settings, as their canonical query ("view=rooms&hours=8-21") */
+  params: string;
+  /** the display's language ('' = the site's main language) */
+  locale: string;
+  /** shows private calendars it names and room bookings (titles, rooms, hosts, the name on a booking) */
+  privateDetails: boolean;
+  /** the secret in the screen's address; '' = no link until it's rotated */
+  key: string;
+  /** when the screen last fetched its events (ms; null = never) */
+  lastSeenAt: number | null;
+  order: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export type ScreenInput = Pick<Screen, 'name' | 'params' | 'locale' | 'privateDetails'>;
+
+// v67: Admin → Calendar → Screens. Not public (each screen is reached by its
+// own key, never cached), so no content-version trigger.
+export const SCREENS_MIGRATION = {
+  version: 67,
+  statements: [
+    `CREATE TABLE display_screens (
+      id TEXT PRIMARY KEY, name TEXT NOT NULL DEFAULT '', params TEXT NOT NULL DEFAULT '', locale TEXT NOT NULL DEFAULT '',
+      private_details INTEGER NOT NULL DEFAULT 0, screen_key TEXT NOT NULL DEFAULT '', last_seen_at INTEGER,
+      ord INTEGER NOT NULL DEFAULT 0, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+    )`,
+    `CREATE UNIQUE INDEX display_screens_key ON display_screens (screen_key) WHERE screen_key <> ''`,
+  ],
+};
+
+/** 32 random bytes, base64url (43 characters) */
+export function screenKey(): string {
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  return btoa(String.fromCharCode(...bytes)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+export const isScreenKey = (s: string) => /^[A-Za-z0-9_-]{43}$/.test(s);
+
+type Row = Record<string, unknown>;
+const screen = (r: Row): Screen => ({
+  id: String(r.id), name: String(r.name ?? ''), params: String(r.params ?? ''), locale: String(r.locale ?? ''),
+  privateDetails: Number(r.private_details) === 1, key: String(r.screen_key ?? ''),
+  lastSeenAt: r.last_seen_at == null ? null : Number(r.last_seen_at),
+  order: Number(r.ord ?? 0), createdAt: Number(r.created_at), updatedAt: Number(r.updated_at),
+});
+
+/** The INSERT for one screen (create and backup restore). */
+export function screenInsert(s: Screen): SqlStatement {
+  return {
+    sql: `INSERT INTO display_screens (id, name, params, locale, private_details, screen_key, last_seen_at, ord, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [s.id, s.name, s.params, s.locale, s.privateDetails ? 1 : 0, s.key, s.lastSeenAt, s.order, s.createdAt, s.updatedAt],
+  };
+}
+
+// a screen fetching every few minutes writes its check-in at most once a minute
+const CHECK_IN_EVERY = 60_000;
+
+export class ScreenStore {
+  constructor(private driver: () => Promise<SqlDriver>) {}
+  private async all(sql: string, args: unknown[] = []) { return (await this.driver()).all(sql, args); }
+
+  async list(): Promise<Screen[]> {
+    return (await this.all('SELECT * FROM display_screens ORDER BY ord, name COLLATE NOCASE, created_at')).map(screen);
+  }
+  async get(id: string): Promise<Screen | null> {
+    const r = await this.all('SELECT * FROM display_screens WHERE id = ?', [id]);
+    return r[0] ? screen(r[0]) : null;
+  }
+  /** the screen with this key (null for a wrong, rotated or empty key) */
+  async byKey(key: string): Promise<Screen | null> {
+    if (!isScreenKey(key)) return null;
+    const r = await this.all('SELECT * FROM display_screens WHERE screen_key = ?', [key]);
+    return r[0] ? screen(r[0]) : null;
+  }
+  async create(input: ScreenInput, now = Date.now()): Promise<Screen> {
+    const next = await this.all('SELECT COALESCE(MAX(ord), -1) + 1 AS n FROM display_screens');
+    const s: Screen = { id: crypto.randomUUID(), ...input, key: screenKey(), lastSeenAt: null, order: Number(next[0]?.n ?? 0), createdAt: now, updatedAt: now };
+    const insert = screenInsert(s);
+    return screen((await this.all(`${insert.sql} RETURNING *`, insert.args))[0]);
+  }
+  async update(id: string, input: ScreenInput, now = Date.now()): Promise<Screen | null> {
+    const r = await this.all('UPDATE display_screens SET name = ?, params = ?, locale = ?, private_details = ?, updated_at = ? WHERE id = ? RETURNING *',
+      [input.name, input.params, input.locale, input.privateDetails ? 1 : 0, now, id]);
+    return r[0] ? screen(r[0]) : null;
+  }
+  /** a new key: the old address stops working at once */
+  async rotate(id: string, now = Date.now()): Promise<Screen | null> {
+    const r = await this.all('UPDATE display_screens SET screen_key = ?, updated_at = ? WHERE id = ? RETURNING *', [screenKey(), now, id]);
+    return r[0] ? screen(r[0]) : null;
+  }
+  async delete(id: string): Promise<boolean> {
+    return (await this.all('DELETE FROM display_screens WHERE id = ? RETURNING id', [id])).length > 0;
+  }
+  async reorder(ids: string[]): Promise<void> {
+    await (await this.driver()).batch(ids.map((id, i) => ({ sql: 'UPDATE display_screens SET ord = ? WHERE id = ?', args: [i, id] })));
+  }
+  /** the screen fetched its events (written at most once a minute) */
+  async checkIn(id: string, now = Date.now()): Promise<void> {
+    await (await this.driver()).run('UPDATE display_screens SET last_seen_at = ? WHERE id = ? AND (last_seen_at IS NULL OR last_seen_at <= ?)', [now, id, now - CHECK_IN_EVERY]);
+  }
+}

package/src/lib/display/words.ts

@@ -1,6 +1,9 @@
 // Words of the TV display (/display/…). Dates, weekdays and times come from
 // Intl in the display's language; these are the rest. Plain strings with
-// {slots} filled by `fill`. Other languages fall back to English.
+// {slots} filled by `fill`. Other languages fall back to English. "Moved"
+// and "Cancelled" are the event pages' own words (event-words.ts), so a TV
+// says what the site and its emails say.
+import { eventStrings } from '../calendar/event-words';
 export interface DisplayStrings {
   thisWeek: string;
   /** a rolling week (start=today) or list: "Next 7 days" */
@@ -16,11 +19,13 @@ export interface DisplayStrings {
   nothingNext: string;
   noEvents: string;
   more: string;
+  /** from eventStrings: the event pages' word */
   moved: string;
   /** a moved date's old time */
   was: string;
   /** appointments from Google booking pages (#google-booking) */
   booked: string;
+  /** from eventStrings: the event pages' word */
   cancelled: string;
   scan: string;
   tomorrow: string;
@@ -28,25 +33,30 @@ export interface DisplayStrings {
   notFoundNote: string;
 }
 
-const STRINGS: Record<string, DisplayStrings> = {
+const STRINGS: Record<string, Omit<DisplayStrings, 'moved' | 'cancelled'>> = {
   en: {
     thisWeek: 'This week', nextDays: 'Next {n} days', today: 'Today', upcoming: 'Coming up', allDay: 'All day',
     updated: 'Updated {time}', now: 'Now', next: 'Next', nothingNow: 'Nothing right now', nothingNext: 'Nothing else today',
-    noEvents: 'No events', more: '+{n} more', moved: 'Moved', was: 'was {time}', booked: 'Booked', cancelled: 'Cancelled',
+    noEvents: 'No events', more: '+{n} more', was: 'was {time}', booked: 'Booked',
     scan: 'Scan for the calendar', tomorrow: 'Tomorrow',
     notFound: 'This screen isn’t available', notFoundNote: 'Its link may have changed. Copy the new one from Admin → Calendar → Screens.',
   },
   es: {
     thisWeek: 'Esta semana', nextDays: 'Próximos {n} días', today: 'Hoy', upcoming: 'Próximamente', allDay: 'Todo el día',
     updated: 'Actualizado {time}', now: 'Ahora', next: 'Después', nothingNow: 'Nada en este momento', nothingNext: 'Nada más hoy',
-    noEvents: 'Sin eventos', more: '+{n} más', moved: 'Cambiado', was: 'antes {time}', booked: 'Reservado', cancelled: 'Cancelado',
+    noEvents: 'Sin eventos', more: '+{n} más', was: 'antes {time}', booked: 'Reservado',
     scan: 'Escanea para ver el calendario', tomorrow: 'Mañana',
     notFound: 'Esta pantalla no está disponible', notFoundNote: 'Puede que su enlace haya cambiado. Copia el nuevo en Admin → Calendario → Pantallas.',
   },
 };
 
-export const displayStrings = (lang: string | null | undefined): DisplayStrings =>
-  STRINGS[(lang || 'en').toLowerCase().split('-')[0]] ?? STRINGS.en;
+/** "Booked" in every language: the Google sync titles its appointments with it */
+export const isBookedWord = (title: string) => Object.values(STRINGS).some((s) => s.booked.toLowerCase() === title.trim().toLowerCase());
+
+export const displayStrings = (lang: string | null | undefined): DisplayStrings => {
+  const ew = eventStrings(lang);
+  return { ...(STRINGS[(lang || 'en').toLowerCase().split('-')[0]] ?? STRINGS.en), moved: ew.moved, cancelled: ew.cancelled };
+};
 
 export const fill = (s: string, slots: Record<string, string | number>) =>
   s.replace(/\{(\w+)\}/g, (m, k: string) => (k in slots ? String(slots[k]) : m));

package/src/lib/mobile/calendar.ts

@@ -11,6 +11,7 @@ import { sha256Hex } from '../api-keys';
 import type { PublicContext } from './route';
 import { addDaysYmd, describeLink, linkLengths, localMidnight, slotsForDay, ymd } from '../booking/availability';
 import { siteOrigin } from '../seo';
+import { siteLang } from '../dates';
 import { safeUrl } from './content';
 import { pageQuery, isoDay, isoDayOrInstant, queryParams } from './http';
 import { localizeDoc } from '../translations';
@@ -116,7 +117,8 @@ export function occurrenceDto(o: Occurrence, resources: Map<string, Resource>) {
 }
 // e is already localized; publicCalendars limits which calendars are named
 export function publicEventDto(e: CalEvent, origin: string, publicCalendars: Map<string, Calendar>, settings: Settings, locale: string | null, resources?: Map<string, Resource>) {
-  const event = eventToJson(e, origin, publicCalendars, settings.timezone, { resources });
+  // the repeat line in the request's language, else the site's main one
+  const event = eventToJson(e, origin, publicCalendars, settings.timezone, { resources, locale: locale || siteLang(settings) });
   event.url = localizedUrl(event.url, origin, locale);
   // Only configured public event fields; no undeclared imported metadata, no private fields.
   event.fields = publicEventFields(e.fields);

package/src/lib/repo/migrations.ts

@@ -10,6 +10,7 @@ import { PLACES_MIGRATION } from '../maps/migration';
 import { ROLES_MIGRATION } from '../permissions/migration';
 import { SYNC_MIGRATION } from '../sync/migration';
 import { ANNOUNCEMENT_TABLE, ANNOUNCEMENT_VISIBLE_COLUMNS } from '../announcements/migration';
+import { SCREENS_MIGRATION } from '../display/store';
 // Versioned schema migrations shared by the two SQLite-dialect adapters
 // (D1 and libSQL). Applied versions are recorded in the `migrations` table;
 // each adapter's runner applies whatever is newer, in order, at startup.
@@ -727,6 +728,8 @@ export const MIGRATIONS: Migration[] = [
   // single dates of a series moved (CalEvent.movedDates): a column on the
   // row, so the triggers on events (content version, event_changes) see a move
   MOVED_DATES_MIGRATION(contentVersionTriggers('events', [...CONTENT_VERSION_COLUMNS.events, 'cancelled_dates', 'moved_dates'])[2]),
+  // saved TV screens (Admin → Calendar → Screens, lib/display/store.ts)
+  SCREENS_MIGRATION,
 ];
 
 // Current cache coverage; keep earlier migration inputs frozen for upgrade compatibility.

package/src/lib/repo/sql.ts

@@ -6,6 +6,7 @@ import { GuestStore } from '../mobile/guest-store';
 import { LiveStore } from '../live/store';
 import { PushStore } from '../push/store';
 import { AnnouncementStore, announcementInsert } from '../announcements/store';
+import { ScreenStore, screenInsert, screenKey } from '../display/store';
 import { EditorStore } from '../editor/store';
 import { PermissionStore } from '../permissions/store';
 import { BackupStore } from '../backup/store';
@@ -296,6 +297,7 @@ export class SqlRepository implements ContentRepository {
   readonly editor: EditorStore;
   readonly backups: BackupStore;
   readonly permissions: PermissionStore;
+  readonly screens: ScreenStore;
 
   constructor(driver: SqlDriver | (() => Promise<SqlDriver>)) {
     this.ready = this.init(driver);
@@ -310,6 +312,7 @@ export class SqlRepository implements ContentRepository {
     this.auth = new AuthStore(async () => { await this.ready; return this.driver; });
     this.email = new EmailStore(async () => { await this.ready; return this.driver; });
     this.permissions = new PermissionStore(async () => { await this.ready; return this.driver; });
+    this.screens = new ScreenStore(async () => { await this.ready; return this.driver; });
   }
 
   private async init(driver: SqlDriver | (() => Promise<SqlDriver>)) {
@@ -1938,6 +1941,8 @@ export class SqlRepository implements ContentRepository {
       // announcements (a backup made before them leaves the current ones). Restored
       // rows never push again here: the push ledger keeps announcement:<id>
       ...(content.announcements ? [{ sql: 'DELETE FROM announcements' }, ...content.announcements.map(announcementInsert)] : []),
+      // screens come back with new keys (backups never hold them): each TV needs its new link
+      ...(content.screens ? [{ sql: 'DELETE FROM display_screens' }, ...content.screens.map((s) => screenInsert({ ...s, key: screenKey(), lastSeenAt: null }))] : []),
       ...(content.forms ?? []).map(formInsert),
       ...(content.formSubmissions ?? []).map(submissionInsert),
       ...(content.resources ?? []).map((r) => this.resourceInsert(r)),

package/src/lib/repo/types.ts

@@ -13,6 +13,7 @@ import type { AnnouncementStore } from '../announcements/store';
 import type { Announcement } from '../announcements/types';
 import type { EditorStore } from '../editor/store';
 import type { PermissionStore } from '../permissions/store';
+import type { Screen, ScreenStore } from '../display/store';
 export interface ImportRun { id: string; source: string; label: string; status: 'running' | 'done' | 'undone'; report: Record<string, unknown>; createdAt: number; updatedAt: number }
 export type ImportRecordKind = 'post' | 'page' | 'user' | 'tag' | 'media' | 'redirect' | 'nav';
 export interface ImportRecord { runId: string; kind: ImportRecordKind; sourceId: string; acmsId: string; action: 'created' | 'updated'; stamp: number }
@@ -83,6 +84,7 @@ export interface ContentRepository {
   readonly announcements: AnnouncementStore;
   readonly editor: EditorStore;
   readonly permissions: PermissionStore;
+  readonly screens: ScreenStore;
   // Bounded public catalog; fetch limit + 1 IDs without loading every body.
   listPublicContent(options: { page: number; limit: number; kind?: 'post' | 'page'; collection?: string; locale?: string; collections: string[]; defaultLocale: string }): Promise<{ id: string; kind: 'post' | 'page' }[]>;
   exportBookingState(): Promise<{ bookings: Booking[]; bookingRequests: BookingRequest[] }>;
@@ -367,6 +369,9 @@ export interface ContentRepository {
     formSubmissions?: FormSubmission[];
     // added with announcements; a backup without them leaves the current ones
     announcements?: Announcement[];
+    // saved TV screens, without their keys (each gets a new one); a backup
+    // without them leaves the current ones
+    screens?: Screen[];
   }, authRecovery?: { issuer: string; subject: string; userId: string }): Promise<void>;
 
   // imports (lib/import/apply.ts drives these). writeImported is the

package/src/lib/section-items.ts

@@ -0,0 +1,24 @@
+// The item shapes section data carries (lib/sections.ts fills them): what a
+// theme's section components and the apps' native sections receive.
+// No imports, so other packages can typecheck against them
+// (packages/native keeps its own copy; test/section-items.test.ts there
+// keeps the two in step).
+
+export interface LinkValue { label: string; href: string; external: boolean }
+/** a room this date holds, named only when set to show on public events; color null = none */
+export interface EventItemRoom { slug: string; name: string; color: string | null }
+export interface EventItem {
+  title: string; url: string; summary: string; image: string; imageAlt: string; location: string;
+  start: string; end: string; allDay: boolean; cancelled: boolean;
+  /** this date was moved here: from "Thu, Oct 1 · 6:00 PM" (where it was), with staff's public note; null when not moved */
+  moved: { from: string; note: string } | null;
+  /** the public rooms this date holds (a moved date's own, when it moved into others) */
+  rooms: EventItemRoom[];
+  /** "Sat, Oct 3 · 11:00 AM" */ when: string; /** "Saturday, October 3, 2026" */ date: string;
+  /** "11:00 AM – 1:00 PM EDT" */ time: string; month: string; day: string; weekday: string;
+  cta: { label: string; href: string } | null;
+}
+export interface PostAuthor { name: string; url: string; avatar: string }
+// excerpt: the post's own, else the first ~160 characters of its text
+export interface PostItem { title: string; url: string; excerpt: string; image: string; imageAlt: string; date: string; publishedAt: number | null; tags: string[]; authors: PostAuthor[] }
+export interface BookingItem { title: string; url: string; description: string; resource: string; minutes: number }

package/src/lib/sections.ts

@@ -28,20 +28,8 @@ type Instance = z.infer<typeof SectionInstanceSchema>;
 type Definition = z.infer<typeof SectionDefinition>;
 type FieldDef = Definition['fields'][string];
 
-export interface LinkValue { label: string; href: string; external: boolean }
-export interface EventItem {
-  title: string; url: string; summary: string; image: string; imageAlt: string; location: string;
-  start: string; end: string; allDay: boolean; cancelled: boolean;
-  /** this date was moved here: from "Thu, Oct 1 · 6:00 PM" (where it was), with staff's public note; null when not moved */
-  moved: { from: string; note: string } | null;
-  /** "Sat, Oct 3 · 11:00 AM" */ when: string; /** "Saturday, October 3, 2026" */ date: string;
-  /** "11:00 AM – 1:00 PM EDT" */ time: string; month: string; day: string; weekday: string;
-  cta: { label: string; href: string } | null;
-}
-export interface PostAuthor { name: string; url: string; avatar: string }
-// excerpt: the post's own, else the first ~160 characters of its text
-export interface PostItem { title: string; url: string; excerpt: string; image: string; imageAlt: string; date: string; publishedAt: number | null; tags: string[]; authors: PostAuthor[] }
-export interface BookingItem { title: string; url: string; description: string; resource: string; minutes: number }
+import type { BookingItem, EventItem, LinkValue, PostAuthor, PostItem } from './section-items';
+export type { BookingItem, EventItem, EventItemRoom, LinkValue, PostAuthor, PostItem } from './section-items';
 
 /** apply a theme migration when the stored instance is older than the definition */
 export function migrateSection(theme: Pick<Theme, 'sections' | 'migrations'>, s: Instance): Instance {
@@ -148,7 +136,8 @@ async function resolveSource(field: Extract<FieldDef, { type: 'source' }>, value
       return {
         title: e.title || 'Untitled event', url: lp(eventUrl(e.slug)), summary: e.excerpt, image: safeUrl(e.cover), imageAlt: e.coverAlt,
         location: locationLine(o.moved?.location ?? e.location), start: new Date(o.start).toISOString(), end: new Date(o.end).toISOString(),
-        allDay: o.allDay, cancelled: o.cancelled, moved: was && o.moved ? { from: o.allDay ? was.date : was.range, note: o.moved.note } : null, when: f.range, date: f.date, time: f.time, month: f.month, day: f.day, weekday: f.weekday,
+        allDay: o.allDay, cancelled: o.cancelled, moved: was && o.moved ? { from: o.allDay ? was.date : was.range, note: o.moved.note } : null,
+        rooms: (o.rooms ?? []).map((r) => ({ slug: r.slug, name: r.name, color: r.color || null })), when: f.range, date: f.date, time: f.time, month: f.month, day: f.day, weekday: f.weekday,
         cta: e.cta.label && ctaHref && !o.cancelled ? { label: e.cta.label, href: ctaHref } : null,
       };
     });

package/src/pages/admin/calendar/screens/index.astro

@@ -0,0 +1,24 @@
+---
+import Admin from '../../../../layouts/Admin.astro';
+import ScreensManager from '../../../../components/display/ScreensManager';
+import { getRepo } from '../../../../lib/repo';
+import { CALENDAR } from '../../../../lib/calendar/config';
+import { forbiddenUnless } from '../../../../lib/permissions/access';
+
+// Admin → Calendar → Screens: saved TV screens and quick links
+// (lib/display). A screen's link can show private calendars, so it takes the
+// same permission as calendars and rooms.
+if (!CALENDAR.enabled) return new Response(null, { status: 404, statusText: 'Not found' });
+const repo = await getRepo(Astro.locals);
+const denied = await forbiddenUnless(Astro.request, Astro.cookies, repo, 'schedule.manage');
+if (denied) return denied;
+---
+<Admin title="Screens" section="calendar:screens" wide>
+  <div class="page-head">
+    <div>
+      <h1>Screens</h1>
+      <p class="sub">Full-screen calendars for TVs. A change here reaches the TV within 5 minutes.</p>
+    </div>
+  </div>
+  <ScreensManager client:only="react" />
+</Admin>

package/src/pages/admin/calendar/screens/preview.astro

@@ -0,0 +1,36 @@
+---
+import DisplayPage from '../../../../components/display/DisplayPage.astro';
+import { getRepo } from '../../../../lib/repo';
+import { CALENDAR } from '../../../../lib/calendar/config';
+import { I18N, localePath } from '../../../../lib/i18n';
+import { siteOrigin } from '../../../../lib/seo';
+import { siteLang } from '../../../../lib/dates';
+import { accessFor, forbiddenUnless } from '../../../../lib/permissions/access';
+import { readDisplaySettings } from '../../../../lib/display/settings';
+import { loadDisplayBoard } from '../../../../lib/display/board';
+
+// The Screens editor's live preview (a 16:9 frame beside the settings): the
+// board as the TV will show it, from settings not saved yet. ?lang= picks the
+// language, ?private=1 shows what a screen with private details shows (for
+// people who may see bookings). It never refreshes, keeps no offline copy
+// and counts as no screen's check-in.
+if (!CALENDAR.enabled) return new Response(null, { status: 404 });
+const repo = await getRepo(Astro.locals);
+const denied = await forbiddenUnless(Astro.request, Astro.cookies, repo, 'schedule.manage');
+if (denied) return denied;
+const site = await repo.getSettings();
+const q = Astro.url.searchParams;
+const canPrivate = Boolean((await accessFor(Astro.request, Astro.cookies, repo))?.can('schedule.bookings'));
+const settings = readDisplaySettings(q);
+const wanted = q.get('lang') ?? '';
+const lang = I18N.enabled && I18N.locales.includes(wanted) ? wanted : siteLang(site);
+const board = await loadDisplayBoard(repo, site, {
+  settings, privateDetails: q.get('private') === '1' && canPrivate, lang,
+  phoneLink: siteOrigin(site, Astro.url) + localePath(CALENDAR.base, lang),
+});
+Astro.response.headers.set('Cache-Control', 'private, no-store');
+Astro.response.headers.set('Content-Security-Policy', "frame-ancestors 'self'");
+Astro.response.headers.set('Referrer-Policy', 'no-referrer');
+---
+
+<DisplayPage site={site} board={board} settings={settings} title="Screen preview" lang={lang} live={false} />

package/src/pages/api/calendar/screens.ts

@@ -0,0 +1,30 @@
+import type { APIRoute } from 'astro';
+import { getRepo } from '../../../lib/repo';
+import { ApiError, apiError, json, readJson } from '../../../lib/api';
+import { requirePermission } from '../../../lib/permissions/access';
+import { CALENDAR } from '../../../lib/calendar/config';
+import { siteOrigin } from '../../../lib/seo';
+import { ScreenAction, screenAction, screensState } from '../../../lib/display/screens';
+
+// Admin → Calendar → Screens: saved TV screens, for people who manage rooms
+// and calendars (a screen's link can show private calendars).
+export const GET: APIRoute = async ({ request, cookies, locals, url }) => {
+  try {
+    if (!CALENDAR.enabled) throw new ApiError(404, 'The calendar is off on this site.');
+    const repo = await getRepo(locals);
+    const access = await requirePermission(request, cookies, repo, 'schedule.manage');
+    return json(await screensState(repo, siteOrigin(await repo.getSettings(), url), { bookings: access.can('schedule.bookings') }));
+  } catch (e) { return apiError(e); }
+};
+export const POST: APIRoute = async ({ request, cookies, locals, url }) => {
+  try {
+    if (!CALENDAR.enabled) throw new ApiError(404, 'The calendar is off on this site.');
+    const repo = await getRepo(locals);
+    const access = await requirePermission(request, cookies, repo, 'schedule.manage');
+    // a screen's key unlocks private calendars: only from this site's admin
+    if (request.headers.get('origin') !== url.origin) throw new ApiError(403, 'Change this from this site’s admin.');
+    const bookings = access.can('schedule.bookings');
+    const result = await screenAction(repo, ScreenAction.parse(await readJson(request, 20_000)), { bookings });
+    return json({ ...result, state: await screensState(repo, siteOrigin(await repo.getSettings(), url), { bookings }) });
+  } catch (e) { return apiError(e); }
+};

package/src/pages/display/s/[key].astro

@@ -0,0 +1,48 @@
+---
+import DisplayPage from '../../../components/display/DisplayPage.astro';
+import { getRepo } from '../../../lib/repo';
+import { CALENDAR } from '../../../lib/calendar/config';
+import { I18N, localePath, requestLocale } from '../../../lib/i18n';
+import { siteOrigin } from '../../../lib/seo';
+import { siteLang } from '../../../lib/dates';
+import { defaultDisplaySettings, readDisplaySettings } from '../../../lib/display/settings';
+import { loadDisplayBoard } from '../../../lib/display/board';
+import { displayHeaders } from '../../../lib/display/http';
+import { MISS_WINDOW, openScreen } from '../../../lib/display/screens';
+
+// A saved screen (Admin → Calendar → Screens): its long random key is the
+// whole address. With "Show private calendars and room bookings" on, it shows
+// the private calendars it names and its rooms' bookings, with titles, rooms,
+// hosts and the name on a booking; never emails, phone numbers or notes.
+// The board's 5-minute refresh fetches this same address, so a rotated key
+// stops the TV at once and every fetch counts as the screen's check-in.
+if (!CALENDAR.enabled) return new Response(null, { status: 404 });
+const repo = await getRepo(Astro.locals);
+let address = 'unknown';
+try { address = Astro.clientAddress || address; } catch { /* adapters without a client address share a bucket */ }
+const opened = await openScreen(repo, Astro.params.key ?? '', address);
+if (opened.status === 'limited') {
+  return new Response('Too many wrong screen links from this network. Try again in a few minutes.', {
+    status: 429,
+    headers: { 'Retry-After': String(MISS_WINDOW / 1000), 'Cache-Control': 'private, no-store', 'Referrer-Policy': 'no-referrer', 'Content-Type': 'text/plain; charset=utf-8' },
+  });
+}
+const site = await repo.getSettings();
+// the address's language prefix (/es/display/s/…) picks the worker's scope
+const pathLang = I18N.enabled ? requestLocale(Astro.url, Astro.locals) : '';
+const prefix = I18N.enabled && pathLang && pathLang !== I18N.defaultLocale ? `/${pathLang}` : '';
+const screen = opened.status === 'ok' ? opened.screen : null;
+const settings = screen ? readDisplaySettings(new URLSearchParams(screen.params)) : defaultDisplaySettings();
+const lang = screen?.locale || (prefix ? pathLang : '') || siteLang(site);
+const board = screen
+  ? await loadDisplayBoard(repo, site, {
+      settings, privateDetails: screen.privateDetails, lang,
+      phoneLink: siteOrigin(site, Astro.url) + localePath(CALENDAR.base, lang),
+    })
+  : null;
+if (screen) await repo.screens.checkIn(screen.id);
+else Astro.response.status = 404;
+displayHeaders(Astro.response.headers, { shared: false });
+---
+
+<DisplayPage site={site} board={board} settings={settings} title={screen?.name || site.siteTitle} lang={lang} live sw={`${prefix}/display/sw.js`} />

package/src/styles/display.css

@@ -161,7 +161,8 @@ body { background: #000; }
 /* list: columns, then pages (the script turns them) */
 .display-list { height: 100%; overflow: hidden; }
 .display-list-cols { height: 100%; column-count: var(--dsp-list-cols, 3); column-gap: calc(3.5 * var(--dsp-u)); column-fill: auto; }
-.display-day { margin: 0 0 calc(2.2 * var(--dsp-u)); }
+/* a day stays in one column when it fits, so a column never starts without its day */
+.display-day { margin: 0 0 calc(2.2 * var(--dsp-u)); break-inside: avoid-column; }
 .display-day-title { margin: 0 0 calc(0.6 * var(--dsp-u)); font-size: calc(2.3 * var(--dsp-u)); font-weight: 700; color: var(--dsp-muted); break-after: avoid; }
 .display-day.is-today .display-day-title { color: var(--dsp-fg); }
 .display-row {