ferst-core 0.7.0 → 0.7.4

package/lib/documents.ts

@@ -1,62 +1,68 @@
-/**
- * The `documents` block's list logic: newest first (dated items by date, undated ones
- * after, in the order given), an optional grouping by year, a file-type label from the
- * extension, and a readable date. Pure — the component only renders the result.
- */
-export interface DocumentItem {
-  title: string;
-  file: string;
-  date?: string;
-  note?: string;
-}
-export interface DocumentRow extends DocumentItem {
-  kind: string;
-  dateLabel?: string;
-}
-export interface DocumentGroup {
-  year: string | null;
-  items: DocumentRow[];
-}
-
-const KINDS: Record<string, string> = {
-  pdf: 'PDF', doc: 'Word', docx: 'Word', xls: 'Excel', xlsx: 'Excel', csv: 'CSV',
-  ppt: 'PowerPoint', pptx: 'PowerPoint', odt: 'Document', rtf: 'Document', txt: 'Text',
-  jpg: 'Image', jpeg: 'Image', png: 'Image', zip: 'ZIP',
-};
-
-export function fileKind(file: string): string {
-  const ext = file.split(/[?#]/)[0].split('.').pop()?.toLowerCase() ?? '';
-  return KINDS[ext] ?? 'File';
-}
-
-/** A valid ISO-ish date (YYYY-MM-DD…) → a Date, else null. */
-function parseDate(d: string | undefined): Date | null {
-  if (!d || !/^\d{4}-\d{2}-\d{2}/.test(d)) return null;
-  const t = new Date(d.slice(0, 10) + 'T00:00:00Z');
-  return Number.isNaN(t.getTime()) ? null : t;
-}
-
-export function documentGroups(items: DocumentItem[], groupByYear = false): DocumentGroup[] {
-  const rows = items.map((item, i) => {
-    const d = parseDate(item.date);
-    return {
-      row: {
-        ...item,
-        kind: fileKind(item.file),
-        dateLabel: d ? d.toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric', timeZone: 'UTC' }) : undefined,
-      } as DocumentRow,
-      time: d?.getTime() ?? null,
-      year: d ? String(d.getUTCFullYear()) : null,
-      i,
-    };
-  });
-  rows.sort((a, b) => (a.time !== null && b.time !== null ? b.time - a.time : a.time !== null ? -1 : b.time !== null ? 1 : a.i - b.i));
-  if (!groupByYear) return [{ year: null, items: rows.map((r) => r.row) }];
-  const groups: DocumentGroup[] = [];
-  for (const r of rows) {
-    const last = groups[groups.length - 1];
-    if (last && last.year === r.year) last.items.push(r.row);
-    else groups.push({ year: r.year, items: [r.row] });
-  }
-  return groups;
-}
+/**
+ * The `documents` block's list logic: newest first (dated items by date, undated ones
+ * after, in the order given), an optional grouping by year, a file-type label from the
+ * extension, and a readable date. Pure — the component only renders the result.
+ */
+export interface DocumentItem {
+  title: string;
+  file: string;
+  date?: string;
+  note?: string;
+}
+export interface DocumentRow extends DocumentItem {
+  kind: string;
+  dateLabel?: string;
+}
+export interface DocumentGroup {
+  year: string | null;
+  items: DocumentRow[];
+}
+
+const KINDS: Record<string, string> = {
+  pdf: 'PDF', doc: 'Word', docx: 'Word', xls: 'Excel', xlsx: 'Excel', csv: 'CSV',
+  ppt: 'PowerPoint', pptx: 'PowerPoint', odt: 'Document', rtf: 'Document', txt: 'Text',
+  jpg: 'Image', jpeg: 'Image', png: 'Image', zip: 'ZIP',
+};
+
+export function fileKind(file: string): string {
+  const ext = file.split(/[?#]/)[0].split('.').pop()?.toLowerCase() ?? '';
+  return KINDS[ext] ?? 'File';
+}
+
+/** A YYYY-MM-DD date as "4 October 2026" (UTC, so it never shifts a day); else undefined. */
+export function longDate(d: string | undefined): string | undefined {
+  const t = parseDate(d);
+  return t ? t.toLocaleDateString('en-GB', { day: 'numeric', month: 'long', year: 'numeric', timeZone: 'UTC' }) : undefined;
+}
+
+/** A valid ISO-ish date (YYYY-MM-DD…) → a Date, else null. */
+function parseDate(d: string | undefined): Date | null {
+  if (!d || !/^\d{4}-\d{2}-\d{2}/.test(d)) return null;
+  const t = new Date(d.slice(0, 10) + 'T00:00:00Z');
+  return Number.isNaN(t.getTime()) ? null : t;
+}
+
+export function documentGroups(items: DocumentItem[], groupByYear = false): DocumentGroup[] {
+  const rows = items.map((item, i) => {
+    const d = parseDate(item.date);
+    return {
+      row: {
+        ...item,
+        kind: fileKind(item.file),
+        dateLabel: longDate(item.date),
+      } as DocumentRow,
+      time: d?.getTime() ?? null,
+      year: d ? String(d.getUTCFullYear()) : null,
+      i,
+    };
+  });
+  rows.sort((a, b) => (a.time !== null && b.time !== null ? b.time - a.time : a.time !== null ? -1 : b.time !== null ? 1 : a.i - b.i));
+  if (!groupByYear) return [{ year: null, items: rows.map((r) => r.row) }];
+  const groups: DocumentGroup[] = [];
+  for (const r of rows) {
+    const last = groups[groups.length - 1];
+    if (last && last.year === r.year) last.items.push(r.row);
+    else groups.push({ year: r.year, items: [r.row] });
+  }
+  return groups;
+}

package/lib/embed-consent.ts

@@ -1,73 +1,78 @@
-/**
- * Shared client-side loader for consent-gated third-party embeds (Google Calendar,
- * Google Maps, the Locations tiles). One implementation, so every embed gates,
- * loads and reacts to consent identically — instead of the same ~25-line script
- * copied into each component (where a fix, or a bug, lands in only one copy).
- *
- * Behaviour: nothing loads until the visitor consents. Accepting the site cookie
- * banner (or the footer preferences panel) grants the shared consent and
- * auto-loads EVERY registered embed on the page; the per-embed button is a
- * fallback that grants that same shared consent. Consent is remembered per
- * visitor. Import from a component `<script>` (it touches the DOM).
- *
- * Each embed root element carries the data the loader needs:
- *   data-embed-url   the https URL to load (required)
- *   data-title       the iframe title (optional)
- *   data-height      pixel height, for fixed-height embeds (optional)
- * and contains a `frame` slot (filled with the iframe), a `consent` card (hidden
- * once loaded) and a `button` that grants consent.
- */
-import { hasConsent, setConsent, onConsentChange } from './consent-client';
-
-export interface EmbedConsentConfig {
-  /** Selector for each embed root (one per embed on the page). */
-  root: string;
-  /** Selector, within a root, of the empty slot the iframe is injected into. */
-  frame: string;
-  /** Selector, within a root, of the consent card to hide once loaded. */
-  consent: string;
-  /** Selector, within a root, of the button that grants consent. */
-  button: string;
-  /** Build the iframe for one root — lets each embed set its own src / size / attrs. */
-  buildFrame: (el: HTMLElement, url: string) => HTMLIFrameElement;
-}
-
-/** Wire up every consent-gated embed matching `cfg.root`. Call once per component. */
-export function initEmbedConsent(cfg: EmbedConsentConfig): void {
-  const roots = document.querySelectorAll<HTMLElement>(cfg.root);
-  if (!roots.length) return;
-
-  function load(el: HTMLElement): void {
-    if (el.dataset.loaded === 'true') return;
-    const url = el.dataset.embedUrl;
-    const slot = el.querySelector<HTMLElement>(cfg.frame);
-    if (!url || !slot) return;
-    slot.replaceChildren(cfg.buildFrame(el, url));
-    el.dataset.loaded = 'true';
-    const card = el.querySelector<HTMLElement>(cfg.consent);
-    if (card) card.hidden = true;
-  }
-  const loadAll = (): void => roots.forEach(load);
-
-  if (hasConsent()) loadAll();
-  onConsentChange((allowed) => { if (allowed) loadAll(); });
-  roots.forEach((el) => {
-    el.querySelector<HTMLButtonElement>(cfg.button)?.addEventListener('click', () => setConsent(true));
-  });
-}
-
-/** Build a standard lazy embed iframe (100% width, 0 border). */
-export function makeEmbedFrame(
-  src: string,
-  opts: { title?: string; height?: string; referrer?: boolean } = {},
-): HTMLIFrameElement {
-  const f = document.createElement('iframe');
-  f.src = src;
-  if (opts.title) f.title = opts.title;
-  f.loading = 'lazy';
-  if (opts.referrer) f.referrerPolicy = 'no-referrer-when-downgrade';
-  f.style.width = '100%';
-  f.style.height = opts.height ?? '100%';
-  f.style.border = '0';
-  return f;
-}
+/**
+ * Shared client-side loader for consent-gated third-party embeds (Google Calendar,
+ * Google Maps, the Locations tiles). One implementation, so every embed gates,
+ * loads and reacts to consent identically — instead of the same ~25-line script
+ * copied into each component (where a fix, or a bug, lands in only one copy).
+ *
+ * Behaviour: nothing loads until the visitor consents. Accepting the site cookie
+ * banner (or the footer preferences panel) grants the shared consent and
+ * auto-loads EVERY registered embed on the page; the per-embed button is a
+ * fallback that grants that same shared consent. Consent is remembered per
+ * visitor. Import from a component `<script>` (it touches the DOM).
+ *
+ * Each embed root element carries the data the loader needs:
+ *   data-embed-url   the https URL to load (required)
+ *   data-title       the iframe title (optional)
+ *   data-height      pixel height, for fixed-height embeds (optional)
+ * and contains a `frame` slot (filled with the iframe), a `consent` card (hidden
+ * once loaded) and a `button` that grants consent.
+ */
+import { hasConsent, setConsent, onConsentChange } from './consent-client';
+
+export interface EmbedConsentConfig {
+  /** Selector for each embed root (one per embed on the page). */
+  root: string;
+  /** Selector, within a root, of the empty slot the iframe is injected into. */
+  frame: string;
+  /** Selector, within a root, of the consent card to hide once loaded. */
+  consent: string;
+  /** Selector, within a root, of the button that grants consent. */
+  button: string;
+  /** Build the iframe for one root — lets each embed set its own src / size / attrs. */
+  buildFrame: (el: HTMLElement, url: string) => HTMLIFrameElement;
+}
+
+/** Wire up every consent-gated embed matching `cfg.root`. Call once per component. */
+export function initEmbedConsent(cfg: EmbedConsentConfig): void {
+  const roots = document.querySelectorAll<HTMLElement>(cfg.root);
+  if (!roots.length) return;
+
+  function load(el: HTMLElement): void {
+    if (el.dataset.loaded === 'true') return;
+    const url = el.dataset.embedUrl;
+    const slot = el.querySelector<HTMLElement>(cfg.frame);
+    if (!url || !slot) return;
+    slot.replaceChildren(cfg.buildFrame(el, url));
+    el.dataset.loaded = 'true';
+    const card = el.querySelector<HTMLElement>(cfg.consent);
+    if (card) card.hidden = true;
+  }
+  // An embed marked `data-on-demand="true"` (e.g. a live stream that's often off air)
+  // never loads just because consent exists: only its own button loads it.
+  const loadAll = (): void => roots.forEach((el) => { if (el.dataset.onDemand !== 'true') load(el); });
+
+  if (hasConsent()) loadAll();
+  onConsentChange((allowed) => { if (allowed) loadAll(); });
+  roots.forEach((el) => {
+    el.querySelector<HTMLButtonElement>(cfg.button)?.addEventListener('click', () => {
+      setConsent(true);
+      if (el.dataset.onDemand === 'true') load(el);
+    });
+  });
+}
+
+/** Build a standard lazy embed iframe (100% width, 0 border). */
+export function makeEmbedFrame(
+  src: string,
+  opts: { title?: string; height?: string; referrer?: boolean } = {},
+): HTMLIFrameElement {
+  const f = document.createElement('iframe');
+  f.src = src;
+  if (opts.title) f.title = opts.title;
+  f.loading = 'lazy';
+  if (opts.referrer) f.referrerPolicy = 'no-referrer-when-downgrade';
+  f.style.width = '100%';
+  f.style.height = opts.height ?? '100%';
+  f.style.border = '0';
+  return f;
+}

package/lib/inline-markdown.ts

@@ -37,6 +37,18 @@ function inlineFormat(escaped: string): string {
     .replace(/\n/g, '<br>');
 }
 
+/** Escaped text with single newlines → `<br>`, and no links: for text that already sits
+ *  inside a link (a nested <a> is invalid). */
+export function textWithBreaks(text: string | undefined | null): string {
+  return text ? escapeHtml(text).replace(/\n/g, '<br>') : '';
+}
+
+/** Inline formatting (bold, italic, line breaks) WITHOUT links: `[label](href)` becomes
+ *  its label. For text inside something that is already a link (a linked tile or card). */
+export function inlineMarkdownNoLinks(text: string | undefined | null): string {
+  return text ? inlineFormat(escapeHtml(text.replace(LINK_RE, '$1'))) : '';
+}
+
 export function inlineMarkdown(text: string | undefined | null): string {
   if (!text) return '';
   let out = '';

package/lib/links.ts

@@ -0,0 +1,12 @@
+/**
+ * The icon a link deserves, read from the link itself — so an editor writes a phone
+ * number, an email or a web address and the row shows the right symbol without choosing.
+ */
+import type { IconKey } from './icons';
+
+export function linkIcon(href: string): IconKey {
+  if (/^tel:/i.test(href)) return 'phone';
+  if (/^mailto:/i.test(href)) return 'email';
+  if (/^https?:\/\//i.test(href)) return 'globe';
+  return 'arrow';
+}

package/lib/paginate.ts

@@ -0,0 +1,23 @@
+/**
+ * Pagination for post listings (the index and tag pages). Page 1 lives at the listing's
+ * own URL; later pages at `<base>/page/<n>`. Pure, unit-tested.
+ */
+export function pageCount(total: number, perPage: number): number {
+  return Math.max(1, Math.ceil(total / Math.max(1, perPage)));
+}
+
+export function pageSlice<T>(items: T[], page: number, perPage: number): T[] {
+  return items.slice((page - 1) * perPage, page * perPage);
+}
+
+export function pageHref(base: string, page: number): string {
+  return page <= 1 ? base : `${base}/page/${page}`;
+}
+
+/** Newer (prev) and older (next) page links, where they exist. */
+export function pagerLinks(base: string, page: number, pages: number): { prev?: string; next?: string } {
+  return {
+    prev: page > 1 ? pageHref(base, page - 1) : undefined,
+    next: page < pages ? pageHref(base, page + 1) : undefined,
+  };
+}

package/lib/posts.ts

@@ -13,6 +13,7 @@
  *   // <PostArticle ...><Content /></PostArticle>
  */
 import { getCollection, getEntry, type CollectionEntry } from 'astro:content';
+import { pageCount } from './paginate';
 import {
   postsSettingsSchema,
   tagSchema,
@@ -92,6 +93,23 @@ export async function getPostRoutes() {
 
 /** `getStaticPaths` for a tag route (`tags/[...tag].astro`). */
 export async function getTagRoutes() {
-  const tags = await getUsedTags();
-  return tags.map((tag) => ({ params: { tag: tag.slug }, props: { tag } }));
+  const [tags, settings] = await Promise.all([getUsedTags(), getPostsSettings()]);
+  // Page 1 at /posts/tag/<slug>; later pages at /posts/tag/<slug>/page/<n>.
+  return tags.flatMap((tag) => {
+    const pages = pageCount(tag.count, settings.perPage);
+    return Array.from({ length: pages }, (_, i) => ({
+      params: { tag: i === 0 ? tag.slug : `${tag.slug}/page/${i + 1}` },
+      props: { tag, page: i + 1, pages },
+    }));
+  });
+}
+
+/** `/posts/page/<n>` for n ≥ 2 (page 1 is `/posts` itself). */
+export async function getIndexPageRoutes() {
+  const [posts, settings] = await Promise.all([getIndexPosts(), getPostsSettings()]);
+  const pages = pageCount(posts.length, settings.perPage);
+  return Array.from({ length: Math.max(0, pages - 1) }, (_, i) => ({
+    params: { page: String(i + 2) },
+    props: { page: i + 2, pages },
+  }));
 }

package/lib/timetable.ts

@@ -0,0 +1,27 @@
+/**
+ * The `timetable` recipe's logic: which days a place actually has times on, and the
+ * rows of the side-by-side table (days down the side, a cell per place). Pure.
+ */
+export interface DaySchedule { day: string; times: string[] }
+export interface Place { name: string; schedule: DaySchedule[] }
+
+/** Only the days with at least one real time (blank strings don't count). */
+export function daysWithTimes(schedule: DaySchedule[]): DaySchedule[] {
+  return schedule
+    .map((d) => ({ day: d.day, times: d.times.map((t) => t.trim()).filter(Boolean) }))
+    .filter((d) => d.times.length > 0);
+}
+
+/** Table rows: every day some place uses, in first-seen order, with that day's times per place. */
+export function timetableRows(places: Place[]): Array<{ day: string; cells: string[][] }> {
+  const days: string[] = [];
+  const byPlace = places.map((p) => {
+    const map = new Map<string, string[]>();
+    for (const d of daysWithTimes(p.schedule)) {
+      map.set(d.day, d.times);
+      if (!days.includes(d.day)) days.push(d.day);
+    }
+    return map;
+  });
+  return days.map((day) => ({ day, cells: byPlace.map((m) => m.get(day) ?? []) }));
+}

package/lib/video.ts

@@ -1,56 +1,101 @@
-/**
- * Video links → a privacy-friendly embed. Accepts what an editor would paste — a
- * YouTube watch / share / shorts / live link, a channel's live page, or a Vimeo link —
- * and returns the embed URL (youtube-nocookie / Vimeo `dnt=1`) plus a link to watch it
- * on the provider. Anything else → null (the block shows a plain link instead).
- */
-export interface VideoEmbed {
-  provider: 'YouTube' | 'Vimeo';
-  embedUrl: string;
-  watchUrl: string;
-}
-
-const YT_ID = /^[A-Za-z0-9_-]{11}$/;
-const YT_CHANNEL = /^UC[A-Za-z0-9_-]{22}$/;
-
-export function videoEmbed(input: string | undefined | null): VideoEmbed | null {
-  if (!input) return null;
-  let u: URL;
-  try {
-    u = new URL(input.trim());
-  } catch {
-    return null;
-  }
-  if (u.protocol !== 'https:') return null;
-  const host = u.hostname.replace(/^(www\.|m\.)/, '');
-  const parts = u.pathname.split('/').filter(Boolean);
-  const watchUrl = u.toString();
-
-  if (host === 'youtu.be' && YT_ID.test(parts[0] ?? '')) return yt(parts[0], watchUrl);
-  if (host === 'youtube.com' || host === 'youtube-nocookie.com') {
-    const v = u.searchParams.get('v');
-    if (parts[0] === 'watch' && v && YT_ID.test(v)) return yt(v, watchUrl);
-    if (['embed', 'shorts', 'live', 'v'].includes(parts[0]) && YT_ID.test(parts[1] ?? '')) return yt(parts[1], watchUrl);
-    // A channel's live stream: /channel/<UC…>/live, or an embed of live_stream?channel=…
-    const channel = parts[0] === 'channel' && parts[2] === 'live' ? parts[1] : u.searchParams.get('channel');
-    if (channel && YT_CHANNEL.test(channel)) {
-      return {
-        provider: 'YouTube',
-        embedUrl: `https://www.youtube.com/embed/live_stream?channel=${channel}`,
-        watchUrl: `https://www.youtube.com/channel/${channel}/live`,
-      };
-    }
-    return null;
-  }
-  if (host === 'vimeo.com' && /^\d+$/.test(parts[0] ?? '')) {
-    return { provider: 'Vimeo', embedUrl: `https://player.vimeo.com/video/${parts[0]}?dnt=1`, watchUrl };
-  }
-  if (host === 'player.vimeo.com' && parts[0] === 'video' && /^\d+$/.test(parts[1] ?? '')) {
-    return { provider: 'Vimeo', embedUrl: `https://player.vimeo.com/video/${parts[1]}?dnt=1`, watchUrl: `https://vimeo.com/${parts[1]}` };
-  }
-  return null;
-}
-
-function yt(id: string, watchUrl: string): VideoEmbed {
-  return { provider: 'YouTube', embedUrl: `https://www.youtube-nocookie.com/embed/${id}?rel=0`, watchUrl };
-}
+/**
+ * Video links → a privacy-friendly embed. Accepts what an editor would paste — a
+ * YouTube watch / share / shorts / live link, a channel's live page, or a Vimeo link —
+ * and returns the embed URL (youtube-nocookie / Vimeo `dnt=1`) plus a link to watch it
+ * on the provider. Anything else → null (the block shows a plain link instead).
+ */
+export interface VideoEmbed {
+  provider: 'YouTube' | 'Vimeo';
+  embedUrl: string;
+  watchUrl: string;
+  /** A channel's live stream: often off air, so it loads only when the visitor asks. */
+  live?: boolean;
+}
+
+const YT_ID = /^[A-Za-z0-9_-]{11}$/;
+const YT_CHANNEL = /^UC[A-Za-z0-9_-]{22}$/;
+
+export function videoEmbed(input: string | undefined | null): VideoEmbed | null {
+  if (!input) return null;
+  let u: URL;
+  try {
+    u = new URL(input.trim());
+  } catch {
+    return null;
+  }
+  if (u.protocol !== 'https:') return null;
+  const host = u.hostname.replace(/^(www\.|m\.)/, '');
+  const parts = u.pathname.split('/').filter(Boolean);
+  const watchUrl = u.toString();
+
+  if (host === 'youtu.be' && YT_ID.test(parts[0] ?? '')) return yt(parts[0], watchUrl);
+  if (host === 'youtube.com' || host === 'youtube-nocookie.com') {
+    const v = u.searchParams.get('v');
+    if (parts[0] === 'watch' && v && YT_ID.test(v)) return yt(v, watchUrl);
+    if (['embed', 'shorts', 'live', 'v'].includes(parts[0]) && YT_ID.test(parts[1] ?? '')) return yt(parts[1], watchUrl);
+    // A channel's live stream: /channel/<UC…>/live, or an embed of live_stream?channel=…
+    const channel = parts[0] === 'channel' && parts[2] === 'live' ? parts[1] : u.searchParams.get('channel');
+    if (channel && YT_CHANNEL.test(channel)) {
+      return {
+        provider: 'YouTube',
+        embedUrl: `https://www.youtube.com/embed/live_stream?channel=${channel}`,
+        // The streams tab always has something (upcoming and past streams); /live is
+        // empty whenever the channel is off air.
+        watchUrl: `https://www.youtube.com/channel/${channel}/streams`,
+        live: true,
+      };
+    }
+    return null;
+  }
+  if (host === 'vimeo.com' && /^\d+$/.test(parts[0] ?? '')) {
+    return { provider: 'Vimeo', embedUrl: `https://player.vimeo.com/video/${parts[0]}?dnt=1`, watchUrl };
+  }
+  if (host === 'player.vimeo.com' && parts[0] === 'video' && /^\d+$/.test(parts[1] ?? '')) {
+    return { provider: 'Vimeo', embedUrl: `https://player.vimeo.com/video/${parts[1]}?dnt=1`, watchUrl: `https://vimeo.com/${parts[1]}` };
+  }
+  return null;
+}
+
+/**
+ * The same links as a header BACKGROUND: muted, autoplaying, looping and chromeless.
+ * YouTube loops a single video only with `playlist=<id>`; `enablejsapi=1` lets the
+ * hero's pause button send play/pause commands (postMessage, no API script). Vimeo
+ * has a dedicated `background=1` mode. Live streams and hosted files → null (a file
+ * plays in a native <video>).
+ */
+export function backgroundEmbed(input: string | undefined | null): VideoEmbed | null {
+  const v = videoEmbed(input);
+  if (!v || v.embedUrl.includes('live_stream')) return null;
+  if (v.provider === 'Vimeo') return { ...v, embedUrl: v.embedUrl.replace('?dnt=1', '?background=1&dnt=1') };
+  const id = new URL(v.embedUrl).pathname.split('/').pop()!;
+  const q = new URLSearchParams({
+    autoplay: '1', mute: '1', loop: '1', playlist: id, controls: '0', playsinline: '1',
+    rel: '0', disablekb: '1', iv_load_policy: '3', enablejsapi: '1',
+  });
+  return { ...v, embedUrl: `https://www.youtube-nocookie.com/embed/${id}?${q}` };
+}
+
+/**
+ * Has an embedded background player actually started playing? Read from the messages the
+ * player posts back (YouTube with `enablejsapi=1` after a `listening` handshake; Vimeo
+ * after `addEventListener: play`). Used to keep the poster up until the video is moving,
+ * then cross-fade, rather than flashing a black, loading player.
+ */
+export function playerStarted(provider: string, data: unknown): boolean {
+  let msg: Record<string, unknown> | null = null;
+  try {
+    msg = typeof data === 'string' ? JSON.parse(data) : (data as Record<string, unknown> | null);
+  } catch {
+    return false;
+  }
+  if (!msg || typeof msg !== 'object') return false;
+  if (provider === 'Vimeo') return msg.event === 'play' || msg.event === 'playProgress';
+  const info = msg.info as unknown;
+  if (msg.event === 'onStateChange') return info === 1;
+  if (msg.event === 'infoDelivery' && info && typeof info === 'object') return (info as { playerState?: number }).playerState === 1;
+  return false;
+}
+
+function yt(id: string, watchUrl: string): VideoEmbed {
+  return { provider: 'YouTube', embedUrl: `https://www.youtube-nocookie.com/embed/${id}?rel=0`, watchUrl };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ferst-core",
-  "version": "0.7.0",
+  "version": "0.7.4",
   "type": "module",
   "description": "Ferst Core — the shared, brand-agnostic client-site system: Astro components, layouts, content schemas, the layered config resolver, and a neutral styling architecture that every client overrides.",
   "license": "BUSL-1.1",

package/routes/cookie-policy.astro

@@ -0,0 +1,27 @@
+---
+/**
+ * The cookie policy (`/cookie-policy`) — INJECTED by the ferst() integration, so the
+ * cookie banner's link always resolves. Generated from what this site actually uses:
+ * every block type on its pages (third-party embeds such as maps or video) and whether a
+ * calendar is configured. A site with its own `src/pages/cookie-policy.astro` keeps it
+ * (the integration skips this route then).
+ */
+import Base from '../layouts/Base.astro';
+import CookiePolicy from '../components/CookiePolicy.astro';
+import { getPageEntries } from '../lib/pages';
+import { getCalendarSettings } from '../lib/calendar';
+import { blockTypesIn, scanCookieUses } from '../content/cookies';
+import { pageSchema } from '../content/blocks';
+
+const blockTypes = new Set<string>();
+for (const entry of await getPageEntries()) {
+  const page = pageSchema.safeParse(entry.data);
+  if (page.success) blockTypesIn(page.data.blocks as Array<{ type: string; blocks?: unknown }>, blockTypes);
+}
+const cal = await getCalendarSettings();
+const model = scanCookieUses({ blockTypes, calendarConfigured: Boolean(cal.embedUrl) });
+---
+
+<Base title="Cookie Policy" description="What this site stores on your device, and the third-party content it can show.">
+  <CookiePolicy model={model} />
+</Base>