@acms-subir/core 0.3.51 → 0.3.53

package/src/components/forms/meta.ts

@@ -1,10 +1,13 @@
 // Question types, defaults and small pure helpers shared by the builder panes.
-import { CHOICE_TYPES, FIELD_ID, type FormDefinition, type FormField } from '../../lib/forms/schema';
+import { CHOICE_TYPES, FIELD_ID, type FieldWords, type FormDefinition, type FormField, type FormWords } from '../../lib/forms/schema';
+import { choiceClash } from '../../lib/forms/localize';
 
 export type FieldType = FormField['type'];
 export type Group = 'Basics' | 'Contact' | 'Other';
 export type Selection = { kind: 'field'; id: string } | { kind: 'form' } | { kind: 'submit' } | { kind: 'thanks' } | { kind: 'system'; index: number } | null;
 export type SystemField = { label: string; type: FieldType; note?: string };
+/** The language being written (code '' = the main one) and its name, the main one's, and every language's by code. */
+export type Language = { code: string; name: string; main: string; names: Record<string, string> };
 
 export const META: Record<FieldType, { label: string; group: Group; desc: string; fresh: string }> = {
   text: { label: 'Short text', group: 'Basics', desc: 'A single line, like a name or a title.', fresh: 'Short answer' },
@@ -17,12 +20,13 @@ export const META: Record<FieldType, { label: string; group: Group; desc: string
   url: { label: 'Website', group: 'Contact', desc: 'A web address. “example.org” is accepted too.', fresh: 'Website' },
   number: { label: 'Number', group: 'Other', desc: 'Any number, like a count or an age.', fresh: 'Number' },
   date: { label: 'Date', group: 'Other', desc: 'A calendar date picker.', fresh: 'Date' },
+  time: { label: 'Time', group: 'Other', desc: 'A time of day, like 6:30 PM. Stored as 18:30.', fresh: 'Time' },
   consent: { label: 'Agree checkbox', group: 'Other', desc: 'One box to tick. When required, people must tick it to send.', fresh: 'I agree to the terms' },
   heading: { label: 'Section heading', group: 'Other', desc: 'A title and description that splits a long form into parts. Not a question.', fresh: 'New section' },
   checkbox: { label: 'Checkbox', group: 'Other', desc: 'One box to tick.', fresh: 'Checkbox' },
 };
 /** Insert menu order (`checkbox` stays valid for old data but isn't offered). */
-export const INSERT: FieldType[] = ['text', 'textarea', 'radio', 'checkboxes', 'select', 'email', 'phone', 'url', 'number', 'date', 'consent', 'heading'];
+export const INSERT: FieldType[] = ['text', 'textarea', 'radio', 'checkboxes', 'select', 'email', 'phone', 'url', 'number', 'date', 'time', 'consent', 'heading'];
 export const TYPE_CHOICES: FieldType[] = [...INSERT];
 
 export const isChoice = (t: FieldType) => CHOICE_TYPES.includes(t);
@@ -46,21 +50,77 @@ export function clean(f: FormField): FormField {
   if (f.placeholder && takesPlaceholder(f)) out.placeholder = f.placeholder;
   if (f.width === 'half' && f.type !== 'heading') out.width = 'half';
   if (f.allowOther && canOther(f.type)) out.allowOther = true;
+  const translations = cleanFieldWords(out, f.translations);
+  if (translations) out.translations = translations;
   return out;
 }
 
+const blank = (v: string | undefined) => !v || !v.trim();
+// Another language's words for a question: blank ones (and languages left
+// with none) are dropped, and so are words its type doesn't show. Choices
+// line up with the main ones by position.
+function cleanFieldWords(f: FormField, translations: FormField['translations']): FormField['translations'] {
+  const out: NonNullable<FormField['translations']> = {};
+  for (const [locale, t] of Object.entries(translations ?? {})) {
+    const w: FieldWords = {};
+    if (!blank(t.label)) w.label = t.label;
+    if (!blank(t.help)) w.help = t.help;
+    if (!blank(t.placeholder) && takesPlaceholder(f)) w.placeholder = t.placeholder;
+    if (isChoice(f.type) && t.options?.some(o => !blank(o))) {
+      const options = f.options.map((_, i) => t.options?.[i] ?? '');
+      while (blank(options[options.length - 1])) options.pop();
+      w.options = options;
+    }
+    if (Object.keys(w).length) out[locale] = w;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
+/** The question with some of its words in `locale` changed. */
+export const withFieldWords = (f: FormField, locale: string, next: FieldWords): FormField =>
+  clean({ ...f, translations: { ...f.translations, [locale]: { ...f.translations?.[locale], ...next } } });
+
+/** The form's title, introduction, button or thank-you in `locale` changed (blank ones dropped). */
+export function withFormWords(d: FormDefinition, locale: string, next: FormWords): Pick<FormDefinition, 'translations'> {
+  const all = { ...d.translations, [locale]: { ...d.translations?.[locale], ...next } };
+  const out: NonNullable<FormDefinition['translations']> = {};
+  for (const [l, t] of Object.entries(all)) {
+    const w = Object.fromEntries(Object.entries(t).filter(([, v]) => !blank(v)));
+    if (Object.keys(w).length) out[l] = w;
+  }
+  return { translations: Object.keys(out).length ? out : undefined };
+}
+
+/** Each language's choices follow their main choice when choices are added, removed or moved (map: new position → old one, -1 for a new choice). */
+export function remapChoices(translations: FormField['translations'], map: number[]): FormField['translations'] {
+  if (!translations) return translations;
+  return Object.fromEntries(Object.entries(translations).map(([l, t]) => [l, t.options ? { ...t, options: map.map(i => (i >= 0 ? t.options?.[i] ?? '' : '')) } : t]));
+}
+
 export function newField(type: FieldType, taken: string[]): FormField {
   const label = META[type].fresh;
   return clean({ id: keyFrom(label, taken), type, label, required: false, help: '', options: isChoice(type) ? ['Option 1', 'Option 2'] : [] });
 }
 
-/** Switching type keeps the label/help; choice lists survive between choice types. */
-export function switchType(f: FormField, type: FieldType, remembered?: string[]): FormField {
-  const options = isChoice(type) ? (f.options.length ? f.options : remembered?.length ? remembered : ['Option 1', 'Option 2']) : [];
-  return clean({ ...f, type, options });
+/** Choices kept while a question is some other type: the main ones and each language's. */
+export interface RememberedChoices { options: string[]; words: Record<string, string[]> }
+export const rememberChoices = (f: FormField): RememberedChoices => ({
+  options: f.options, words: Object.fromEntries(Object.entries(f.translations ?? {}).flatMap(([l, t]) => (t.options?.length ? [[l, t.options]] : []))),
+});
+
+/** Switching type keeps the label/help; choice lists (and their translations) survive between choice types. */
+export function switchType(f: FormField, type: FieldType, remembered?: RememberedChoices): FormField {
+  const restore = isChoice(type) && !f.options.length && !!remembered?.options.length;
+  const options = isChoice(type) ? (f.options.length ? f.options : restore ? remembered!.options : ['Option 1', 'Option 2']) : [];
+  const translations = restore
+    ? Object.fromEntries([...new Set([...Object.keys(f.translations ?? {}), ...Object.keys(remembered!.words)])]
+      .map((l) => [l, { ...(f.translations?.[l] ?? {}), ...(remembered!.words[l] ? { options: remembered!.words[l] } : {}) }]))
+    : f.translations;
+  return clean({ ...f, type, options, translations });
 }
 
-export function fieldIssue(f: FormField, all: FormField[]): string {
+/** names: language names by locale, for a translated choice that reads the same as another one */
+export function fieldIssue(f: FormField, all: FormField[], names: Record<string, string> = {}): string {
   if (!f.label.trim()) return 'Needs a label.';
   if (!FIELD_ID.test(f.id)) return 'Answer key must start with a letter and use letters, numbers, - or _.';
   if (all.filter(x => x.id === f.id).length > 1) return 'Answer key is used twice.';
@@ -68,12 +128,14 @@ export function fieldIssue(f: FormField, all: FormField[]): string {
     if (!f.options.length) return 'Add at least one choice.';
     if (f.options.some(o => !o.trim())) return 'A choice is empty.';
     if (new Set(f.options.map(o => o.trim())).size !== f.options.length) return 'Two choices are the same.';
+    const clash = choiceClash(f);
+    if (clash) return `In ${names[clash.locale] ?? clash.locale.toUpperCase()}, “${clash.text.trim()}” is used for two choices.`;
   }
   return '';
 }
 
-export function definitionIssue(d: FormDefinition): string {
-  for (const f of d.fields) { const issue = fieldIssue(f, d.fields); if (issue) return `“${f.label || META[f.type].label}”: ${issue}`; }
+export function definitionIssue(d: FormDefinition, names: Record<string, string> = {}): string {
+  for (const f of d.fields) { const issue = fieldIssue(f, d.fields, names); if (issue) return `“${f.label || META[f.type].label}”: ${issue}`; }
   return '';
 }
 

package/src/layouts/Admin.astro

@@ -128,6 +128,8 @@ const groups: { id: string; label: string; items: Item[] }[] = [
           ...(CALENDAR.enabled && can('schedule.bookings')
             ? [{ key: 'calendar:bookings', label: 'Bookings', href: '/admin/calendar/bookings', icon: icons.bookings, count: pendingBookings || null, attention: pendingBookings > 0 }]
             : []),
+          // TV screens: saved display links (lib/display), with private details behind their key
+          ...(can('schedule.manage') ? [{ key: 'calendar:screens', label: 'Screens', href: '/admin/calendar/screens', icon: icons.monitor, count: null }] : []),
         ],
       }]
     : []),

package/src/lib/backup/content.ts

@@ -9,6 +9,13 @@ import type { ContentRepository } from '../repo/types';
 const legacyApproval = (l: unknown) =>
   l && typeof l === 'object' && !('approval' in l) && (l as { autoConfirm?: boolean }).autoConfirm === false ? { ...l, approval: 'manual' } : l;
 
+// a saved TV screen (lib/display/store.ts). Its key never goes into a
+// backup: a restored screen gets a new one
+export const ScreenRecord = z.object({
+  id: z.string().min(1), name: z.string().max(200).default(''), params: z.string().max(4000).default(''), locale: z.string().max(20).default(''),
+  privateDetails: z.boolean().default(false), key: z.string().default(''), lastSeenAt: z.number().nullable().default(null),
+  order: z.number().default(0), createdAt: z.number(), updatedAt: z.number(),
+});
 export const BookingRequest = z.object({ keyHash: z.string().regex(/^[a-f0-9]{64}$/), requestHash: z.string().regex(/^[a-f0-9]{64}$/), bookingId: z.string().min(1), createdAt: z.number().int().nonnegative() });
 export type BookingRequest = z.infer<typeof BookingRequest>;
 export const BackupContent = z.object({
@@ -21,6 +28,7 @@ export const BackupContent = z.object({
   forms: z.array(SavedForm).optional(), formSubmissions: z.array(FormSubmission).optional(),
   // optional (no version bump): older cores restore such a backup and skip them
   announcements: z.array(AnnouncementRecord).optional(),
+  screens: z.array(ScreenRecord).optional(),
 }).superRefine((data, ctx) => {
   if (data.version >= 6 && (!data.forms || !data.formSubmissions)) ctx.addIssue({ code: 'custom', message: 'Version 6 requires forms and their submissions.' });
   if (data.version >= 5 && !data.bookingRequests) ctx.addIssue({ code: 'custom', message: 'Version 5 requires booking retry records.' });
@@ -39,12 +47,13 @@ export async function exportContent(repo: ContentRepository, now = Date.now()) {
     repo.listUsers(), repo.listRedirects(), repo.listCalendars(), repo.listEvents(), repo.listResources(), repo.listBookingLinks(), repo.exportBookingState(),
     repo.listPlaces(), repo.forms.list(), repo.forms.submissions(undefined, -1),
   ]);
-  const announcements = await repo.announcements.list(-1);
+  const [announcements, screens] = await Promise.all([repo.announcements.list(-1), repo.screens.list()]);
   return {
     format: 'acms-backup' as const, version: 6, exportedAt: new Date(now).toISOString(),
     settings: { ...settings, live: { ...settings.live, mode: 'off' as const, manual: { watchUrl: '', title: 'We’re live', until: 0 } }, ai: { ...settings.ai, enabled: false, encryptedKey: '' }, agent: { ...settings.agent, enabled: false, keyHash: '', keyPrefix: '', allowPublish: false }, monitoring: { ...settings.monitoring, pushUrl: '' } },
     pages, posts, media, links, tags, navItems, users, redirects,
     calendars: calendars.map(c => ({ ...c, feedToken: '' })), events,
     resources: resources.map(r => ({ ...r, feedToken: '' })), bookingLinks, ...bookingState, places, forms, formSubmissions, announcements,
+    screens: screens.map(s => ({ ...s, key: '', lastSeenAt: null })),
   };
 }

package/src/lib/calendar/api.ts

@@ -6,6 +6,7 @@
 import { roomColor, type CalEvent, type Calendar, type MovedDate, type Resource } from '../schema';
 import { calendarFeedUrl, eventIcsUrl, eventUrl, publicEventFields } from './config';
 import { describeRepeat } from './rrule';
+import { localizeForm } from '../forms/localize';
 
 export interface EventJson {
   id: string;
@@ -90,7 +91,8 @@ export function eventToJson(e: CalEvent, origin: string, calendars: Map<string,
     movedDates: movedDatesToJson(e, opts.includePrivate),
     location: e.location,
     cta: e.cta,
-    rsvp: opts.includePrivate ? e.rsvp : (({ notifyStaff: _, ...rsvp }) => rsvp)(e.rsvp),
+    // public: the RSVP form in the main language, without its translations (GET /events/{slug}/rsvp?locale= has it in a language)
+    rsvp: opts.includePrivate ? e.rsvp : (({ notifyStaff: _, ...rsvp }) => (rsvp.form ? { ...rsvp, form: localizeForm(rsvp.form, '') } : rsvp))(e.rsvp),
     image: e.cover ? abs(origin, e.cover) : '',
     imageAlt: e.coverAlt,
     tags: e.tags.filter((t) => !t.startsWith('#')),

package/src/lib/display/board.ts

@@ -15,7 +15,7 @@ import { addDays, dayOfWeek, monthWeeks, startOfWeek, type Iso } from '../calend
 import { siteLang, siteLocale } from '../dates';
 import { DEFAULT_HOURS, MIN_AUTO_HOURS, type DisplaySettings, type HourRange } from './settings';
 import { renderBoard, type DisplayItem, type DisplayModel, type DisplayRoom } from './render';
-import { displayStrings } from './words';
+import { displayStrings, isBookedWord } from './words';
 import { qrSvg } from './http';
 
 export const GOOGLE_BOOKING_TAG = '#google-booking';
@@ -200,8 +200,9 @@ function displayItem(v: ViewEvent, i: number, c: ItemContext): DisplayItem {
     key: `${ev?.id ?? v.ref ?? 'x'}:${v.start}:${i}`,
     kind: ev ? 'event' : v.rooms ? 'booking' : 'feed',
     title: booked ? c.words.booked : v.title,
-    // under "Booked", a private screen also names the appointment
-    detail: booked && c.privateDetails ? v.title : '',
+    // under "Booked", a private screen also names the appointment (unless
+    // its title is just "Booked", as the Google sync makes them)
+    detail: booked && c.privateDetails && !isBookedWord(v.title) ? v.title : '',
     start: v.start, end: v.end, allDay: v.allDay,
     startDay, endDay,
     startMin: v.allDay ? 0 : s.min,

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/dynamicBlocks.ts

@@ -5,6 +5,7 @@ import { formatDate } from './dates';
 import { CONTENT, collectionUrl } from './content';
 import { renderCalendarBlock, isNativeSource } from './calendar/render';
 import { renderEventCards, type EventCardAttrs } from './calendar/cards';
+import { localePath } from './i18n';
 
 // Dynamic blocks: bodyHtml is a save-time cache, so cards whose content must
 // stay fresh (post lists, calendars) serialize as placeholder divs and get
@@ -131,7 +132,8 @@ function eventCardAttrs(tag: string): EventCardAttrs {
   };
 }
 
-export async function expandDynamicBlocks(html: string, repo: ContentRepository): Promise<string> {
+// locale: the page's language; a form block opens the form in it (/es/forms/<id>)
+export async function expandDynamicBlocks(html: string, repo: ContentRepository, locale = ''): Promise<string> {
   html = stampHeadingAnchors(html);
   const hasForms = html.includes('data-dyn="form"');
   const hasPostList = html.includes('data-dyn="post-list"');
@@ -168,7 +170,7 @@ export async function expandDynamicBlocks(html: string, repo: ContentRepository)
       // A same-origin frame gives each visitor an uncached form/receipt even
       // when the containing content page is served from a shared cache.
       calendarHtml.set(tag, form?.kind === 'form' && form.purpose === 'general' && form.status === 'published'
-        ? `<iframe class="pc-form-embed" src="/forms/${encodeURIComponent(form.id)}?embed=1" title="${esc(form.definition.title || form.name)}" loading="lazy"></iframe>` : '');
+        ? `<iframe class="pc-form-embed" src="${localePath(`/forms/${encodeURIComponent(form.id)}`, locale)}?embed=1" title="${esc(form.definition.title || form.name)}" loading="lazy"></iframe>` : '');
     }));
   }
   const anchored = html;

package/src/lib/forms/fields.ts

@@ -1,13 +1,18 @@
 import { hasOther, isHalf, type FormDefinition, type FormField } from './schema';
 import { OTHER } from './validate';
+import { formStrings, type FormStrings } from './words';
+import { fill } from '../live/words';
 export const escapeForm = (s: string) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
 const e = escapeForm;
-const inputType: Partial<Record<FormField['type'], string>> = { phone: 'tel', email: 'email', number: 'number', date: 'date' };
+const inputType: Partial<Record<FormField['type'], string>> = { phone: 'tel', email: 'email', number: 'number', date: 'date', time: 'time' };
 // Websites use a text box so "example.org" can be typed; the server adds https://.
 const autocomplete: Partial<Record<FormField['type'], string>> = { email: 'email', phone: 'tel', url: 'url' };
+// Questions arrive in the page's language already (localize.ts localizeForm);
+// `w` is the form's own words around them (words.ts), English by default.
+const english = formStrings('en');
 
 /** The answer control alone (input, select, textarea or option list). The builder canvas reuses it under editable labels. */
-export function renderControl(f: FormField, value: string, id: string): string {
+export function renderControl(f: FormField, value: string, id: string, w: FormStrings = english): string {
   const describe = f.help ? ` aria-describedby="${e(id)}-help"` : '';
   const attrs = `id="${e(id)}" name="q_${e(f.id)}"${f.required ? ' required' : ''}${describe}`;
   const ph = f.placeholder ? ` placeholder="${e(f.placeholder)}"` : '';
@@ -17,31 +22,31 @@ export function renderControl(f: FormField, value: string, id: string): string {
     // A required checkbox group can't be enforced natively; the server checks it.
     const req = radio && f.required ? ' required' : '';
     const option = (o: string, i: number) => `<label class="pc-bk-option"><input type="${radio ? 'radio' : 'checkbox'}" id="${e(id)}-${i}" name="q_${e(f.id)}" value="${e(o)}"${req}${chosen.includes(o) ? ' checked' : ''}/><span>${e(o)}</span></label>`;
-    const other = hasOther(f) ? `<label class="pc-bk-option pc-bk-other"><input type="${radio ? 'radio' : 'checkbox'}" name="q_${e(f.id)}" value="${OTHER}"${req}${extra ? ' checked' : ''}/><span>Other</span><input type="text" name="o_${e(f.id)}" maxlength="200" aria-label="Other answer for ${e(f.label)}" placeholder="${e(f.placeholder || 'Type your answer')}" value="${e(extra)}"/></label>` : '';
+    const other = hasOther(f) ? `<label class="pc-bk-option pc-bk-other"><input type="${radio ? 'radio' : 'checkbox'}" name="q_${e(f.id)}" value="${OTHER}"${req}${extra ? ' checked' : ''}/><span>${e(w.other)}</span><input type="text" name="o_${e(f.id)}" maxlength="200" aria-label="${e(fill(w.otherAnswer, { label: f.label }))}" placeholder="${e(f.placeholder || w.typeAnswer)}" value="${e(extra)}"/></label>` : '';
     return `<div class="pc-bk-options">${f.options.map(option).join('')}${other}</div>`;
   }
   if (f.type === 'textarea') return `<textarea ${attrs}${ph} maxlength="2000" rows="3">${e(value)}</textarea>`;
-  if (f.type === 'select') return `<select ${attrs}><option value="">${e(f.placeholder || 'Choose…')}</option>${f.options.map(o => `<option value="${e(o)}" ${o === value ? 'selected' : ''}>${e(o)}</option>`).join('')}</select>`;
+  if (f.type === 'select') return `<select ${attrs}><option value="">${e(f.placeholder || w.choose)}</option>${f.options.map(o => `<option value="${e(o)}" ${o === value ? 'selected' : ''}>${e(o)}</option>`).join('')}</select>`;
   const ac = (autocomplete[f.type] ? ` autocomplete="${autocomplete[f.type]}"` : '') + (f.type === 'url' ? ' inputmode="url" spellcheck="false"' : '');
   return `<input ${attrs}${ph}${ac} type="${inputType[f.type] ?? 'text'}"${f.type === 'number' ? ' step="any"' : ''} maxlength="${f.type === 'phone' ? 40 : 2000}" value="${e(value)}"/>`;
 }
 
-export function renderField(f: FormField, value: string, prefix: string): string {
+export function renderField(f: FormField, value: string, prefix: string, w: FormStrings = english): string {
   const id = `${prefix}-${f.id}`, half = isHalf(f) ? ' is-half' : '';
   const help = f.help ? `<small id="${e(id)}-help">${e(f.help)}</small>` : '';
   const label = `${e(f.label)}${f.required ? ' *' : ''}`;
   if (f.type === 'heading') return `<div class="pc-form-heading" id="${e(id)}"><h3>${e(f.label)}</h3>${f.help ? `<p>${e(f.help)}</p>` : ''}</div>`;
   if (f.type === 'checkbox' || f.type === 'consent') return `<label class="pc-bk-check${half}" for="${e(id)}"><input type="checkbox" id="${e(id)}" name="q_${e(f.id)}" ${f.required ? 'required' : ''} ${f.help ? `aria-describedby="${e(id)}-help"` : ''} value="yes" ${value === 'yes' ? 'checked' : ''}/><span>${label}${help}</span></label>`;
-  if (f.type === 'radio' || f.type === 'checkboxes') return `<fieldset class="pc-bk-field pc-bk-choices${half}"${f.help ? ` aria-describedby="${e(id)}-help"` : ''}><legend>${label}</legend>${renderControl(f, value, id)}${help}</fieldset>`;
-  return `<label class="pc-bk-field${half}" for="${e(id)}"><span>${label}</span>${renderControl(f, value, id)}${help}</label>`;
+  if (f.type === 'radio' || f.type === 'checkboxes') return `<fieldset class="pc-bk-field pc-bk-choices${half}"${f.help ? ` aria-describedby="${e(id)}-help"` : ''}><legend>${label}</legend>${renderControl(f, value, id, w)}${help}</fieldset>`;
+  return `<label class="pc-bk-field${half}" for="${e(id)}"><span>${label}</span>${renderControl(f, value, id, w)}${help}</label>`;
 }
 
 /** Two consecutive half-width questions share a `.pc-form-row` (side by side when there's room). */
-export function renderFields(definition: FormDefinition, values: Record<string, string> = {}, prefix = 'form'): string {
+export function renderFields(definition: FormDefinition, values: Record<string, string> = {}, prefix = 'form', w: FormStrings = english): string {
   const out: string[] = []; let row: string[] = [];
   const flush = () => { if (row.length) out.push(`<div class="pc-form-row">${row.join('')}</div>`); row = []; };
   for (const f of definition.fields) {
-    const html = renderField(f, values[f.id] ?? '', prefix);
+    const html = renderField(f, values[f.id] ?? '', prefix, w);
     if (isHalf(f)) { row.push(html); if (row.length === 2) flush(); }
     else { flush(); out.push(html); }
   }