edgepress 2026.9.5 → 2026.9.8

package/src/config.js

@@ -20,7 +20,7 @@ const defaults = {
     policyUrl: '/privacy-policy/'
   },
   browserPlugins: {
-    consent: { enabled: true, version: '1', expiresDays: 180 },
+    consent: { enabled: true, proposedDate: '', effectiveDate: '', expiresDays: 180 },
     tracking: { enabled: true, services: [] },
     statistics: { enabled: true, services: [] },
     advertising: { enabled: true, services: [] },
@@ -51,6 +51,31 @@ function assertString(value, label) {
   if (typeof value !== 'string' || !value.trim()) throw new Error(label + ' must be a non-empty string');
 }
 
+function isDateOnly(value) {
+  if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+  const date = new Date(value + 'T00:00:00.000Z');
+  return !Number.isNaN(date.valueOf()) && date.toISOString().slice(0, 10) === value;
+}
+
+function validateLocalizedServiceText(value, label, maxLength, locales) {
+  if (typeof value === 'string') {
+    if (!value.trim() || value.length > maxLength) throw new Error(label + ' must be a non-empty string of at most ' + maxLength + ' characters');
+    return;
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(label + ' must be a string or a locale-to-string map');
+  }
+  for (const [locale, text] of Object.entries(value)) {
+    if (!locales.includes(locale)) throw new Error(label + ' uses unsupported locale ' + locale);
+    if (typeof text !== 'string' || !text.trim() || text.length > maxLength) {
+      throw new Error(label + '.' + locale + ' must be a non-empty string of at most ' + maxLength + ' characters');
+    }
+  }
+  for (const locale of locales) if (!Object.prototype.hasOwnProperty.call(value, locale)) {
+    throw new Error(label + ' needs a translation for every configured locale, including ' + locale);
+  }
+}
+
 const integrationProviders = {
   'google-tag-manager': { group: 'tracking', credential: 'containerId', pattern: /^GTM-[A-Z0-9]{4,20}$/i },
   'meta-pixel': { group: 'tracking', credential: 'pixelId', pattern: /^[0-9]{6,20}$/ },
@@ -169,6 +194,29 @@ function validatePrivacyConfig(config) {
   if (!validPolicyUrl || /[\x00-\x20]/.test(policyUrl)) throw new Error('privacy.policyUrl must be a safe site path or HTTP URL');
 }
 
+function normalizeBrowserPlugins(value) {
+  if (value === undefined) return {};
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('config.yml plugins must be an object');
+  for (const key of Object.keys(value)) {
+    if (key !== 'consent') {
+      throw new Error('Unsupported plugin configuration group: ' + key + '; place browser services under plugins.consent.' + key);
+    }
+  }
+  if (value.consent === undefined) return {};
+  const input = value.consent;
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('plugins.consent must be an object');
+  const consent = {};
+  const normalized = {};
+  const groups = ['tracking', 'statistics', 'advertising', 'captcha'];
+  for (const [key, section] of Object.entries(input)) {
+    if (groups.includes(key)) normalized[key] = section;
+    else if (['enabled', 'proposedDate', 'effectiveDate', 'expiresDays'].includes(key)) consent[key] = section;
+    else throw new Error('Unsupported plugins.consent option: ' + key);
+  }
+  normalized.consent = consent;
+  return normalized;
+}
+
 function validateBrowserPlugins(config) {
   const plugins = config.browserPlugins;
   const allowedGroups = ['consent', 'tracking', 'statistics', 'advertising', 'captcha'];
@@ -176,33 +224,43 @@ function validateBrowserPlugins(config) {
   for (const key of Object.keys(plugins)) if (!allowedGroups.includes(key)) throw new Error('Unsupported plugin configuration group: ' + key);
   const consent = plugins.consent;
   if (!consent || typeof consent !== 'object' || Array.isArray(consent) || typeof consent.enabled !== 'boolean' ||
-      typeof consent.version !== 'string' || !consent.version.trim() || !Number.isInteger(consent.expiresDays) ||
+      !isDateOnly(consent.proposedDate) ||
+      (consent.effectiveDate !== '' && consent.effectiveDate !== undefined && !isDateOnly(consent.effectiveDate)) ||
+      !Number.isInteger(consent.expiresDays) ||
       consent.expiresDays < 1 || consent.expiresDays > 730) {
-    throw new Error('plugins.consent needs enabled, version, and expiresDays from 1 to 730');
+    throw new Error('plugins.consent needs enabled, a YYYY-MM-DD proposedDate, an optional YYYY-MM-DD effectiveDate, and expiresDays from 1 to 730');
   }
-  for (const key of Object.keys(consent)) if (!['enabled', 'version', 'expiresDays'].includes(key)) {
+  if (consent.effectiveDate && consent.effectiveDate < consent.proposedDate) {
+    throw new Error('plugins.consent.effectiveDate cannot be earlier than proposedDate');
+  }
+  for (const key of Object.keys(consent)) if (!['enabled', 'proposedDate', 'effectiveDate', 'expiresDays'].includes(key)) {
     throw new Error('Unsupported plugins.consent option: ' + key);
   }
   const ids = new Set();
   let servicesCount = 0;
   for (const group of ['tracking', 'statistics', 'advertising', 'captcha']) {
+    const groupPath = 'plugins.consent.' + group;
     const section = plugins[group];
     if (!section || typeof section !== 'object' || Array.isArray(section) || typeof section.enabled !== 'boolean' || !Array.isArray(section.services)) {
-      throw new Error('plugins.' + group + ' needs enabled and a services array');
+      throw new Error(groupPath + ' needs enabled and a services array');
     }
-    for (const key of Object.keys(section)) if (!['enabled', 'services'].includes(key)) throw new Error('Unsupported plugins.' + group + ' option: ' + key);
-    if (!section.enabled && section.services.length) throw new Error('Clear plugins.' + group + '.services or enable the plugin group');
+    for (const key of Object.keys(section)) if (!['enabled', 'services'].includes(key)) throw new Error('Unsupported ' + groupPath + ' option: ' + key);
+    if (!section.enabled && section.services.length) throw new Error('Clear ' + groupPath + '.services or enable the plugin group');
     servicesCount += section.services.length;
     for (const service of section.services) {
-      if (!service || typeof service !== 'object' || Array.isArray(service)) throw new Error('Each plugins.' + group + '.services item must be an object');
+      if (!service || typeof service !== 'object' || Array.isArray(service)) throw new Error('Each ' + groupPath + '.services item must be an object');
       const { id, provider, purpose } = service;
       if (typeof id !== 'string' || !/^[a-z][a-z0-9-]{1,63}$/.test(id) || ids.has(id)) throw new Error('Each configured service needs a unique lowercase id');
       ids.add(id);
       const definition = integrationProviders[provider];
-      if (!definition || definition.group !== group) throw new Error('Unsupported provider for plugins.' + group + ': ' + provider);
-      if (typeof purpose !== 'string' || !purpose.trim() || purpose.length > 500) throw new Error('Service ' + id + ' needs a short purpose description');
-      if (typeof service.retention !== 'string' || !service.retention.trim() || service.retention.length > 300) throw new Error('Service ' + id + ' needs a retention description');
-      const allowedKeys = new Set(['id', 'provider', 'purpose', 'retention', definition.credential]);
+      if (!definition || definition.group !== group) throw new Error('Unsupported provider for ' + groupPath + ': ' + provider);
+      const locales = config.i18n.locales;
+      validateLocalizedServiceText(service.name || provider, 'Service ' + id + '.name', 120, locales);
+      validateLocalizedServiceText(purpose, 'Service ' + id + '.purpose', 500, locales);
+      validateLocalizedServiceText(service.dataCategories, 'Service ' + id + '.dataCategories', 600, locales);
+      validateLocalizedServiceText(service.recipient, 'Service ' + id + '.recipient', 200, locales);
+      validateLocalizedServiceText(service.retention, 'Service ' + id + '.retention', 300, locales);
+      const allowedKeys = new Set(['id', 'provider', 'name', 'purpose', 'dataCategories', 'recipient', 'retention', definition.credential]);
       for (const key of Object.keys(service)) if (!allowedKeys.has(key)) throw new Error('Unsupported option for service ' + id + ': ' + key);
       const credential = service[definition.credential];
       if (typeof credential !== 'string' || !definition.pattern.test(credential)) throw new Error('Service ' + id + ' needs a valid public ' + definition.credential);
@@ -287,14 +345,13 @@ export async function loadConfig(root = process.cwd()) {
   }
   config.site = merge(config.site, siteYaml.site);
   config.privacy = merge(config.privacy, siteYaml.privacy);
-  config.browserPlugins = merge(config.browserPlugins, siteYaml.plugins);
+  config.browserPlugins = merge(config.browserPlugins, normalizeBrowserPlugins(siteYaml.plugins));
   assertString(config.site.title, 'site.title');
   assertString(config.site.language, 'site.language');
   if (!isCanonicalLocale(config.site.language)) throw new Error('site.language must be a valid canonical language tag');
   if (typeof config.site.description !== 'string') throw new Error('site.description must be a string');
   validateSiteConfig(config);
   validatePrivacyConfig(config);
-  validateBrowserPlugins(config);
   if (typeof config.markdown.gfm !== 'boolean' || typeof config.markdown.breaks !== 'boolean') {
     throw new Error('markdown.gfm and markdown.breaks must be booleans');
   }
@@ -329,6 +386,7 @@ export async function loadConfig(root = process.cwd()) {
     throw new Error('i18n.languagePacks must not contain duplicates');
   }
   config.i18n.locales = [config.i18n.defaultLocale, ...config.i18n.languagePacks];
+  validateBrowserPlugins(config);
 
   const siteUrl = String(config.site.url ?? '').trim();
   if (siteUrl) {

package/src/content.js

@@ -3,6 +3,27 @@ import { basename, dirname, extname, relative, resolve, sep } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { mapLimit } from './concurrency.js';
 
+export function sortPostsNewest(posts) {
+  return [...posts].sort((left, right) => {
+    const dateOrder = right.date - left.date;
+    if (dateOrder) return dateOrder;
+    const leftPath = String(left.path);
+    const rightPath = String(right.path);
+    return rightPath.localeCompare(leftPath, undefined, { numeric: true, sensitivity: 'base' });
+  });
+}
+
+export function postsForLocale(posts, locale, defaultLocale) {
+  const byBundle = new Map();
+  for (const post of posts) {
+    const current = byBundle.get(post.bundlePath);
+    if (!current || post.locale === locale || (current.locale !== locale && post.locale === defaultLocale)) {
+      byBundle.set(post.bundlePath, post);
+    }
+  }
+  return sortPostsNewest([...byBundle.values()]);
+}
+
 async function walkMarkdown(directory) {
   let entries;
   try {
@@ -47,6 +68,36 @@ function normalizeTags(value) {
   return (Array.isArray(value) ? value : [value]).map(String).map((tag) => tag.trim()).filter(Boolean);
 }
 
+function normalizeAuthor(value, file) {
+  if (value === undefined || value === null || value === '') return '';
+  if (typeof value !== 'string' || !value.trim() || value.length > 160) {
+    throw new Error('author must be a non-empty string of at most 160 characters in ' + file);
+  }
+  return value.trim();
+}
+
+function normalizeVideo(value, file) {
+  if (value === undefined) return null;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('video must be an object in ' + file);
+  for (const key of Object.keys(value)) {
+    if (!['src', 'captions', 'captionLanguage', 'captionLabel', 'poster', 'alt', 'title', 'description'].includes(key)) {
+      throw new Error('Unsupported video field in ' + file + ': ' + key);
+    }
+  }
+  const localAsset = /^\/edgepress\/media\/[a-z0-9-]+\.(?:mp4|vtt|jpe?g)$/i;
+  for (const field of ['src', 'captions', 'poster']) {
+    if (typeof value[field] !== 'string' || !localAsset.test(value[field])) {
+      throw new Error('video.' + field + ' must reference a local /edgepress/media asset in ' + file);
+    }
+  }
+  if (typeof value.captionLanguage !== 'string' || !/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(value.captionLanguage) ||
+      typeof value.captionLabel !== 'string' || !value.captionLabel.trim() || typeof value.alt !== 'string' || !value.alt.trim() ||
+      typeof value.title !== 'string' || !value.title.trim() || typeof value.description !== 'string' || !value.description.trim()) {
+    throw new Error('video needs a language, labels, accessible description, title, and summary in ' + file);
+  }
+  return value;
+}
+
 function normalizeDate(value, filename, kind, file) {
   if (value instanceof Date) {
     if (!Number.isNaN(value.valueOf())) return value;
@@ -144,7 +195,10 @@ export async function readDocuments(config) {
     }
     if (locale !== config.i18n.defaultLocale && metadata.homepage !== true) path = locale + '/' + path;
     return {
-      kind, file, relativePath, title, slug, date, locale,
+      kind, file, relativePath, bundlePath, title, slug, date, locale,
+      author: kind === 'posts' ? normalizeAuthor(metadata.author, file) : '',
+      videoId: (kind === 'posts' ? 'post-' : 'page-') + slugify(bundlePath + '-' + locale.toLowerCase()),
+      video: kind === 'posts' ? normalizeVideo(metadata.video, file) : null,
       tags: normalizeTags(metadata.tags),
       description: String(metadata.description ?? ''),
       keywords: normalizeTags(metadata.keywords),

package/src/generators.js

@@ -1,8 +1,8 @@
-import { plainText } from './markdown.js';
+import { plainText, renderMarkdownExcerpt } from './markdown.js';
 import { renderBlocks } from './page-blocks.js';
 import { renderLayout } from './theme.js';
 import { localizedUrl, translate } from './i18n.js';
-import { slugify } from './content.js';
+import { postsForLocale, slugify, sortPostsNewest } from './content.js';
 import { mapLimit } from './concurrency.js';
 
 function escapeHtml(value) {
@@ -42,6 +42,51 @@ function urlPathForRoute(path) {
   return '/' + value;
 }
 
+function decodeHeadingEntities(value) {
+  return value.replace(/&(#x[\da-f]+|#\d+|amp|lt|gt|quot|apos|nbsp);/gi, (match, entity) => {
+    const named = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' };
+    if (entity[0] === '#') {
+      const hex = entity[1]?.toLowerCase() === 'x';
+      const point = Number.parseInt(entity.slice(hex ? 2 : 1), hex ? 16 : 10);
+      return Number.isFinite(point) && point > 0 && point <= 0x10ffff ? String.fromCodePoint(point) : match;
+    }
+    return named[entity.toLowerCase()] ?? match;
+  });
+}
+
+function addPostContents(html, locale, config) {
+  const headings = [];
+  const counts = new Map();
+  const content = html.replace(/<h([2-6])\b([^>]*)>([\s\S]*?)<\/h\1>/gi, (whole, levelText, attributes, inner) => {
+    const label = decodeHeadingEntities(inner.replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim());
+    if (!label) return whole;
+    const base = slugify(label);
+    const count = (counts.get(base) || 0) + 1;
+    counts.set(base, count);
+    const id = count === 1 ? base : base + '-' + count;
+    headings.push({ id, label, level: Number(levelText) });
+    const safeAttributes = attributes.replace(/\s+id\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, '');
+    return '<h' + levelText + safeAttributes + ' id="' + escapeHtml(id) + '">' + inner + '</h' + levelText + '>';
+  });
+  if (!headings.length) return { html: content, toc: '' };
+  const items = headings.map((heading) => '<li class="post-toc-level-' + heading.level + '"><a href="#' +
+    escapeHtml(heading.id) + '">' + escapeHtml(heading.label) + '</a></li>').join('');
+  const contentsLabel = translate(config, locale, 'postContents');
+  const toc = '<nav class="post-toc" aria-label="' + escapeHtml(contentsLabel) + '"><h2 id="post-toc-title">' +
+    escapeHtml(contentsLabel) + '</h2><ol>' + items + '</ol></nav>';
+  return { html: content, toc };
+}
+
+function renderPostVideo(video, locale) {
+  if (!video) return '';
+  const videoTitle = escapeHtml(video.title);
+  return '<figure class="post-video"><video controls playsinline preload="metadata" poster="' + escapeHtml(video.poster) + '" aria-label="' +
+    escapeHtml(video.alt) + '"><source src="' + escapeHtml(video.src) + '" type="video/mp4"><track kind="captions" src="' +
+    escapeHtml(video.captions) + '" srclang="' + escapeHtml(video.captionLanguage) + '" label="' + escapeHtml(video.captionLabel) + '" default>' +
+    '<a href="' + escapeHtml(video.src) + '">' + (locale.toLowerCase().startsWith('zh') ? '下载 MP4 视频' : 'Download the MP4 video') +
+    '</a></video><figcaption><strong>' + videoTitle + '</strong><br>' + escapeHtml(video.description) + '</figcaption></figure>';
+}
+
 async function pageRoute(path, title, description, body, locale, config, extensions, metadata = {}) {
   const urlPath = metadata.urlPath || urlPathForRoute(path);
   const structuredData = metadata.structuredData ?? {
@@ -53,6 +98,7 @@ async function pageRoute(path, title, description, body, locale, config, extensi
     inLanguage: locale,
     isPartOf: config.site.url ? { '@type': 'WebSite', name: config.site.title, url: config.site.url } : undefined
   };
+  body = body.replace(/<pre\b/gi, '<pre data-copyable-code');
   let html = await renderLayout(config, extensions, {
     title,
     description,
@@ -69,21 +115,44 @@ async function pageRoute(path, title, description, body, locale, config, extensi
   return fileRoute(path, html);
 }
 
-function renderPostCard(post, locale) {
-  const summary = post.description || plainText(post.markdown).slice(0, 220);
-  return '<article class="post-card"><h2><a href="' + escapeHtml(urlFor(post.path)) + '">' + escapeHtml(post.title) + '</a></h2>' +
-    '<p class="meta"><time datetime="' + post.date.toISOString() + '">' + escapeHtml(dateLabel(post.date, locale)) + '</time></p><p>' +
-    escapeHtml(summary) + '</p></article>';
+function renderPostAuthor(post, locale, config) {
+  if (!post.author) return '';
+  return '<span class="post-author">' + escapeHtml(translate(config, locale, 'postAuthor').replace('{author}', post.author)) + '</span>';
+}
+
+async function renderPostCard(post, locale, config, showLanguage = false) {
+  const summary = await renderMarkdownExcerpt(post.description || post.markdown, config.markdown);
+  return '<article class="post-card" lang="' + escapeHtml(post.locale) + '"><h2><a href="' + escapeHtml(urlFor(post.path)) + '">' + escapeHtml(post.title) + '</a></h2>' +
+    '<p class="meta"><time datetime="' + post.date.toISOString() + '">' + escapeHtml(dateLabel(post.date, post.locale)) + '</time>' +
+    (showLanguage ? ' · <span class="post-language" lang="' + escapeHtml(post.locale) + '">' + escapeHtml(post.locale) + '</span>' : '') +
+    (post.author ? ' · ' + renderPostAuthor(post, locale, config) : '') + '</p><div class="post-excerpt" lang="' + escapeHtml(post.locale) + '">' +
+    summary + '</div></article>';
 }
 
-async function pageBodyForDocument(page, site, config, locale, isHomepage = false) {
-  const content = await renderBlocks(page.blocks, { config, locale, site, isHomepage });
+async function pageBodyForDocument(page, site, config, locale, isHomepage = false, renderContext = {}) {
+  const content = await renderBlocks(page.blocks, { config, locale, site, isHomepage, ...renderContext });
   const firstElement = page.blocks[0]?.cells?.[0]?.[0];
   const needsTitle = !isHomepage || firstElement?.type !== 'hero';
   const title = needsTitle ? '<header class="page-title"><h1>' + escapeHtml(page.title) + '</h1></header>' : '';
   return '<article class="page-builder">' + title + content + '</article>';
 }
 
+function paginatedLatestPostsSize(page) {
+  function find(value) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const result = find(item);
+        if (result !== null) return result;
+      }
+      return null;
+    }
+    if (!value || typeof value !== 'object') return null;
+    if (value.type === 'latest-posts' && value.paginate === true) return value.count ?? 3;
+    return find(value.cells) ?? find(value.blocks);
+  }
+  return find(page?.blocks);
+}
+
 function homepageDocument(pages, locale, defaultLocale) {
   return pages.find((page) => page.homepage && page.locale === locale) ||
     pages.find((page) => page.homepage && page.locale === defaultLocale) || null;
@@ -100,17 +169,29 @@ export async function generateBuiltinRoutes(site, config, extensions) {
     homepageLocales.add(page.locale);
   }
 
+  const allPosts = sortPostsNewest(site.posts);
   for (const locale of config.i18n.locales) {
-    const posts = site.posts.filter((post) => post.locale === locale).sort((a, b) => b.date - a.date);
+    const posts = allPosts.filter((post) => post.locale === locale);
+    const archivePosts = postsForLocale(allPosts, locale, defaultLocale);
     const pages = site.pages.filter((page) => page.locale === locale && !page.homepage);
     const homePage = homepageDocument(site.pages, locale, defaultLocale);
+    const latestPostsPageSize = paginatedLatestPostsSize(homePage);
+    if (latestPostsPageSize !== null && (!Number.isInteger(latestPostsPageSize) || latestPostsPageSize < 1 || latestPostsPageSize > 12)) {
+      throw new Error('A paginated latest-posts block must use a count from 1 to 12');
+    }
+    const homepageArchivePages = latestPostsPageSize ? Math.ceil(archivePosts.length / latestPostsPageSize) : 0;
     const prefix = locale === defaultLocale ? '' : locale + '/';
     const label = (key) => translate(config, locale, key);
     const localeHomeUrl = localizedUrl(config, locale, '');
     allPagePaths.add(localeHomeUrl);
 
     if (homePage) {
-      const body = await pageBodyForDocument(homePage, site, config, locale, true);
+      const latestPostsPagination = latestPostsPageSize ? {
+        totalPages: homepageArchivePages,
+        archiveUrl: localizedUrl(config, locale, 'archives/'),
+        olderUrl: localizedUrl(config, locale, 'archives/page/2/')
+      } : null;
+      const body = await pageBodyForDocument(homePage, site, config, locale, true, { latestPostsPagination });
       routes.push(await pageRoute(prefix + 'index.html', homePage.title, homePage.description || config.site.description,
         body, locale, config, extensions, {
           urlPath: localeHomeUrl,
@@ -126,12 +207,13 @@ export async function generateBuiltinRoutes(site, config, extensions) {
           }
         }));
     } else {
-      const totalPages = Math.max(1, Math.ceil(posts.length / config.pagination.perPage));
+      const totalPages = Math.max(1, Math.ceil(archivePosts.length / config.pagination.perPage));
       for (let pageNumber = 1; pageNumber <= totalPages; pageNumber += 1) {
-        const subset = posts.slice((pageNumber - 1) * config.pagination.perPage, pageNumber * config.pagination.perPage);
+        const subset = archivePosts.slice((pageNumber - 1) * config.pagination.perPage, pageNumber * config.pagination.perPage);
+        const cards = await Promise.all(subset.map((post) => renderPostCard(post, locale, config, true)));
         const body = '<section class="intro"><h1>' + escapeHtml(config.site.title) + '</h1><p>' + escapeHtml(config.site.description) +
           '</p></section><section class="post-list" aria-label="' + escapeHtml(label('latestPosts')) + '">' +
-          (subset.length ? subset.map((post) => renderPostCard(post, locale)).join('') : '<p>' + escapeHtml(label('noPosts')) + '</p>') +
+          (cards.length ? cards.join('') : '<p>' + escapeHtml(label('noPosts')) + '</p>') +
           '</section>' + (pageNumber === 1 && pages.length ? '<section class="page-links"><h2>' + escapeHtml(label('pages')) + '</h2><ul>' +
             pages.map((page) => '<li><a href="' + escapeHtml(urlFor(page.path)) + '">' + escapeHtml(page.title) + '</a></li>').join('') + '</ul></section>' : '') +
           (totalPages > 1 ? '<nav class="pagination" aria-label="' + escapeHtml(label('pagination')) + '">' +
@@ -145,8 +227,10 @@ export async function generateBuiltinRoutes(site, config, extensions) {
 
     for (const post of posts) allPagePaths.add(urlFor(post.path));
     const postRoutes = await mapLimit(posts, config.concurrency, async (post) => {
+      const renderedMarkdown = addPostContents(post.html, locale, config);
       const body = '<article class="post"><header><h1>' + escapeHtml(post.title) + '</h1><p class="meta"><time datetime="' + post.date.toISOString() + '">' +
-        escapeHtml(dateLabel(post.date, locale)) + '</time></p></header><div class="post-content">' + post.html + '</div>' +
+        escapeHtml(dateLabel(post.date, locale)) + '</time>' + (post.author ? ' · ' + renderPostAuthor(post, locale, config) : '') +
+        '</p></header>' + renderPostVideo(post.video, locale) + renderedMarkdown.toc + '<div class="post-content">' + renderedMarkdown.html + '</div>' +
         (post.tags.length ? '<p class="tags">' + escapeHtml(label('tags')) + ': ' + post.tags.map((tag) => '<a href="' +
           escapeHtml(localizedUrl(config, locale, 'tags/' + tagSlug(tag) + '/')) + '">' + escapeHtml(tag) + '</a>').join(' ') + '</p>' : '') + '</article>';
       const canonicalPath = urlFor(post.path);
@@ -157,7 +241,7 @@ export async function generateBuiltinRoutes(site, config, extensions) {
             '@context': 'https://schema.org', '@type': 'BlogPosting', headline: post.title,
             description: post.description || plainText(post.markdown).slice(0, 160),
             datePublished: post.date.toISOString(), dateModified: post.date.toISOString(),
-            author: { '@type': 'Person', name: config.site.seo.author || config.site.title },
+            author: { '@type': 'Person', name: post.author || config.site.seo.author || config.site.title },
             mainEntityOfPage: config.site.url ? config.site.url + canonicalPath : undefined,
             inLanguage: locale
           }
@@ -176,9 +260,25 @@ export async function generateBuiltinRoutes(site, config, extensions) {
     routes.push(...pageRoutes);
 
     if (!homePage) allPagePaths.add(localizedUrl(config, locale, ''));
-    const archiveBody = '<section><h1>' + escapeHtml(label('archives')) + '</h1>' +
-      (posts.length ? posts.map((post) => renderPostCard(post, locale)).join('') : '<p>' + escapeHtml(label('noPosts')) + '</p>') + '</section>';
-    routes.push(await pageRoute(prefix + 'archives/index.html', label('archives'), label('allPosts'), archiveBody, locale, config, extensions));
+    const archivePageSize = latestPostsPageSize || config.pagination.perPage;
+    const archivePageCount = Math.max(1, Math.ceil(archivePosts.length / archivePageSize));
+    for (let pageNumber = 1; pageNumber <= archivePageCount; pageNumber += 1) {
+      const subset = archivePosts.slice((pageNumber - 1) * archivePageSize, pageNumber * archivePageSize);
+      const cards = await Promise.all(subset.map((post) => renderPostCard(post, locale, config, true)));
+      const archiveUrl = pageNumber === 1 ? 'archives/' : 'archives/page/' + pageNumber + '/';
+      const pagination = archivePageCount > 1
+        ? '<nav class="pagination" aria-label="' + escapeHtml(label('pagination')) + '">' +
+          (pageNumber > 1 ? '<a rel="prev" href="' + escapeHtml(pageNumber === 2 ? localizedUrl(config, locale, 'archives/') :
+            localizedUrl(config, locale, 'archives/page/' + (pageNumber - 1) + '/')) + '">' + escapeHtml(label('newer')) + '</a>' : '') +
+          (pageNumber < archivePageCount ? '<a rel="next" href="' + escapeHtml(localizedUrl(config, locale, 'archives/page/' + (pageNumber + 1) + '/')) + '">' +
+            escapeHtml(label('older')) + '</a>' : '') + '</nav>' : '';
+      const archiveBody = '<section><h1>' + escapeHtml(label('archives')) + '</h1>' +
+        (cards.length ? cards.join('') : '<p>' + escapeHtml(label('noPosts')) + '</p>') + pagination + '</section>';
+      routes.push(await pageRoute(prefix + (pageNumber === 1 ? 'archives/index.html' : 'archives/page/' + pageNumber + '/index.html'),
+        pageNumber === 1 ? label('archives') : label('archives') + ' · ' + pageNumber, label('allPosts'), archiveBody, locale, config, extensions,
+        { urlPath: localizedUrl(config, locale, archiveUrl) }));
+      allPagePaths.add(localizedUrl(config, locale, archiveUrl));
+    }
 
     const tags = new Map();
     for (const post of posts) for (const tag of post.tags) {
@@ -187,15 +287,16 @@ export async function generateBuiltinRoutes(site, config, extensions) {
       tags.get(slug).posts.push(post);
     }
     const tagRoutes = await mapLimit([...tags.entries()], config.concurrency, async ([slug, value]) => {
+      const cards = await Promise.all(value.posts.map((post) => renderPostCard(post, locale, config)));
       const body = '<section><h1>' + escapeHtml(label('tag')) + ': ' + escapeHtml(value.label) + '</h1>' +
-        value.posts.map((post) => renderPostCard(post, locale)).join('') + '</section>';
+        cards.join('') + '</section>';
       return pageRoute(prefix + 'tags/' + slug + '/index.html', label('tag') + ': ' + value.label,
         label('tag') + ' ' + value.label, body, locale, config, extensions);
     });
     routes.push(...tagRoutes);
 
     const searchable = [
-      ...posts.map((post) => ({ title: post.title, date: post.date.toISOString(), url: urlFor(post.path), summary: post.description || plainText(post.markdown).slice(0, 220), content: plainText(post.markdown), type: 'post' })),
+      ...posts.map((post) => ({ title: post.title, author: post.author, date: post.date.toISOString(), url: urlFor(post.path), summary: plainText(post.description || post.markdown).slice(0, 220), content: plainText(post.markdown), type: 'post' })),
       ...pages.map((page) => ({ title: page.title, url: urlFor(page.path), summary: page.description || plainText(page.markdown).slice(0, 220), type: 'page' }))
     ];
     routes.push(fileRoute(prefix + 'search.json', JSON.stringify(searchable), 'application/json; charset=utf-8'));
@@ -213,9 +314,10 @@ export async function generateBuiltinRoutes(site, config, extensions) {
       locale, config, extensions));
 
     const base = config.site.url;
-    const entries = posts.slice(0, 20).map((post) => '<entry><title>' + escapeXml(post.title) + '</title><link href="' +
+    const entries = posts.slice(0, 20).map((post) => '<entry><title>' + escapeXml(post.title) + '</title>' +
+      (post.author ? '<author><name>' + escapeXml(post.author) + '</name></author>' : '') + '<link href="' +
       escapeXml(base + urlFor(post.path)) + '"/><id>' + escapeXml(base + urlFor(post.path)) + '</id><updated>' + post.date.toISOString() +
-      '</updated><summary>' + escapeXml(post.description || plainText(post.markdown).slice(0, 220)) + '</summary></entry>').join('');
+      '</updated><summary>' + escapeXml(plainText(post.description || post.markdown).slice(0, 220)) + '</summary></entry>').join('');
     routes.push(fileRoute(prefix + 'feed.xml', '<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom"><title>' +
       escapeXml(config.site.title) + '</title><id>' + escapeXml(base || 'urn:edgepress:site') + '</id><updated>' +
       (posts[0]?.date.toISOString() || new Date(0).toISOString()) + '</updated>' + entries + '</feed>', 'application/atom+xml; charset=utf-8'));

package/src/i18n.js

@@ -53,6 +53,12 @@ export function translate(config, locale, key) {
   return selected?.[key] ?? base?.[key] ?? key;
 }
 
+export function translateValue(config, locale, value) {
+  if (typeof value === 'string') return value;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return '';
+  return value[locale] ?? value[config.i18n.defaultLocale] ?? Object.values(value).find((text) => typeof text === 'string') ?? '';
+}
+
 export function localePrefix(config, locale) {
   return locale === config.i18n.defaultLocale ? '' : '/' + locale;
 }

package/src/icons.js

@@ -0,0 +1,16 @@
+const iconNames = new Set([
+  'home', 'book-open', 'rocket', 'newspaper', 'search', 'shield-check', 'rss', 'file-text',
+  'layers', 'code', 'puzzle', 'plug', 'cloud', 'palette', 'globe', 'help-circle', 'arrow-up-right',
+  'check-circle', 'layout-grid', 'terminal', 'settings', 'sparkles'
+]);
+
+export function isIconName(name) {
+  return typeof name === 'string' && iconNames.has(name);
+}
+
+export function renderIcon(name, className = 'icon') {
+  if (!isIconName(name)) throw new Error('Unsupported EdgePress icon: ' + String(name));
+  if (!/^[a-z][a-z0-9-]*$/.test(className)) throw new Error('Icon class must be a simple CSS identifier');
+  return '<svg class="' + className + '" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><use href="/edgepress/icons.svg#' +
+    name + '"></use></svg>';
+}

package/src/maintenance.js

@@ -17,29 +17,6 @@ function versionAtLeast(current, minimum) {
   return true;
 }
 
-function markdown(report) {
-  const lines = [
-    '# EdgePress compatibility report',
-    '',
-    'Status: **' + report.status + '**',
-    '',
-    'Node.js: ' + report.runtime.node,
-    'Minimum required Node.js: ' + report.requirements.nodeMinimumVersion,
-    'Workers compatibility date: ' + report.runtime.workersDate,
-    'Minimum required date: ' + report.requirements.minimumWorkersDate,
-    '',
-    '## Findings',
-    ''
-  ];
-  if (!report.issues.length) lines.push('No compatibility findings.');
-  for (const issue of report.issues) lines.push('- **' + issue.severity.toUpperCase() + '** ' + issue.message);
-  lines.push('', '## Feature lifecycle', '');
-  for (const feature of report.features) {
-    lines.push('- ' + feature.name + ': ' + feature.stage + ' (since ' + feature.since + ')');
-  }
-  return lines.join('\n');
-}
-
 export async function checkCompatibility(config) {
   const root = config.root;
   const manifest = await readJson(resolve(root, 'project-compatibility.json'));
@@ -77,10 +54,6 @@ export async function checkCompatibility(config) {
     features: manifest.features,
     issues
   };
-  const directory = resolve(config.resolvedPaths.cache, 'reports');
-  await mkdir(directory, { recursive: true });
-  await writeFile(resolve(directory, 'compatibility.json'), JSON.stringify(report, null, 2), 'utf8');
-  await writeFile(resolve(directory, 'compatibility.md'), markdown(report), 'utf8');
   return report;
 }