edgepress 2026.10.1 → 2026.10.13

package/src/publication-time.js

@@ -0,0 +1,47 @@
+export const defaultTimeZone = 'Asia/Taipei';
+export function validateTimeZone(value) {
+  if (typeof value !== 'string' || !value || value.length > 80) throw new Error('site.timeZone must be an IANA time zone');
+  try { new Intl.DateTimeFormat('en',{timeZone:value}).format(); }
+  catch { throw new Error('site.timeZone must be a valid IANA time zone'); }
+  return value;
+}
+function parts(date,timeZone) {
+  return Object.fromEntries(new Intl.DateTimeFormat('en-CA',{timeZone,year:'numeric',month:'2-digit',day:'2-digit',
+    hour:'2-digit',minute:'2-digit',second:'2-digit',hourCycle:'h23'}).formatToParts(date).filter(part=>part.type!=='literal').map(part=>[part.type,part.value]));
+}
+const wall = values => `${values.year}-${values.month}-${values.day}T${values.hour}:${values.minute}:${values.second}`;
+function offset(date,timeZone) {
+  const values=parts(date,timeZone);
+  return Date.parse(wall(values)+'Z')-Math.floor(date.valueOf()/1000)*1000;
+}
+export function publicationTimestamp(date=new Date(),timeZone=defaultTimeZone) {
+  const values=parts(date,timeZone),minutes=offset(date,timeZone)/60000;
+  const sign=minutes<0?'-':'+';
+  return wall(values)+sign+String(Math.floor(Math.abs(minutes)/60)).padStart(2,'0')+':'+String(Math.abs(minutes)%60).padStart(2,'0');
+}
+export function parsePublicationDate(value,timeZone=defaultTimeZone) {
+  if (value instanceof Date && !Number.isNaN(value.valueOf())) return value;
+  if (typeof value !== 'string') throw new Error('Publication date must be a date or timestamp');
+  const match=value.match(/^(\d{4}-\d{2}-\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})?)?$/);
+  if (!match || new Date(match[1]+'T00:00:00Z').toISOString().slice(0,10)!==match[1]) throw new Error('Invalid publication date');
+  if (!match[2]) return new Date(match[1]+'T00:00:00Z'); // Calendar date, never a fabricated local midnight.
+  const local=match[1]+'T'+match[2]+':'+match[3]+':'+(match[4]||'00');
+  const naive=Date.parse(local+(match[5]||'')+'Z');
+  if (!Number.isFinite(naive) || new Date(naive).toISOString().slice(0,19)!==local) throw new Error('Invalid publication time');
+  if (match[6]) {
+    const date=new Date(local+(match[5]||'')+match[6]);
+    if (!Number.isNaN(date.valueOf())) return date;
+    throw new Error('Invalid publication offset');
+  }
+  const candidates=new Set();
+  // Probe both sides of DST transitions. Ambiguous/nonexistent times require an explicit offset.
+  for(const delta of [-172800000,0,172800000]) {
+    const candidate=new Date(naive-offset(new Date(naive+delta),timeZone));
+    if(wall(parts(candidate,timeZone))===local)candidates.add(candidate.valueOf());
+  }
+  if(candidates.size!==1)throw new Error('Ambiguous or nonexistent publication time; include an explicit timezone offset');
+  return new Date([...candidates][0]);
+}
+export function publicationCalendar(value,date,timeZone=defaultTimeZone) {
+  return typeof value==='string' && /^\d{4}-\d{2}-\d{2}/.test(value) ? value.slice(0,10) : publicationTimestamp(date,timeZone).slice(0,10);
+}

package/src/report-path.js

@@ -0,0 +1,19 @@
+import {lstat, mkdir, realpath} from 'node:fs/promises';
+import {resolve, relative, isAbsolute, sep} from 'node:path';
+
+export async function reportDirectory(root, create = true) {
+  const project = await realpath(root);
+  for (const directory of [resolve(root, 'tools'), resolve(root, 'tools/reports')]) {
+    try {
+      const info = await lstat(directory);
+      if (info.isSymbolicLink() || !info.isDirectory()) throw new Error('Report directory must be a real directory: ' + directory);
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      if (!create) return null;
+      await mkdir(directory);
+    }
+    const path = await realpath(directory), local = relative(project, path);
+    if (local === '..' || local.startsWith('..' + sep) || isAbsolute(local)) throw new Error('Report directory must stay inside the project root');
+  }
+  return resolve(root, 'tools/reports');
+}

package/src/report-visuals.js

@@ -1,9 +1,11 @@
+import {reportDirectory} from './report-path.js';
 import { createHash } from 'node:crypto';
 import { access, lstat, mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { extname, relative, resolve, sep } from 'node:path';
 import { tmpdir } from 'node:os';
 import { spawn } from 'node:child_process';
+import { auditBrowser, deviceProfiles } from './browser-audit.js';
 
 function escapeHtml(value) {
   return String(value ?? '').replace(/[&<>"']/g, (char) => ({
@@ -64,7 +66,9 @@ function withTimeout(promise, timeoutMs, message) {
 async function startHeadlessBrowser(executable, profile) {
   const port = await freePort();
   const child = spawn(executable, [
-    '--headless=new', '--disable-gpu', '--no-sandbox', '--no-first-run', '--no-default-browser-check',
+    '--headless=new', '--mute-audio', '--disable-notifications',
+    '--disable-sync', '--disable-features=msForceBrowserSignIn,msEdgeUpdateLaunchServicesPreferredVersion',
+    '--disable-background-timer-throttling', '--disable-backgrounding-occluded-windows', '--disable-renderer-backgrounding', '--disable-gpu', '--no-sandbox', '--no-first-run', '--no-default-browser-check',
     '--disable-background-networking', '--host-resolver-rules=MAP * ~NOTFOUND, EXCLUDE localhost, EXCLUDE 127.0.0.1',
     '--remote-debugging-port=' + port, '--remote-allow-origins=*', '--user-data-dir=' + profile, 'about:blank'
   ], { stdio: 'ignore', windowsHide: true });
@@ -114,17 +118,29 @@ async function startHeadlessBrowser(executable, profile) {
     });
     await send('Page.enable');
     await send('Runtime.enable');
+    await send('Accessibility.enable');
     const setViewport = async (viewport) => {
       await send('Emulation.setDeviceMetricsOverride', {
-        width: viewport.width, height: viewport.height, deviceScaleFactor: 1, mobile: viewport.name === 'mobile',
+        width: viewport.width, height: viewport.height, deviceScaleFactor: viewport.deviceScaleFactor || 1,
+        mobile: viewport.mobile ?? viewport.name === 'mobile',
         screenWidth: viewport.width, screenHeight: viewport.height
       });
+      await send('Emulation.setTouchEmulationEnabled', { enabled: viewport.touch ?? viewport.name === 'mobile', maxTouchPoints: 5 });
+      await send('Emulation.setEmulatedMedia', { features: viewport.colorScheme
+        ? [{ name: 'prefers-color-scheme', value: viewport.colorScheme }] : [] });
     };
     const navigate = async (url) => {
+      await send('Page.bringToFront');
       const loaded = waitFor('Page.loadEventFired');
       const result = await send('Page.navigate', { url });
       if (result.errorText) throw new Error('Could not load screenshot page: ' + result.errorText);
-      await withTimeout(loaded, 20000, 'Screenshot page load timed out');
+      try { await withTimeout(loaded, 20000, 'Screenshot page load timed out: ' + url); }
+      catch (error) {
+        // Chromium can omit loadEventFired after navigation to an already loaded URL.
+        const state=await send('Runtime.evaluate',{expression:'JSON.stringify({url:location.href,state:document.readyState})',returnByValue:true});
+        const document=JSON.parse(state.result.value||'{}');
+        if(document.url!==url||document.state!=='complete')throw error;
+      }
       await send('Runtime.evaluate', { expression: 'new Promise(resolve => requestAnimationFrame(() => setTimeout(resolve, 150)))', awaitPromise: true });
     };
     const screenshot = async ({ hideConsent = false, clipSelector = '' } = {}) => {
@@ -186,7 +202,7 @@ async function startHeadlessBrowser(executable, profile) {
         await new Promise((resolveExit) => child.once('exit', resolveExit));
       }
     };
-    return { setViewport, navigate, screenshot, metrics, printToPdf, close };
+    return { setViewport, navigate, screenshot, metrics, printToPdf, close, audit: profile => auditBrowser(send, profile) };
   } catch (error) {
     if (child.exitCode === null) {
       child.kill();
@@ -222,16 +238,30 @@ function reportHtml(report, screenshots) {
   const consentPassed = report.consentUi?.passed || 0;
   const consentErrors = Math.max(0, consentChecks - consentPassed);
   const consentScore = consentChecks ? Math.floor(consentPassed / consentChecks * 100) + '%' : '—';
+  const browserChecks = report.browserChecks || { status: 'not run', results: [] };
+  const browserRows = [['Device emulation', ['device']], ['Browser structure and accessibility tree', ['structure', 'semantics']], ['Keyboard sample', ['keyboard']]]
+    .map(([label, groups]) => {
+      const checks = browserChecks.results.flatMap(result => result.checks).filter(check => groups.includes(check.group));
+      const errors = checks.filter(check => !check.passed).length;
+      const status = ['unavailable', 'incomplete'].includes(browserChecks.status) ? browserChecks.status : checks.length ? errors ? 'fail' : 'pass' : 'not run';
+      return '<tr><th scope="row">' + label + '</th><td>' + escapeHtml(status) + '</td><td>—</td><td>' + checks.length + '</td><td>' + errors + '</td><td>0</td></tr>';
+    }).join('');
+  const browserDetails = '<p>Device profiles run in an isolated headless Chromium browser. Accessibility-tree checks inspect what assistive technology can receive; no physical device or screen reader was operated. Keyboard checks use real Tab, Shift+Tab and Enter events, sampling at most 12 focus stops per page/profile.</p>' +
+    '<p>Status: ' + escapeHtml(browserChecks.status) + (browserChecks.reason ? ' · ' + escapeHtml(browserChecks.reason) : '') + '</p>' +
+    (browserChecks.results.length ? '<table><caption>Browser simulation results</caption><thead><tr><th scope="col">Page</th><th scope="col">Profile</th><th scope="col">Status</th><th scope="col">Checks</th><th scope="col">Failures</th></tr></thead><tbody>' +
+      browserChecks.results.map(result => '<tr><th scope="row">' + escapeHtml(result.page) + '</th><td>' + escapeHtml(result.profile + ' · ' + result.colorScheme) +
+        '</td><td>' + escapeHtml(result.status) + '</td><td>' + result.checks.length + '</td><td>' +
+        escapeHtml(result.checks.filter(check => !check.passed).map(check => check.group + ': ' + check.name + (check.detail ? ' (' + check.detail + ')' : '')).join('; ')) + '</td></tr>').join('') + '</tbody></table>' : '');
   const typeLabel = (type) => ({ post: 'Posts', page: 'Pages', homepage: 'Homepages', system: 'System routes', consent: 'Consent interface' })[type] || type;
   const statusTable = '<table><caption>Audit results</caption><thead><tr><th scope="col">Audit</th><th scope="col">Status</th>' +
     '<th scope="col">Score</th><th scope="col">Checks</th><th scope="col">Errors</th><th scope="col">Warnings</th></tr></thead><tbody>' +
-    '<tr><th scope="row">Accessibility</th><td>' + escapeHtml(report.accessibility.status) + '</td><td>' + report.accessibility.score +
+    '<tr><th scope="row">Accessibility (HTML/CSS structure)</th><td>' + escapeHtml(report.accessibility.status) + '</td><td>' + report.accessibility.score +
     '%</td><td>' + report.accessibility.checks + '</td><td>' + report.accessibility.errors + '</td><td>' + report.accessibility.warnings + '</td></tr>' +
     '<tr><th scope="row">Agent friendliness</th><td>' + escapeHtml(report.agentFriendliness.status) + '</td><td>' + report.agentFriendliness.score +
     '%</td><td>' + report.agentFriendliness.checks + '</td><td>' + report.agentFriendliness.errors + '</td><td>' + report.agentFriendliness.warnings + '</td></tr>' +
     '<tr><th scope="row">Markdown rendering</th><td>' + escapeHtml(report.markdownRendering?.status || 'not run') + '</td><td>—</td><td>' +
     (report.markdownRendering?.checks || 0) + '</td><td>' + ((report.markdownRendering?.checks || 0) - (report.markdownRendering?.passed || 0)) + '</td><td>0</td></tr>' +
-    '<tr><th scope="row">Consent interface</th><td>' + escapeHtml(report.consentUi?.status || 'not checked') + '</td><td>' + consentScore +
+    browserRows + '<tr><th scope="row">Consent interface</th><td>' + escapeHtml(report.consentUi?.status || 'not checked') + '</td><td>' + consentScore +
     '</td><td>' + consentChecks + '</td><td>' + consentErrors + '</td><td>0</td></tr>' +
     '<tr><th scope="row">Report reading structure</th><td>' + escapeHtml(reportReading.status) + '</td><td>' +
     Math.floor(reportReading.passed / Math.max(1, reportReading.checks) * 100) + '%</td><td>' + reportReading.checks +
@@ -277,14 +307,15 @@ function reportHtml(report, screenshots) {
     '<body><a class="skip-link" href="#main">Skip to report</a><header><h1>EdgePress accessibility and content report</h1><p>Generated ' +
     escapeHtml(report.generatedAt) + ' · Overall status: <span class="status">' + escapeHtml(report.status) + '</span>.</p>' +
     '<nav class="report-nav" aria-label="Report sections"><ul><li><a href="#summary">Summary</a></li><li><a href="#content">Content reviewed</a></li>' +
-    '<li><a href="#findings">Findings</a></li><li><a href="#markdown">Markdown rendering</a></li><li><a href="#consent">Consent interface</a></li><li><a href="#evidence">Screenshots</a></li><li><a href="#scope">Scope</a></li></ul></nav></header>' +
+    '<li><a href="#findings">Findings</a></li><li><a href="#markdown">Markdown rendering</a></li><li><a href="#browser">Browser simulations</a></li><li><a href="#consent">Consent interface</a></li><li><a href="#evidence">Screenshots</a></li><li><a href="#scope">Scope</a></li></ul></nav></header>' +
     '<main id="main"><section id="summary"><h2>Audit summary</h2>' + statusTable + summary + '<p>Generated HTML documents: ' + report.pages +
     ' · HTML bytes: ' + report.metrics.htmlBytes + ' · Stylesheet references: ' + report.metrics.stylesheets +
     ' · Script references: ' + report.metrics.scripts + '.</p></section>' +
     '<section id="content"><h2>Content reviewed</h2><p>Every generated post and customizable page is listed with its generated route and audit status. Posts are checked alongside pages.</p>' +
     documentSections + '</section><section id="findings"><h2>Findings</h2>' + findings + '</section>' +
     '<section id="markdown"><h2>Markdown rendering verification</h2><p>' + escapeHtml(String(report.markdownRendering?.passed || 0)) + ' of ' +
-    escapeHtml(String(report.markdownRendering?.checks || 0)) + ' syntax checks passed across the tutorial post locales.</p>' + markdownDetails + '</section>' +
+    escapeHtml(String(report.markdownRendering?.checks || 0)) + ' syntax checks passed using an in-memory renderer fixture. No tutorial article needs to be published.</p>' + markdownDetails + '</section>' +
+    '<section id="browser"><h2>Device, accessibility-tree and keyboard simulations</h2>' + browserDetails + '</section>' +
     '<section id="consent"><h2>Consent interface checks</h2><p>Consent component checks run separately from page-content layout checks.</p>' +
     (consentDetails ? '<ul>' + consentDetails + '</ul>' : '<p>No consent UI checks were run.</p>') + '</section>' +
     '<section id="evidence" class="appendix"><h2>Responsive and consent screenshots</h2><p>Page screenshots use a 390 by 844 CSS pixel mobile viewport and hide the consent component while measuring page content. Separate consent screenshots crop the component at desktop and mobile sizes.</p>' +
@@ -362,6 +393,10 @@ async function startReportServer(output, evidenceDirectory, htmlPath) {
           catch { target = resolve(target, 'index.html'); info = await lstat(target); }
         } else throw error;
       }
+      if (info.isDirectory() && !info.isSymbolicLink()) {
+        target = resolve(target, 'index.html');
+        info = await lstat(target);
+      }
       if (info.isSymbolicLink() || !info.isFile()) {
         response.writeHead(404);
         response.end();
@@ -392,11 +427,12 @@ function siteAddress(relativeFile) {
 }
 
 export async function addVisualEvidence(config, report) {
-  const root = resolve(config.root, 'tools');
-  const directoryInfo = await lstat(root);
-  if (directoryInfo.isSymbolicLink() || !directoryInfo.isDirectory()) throw new Error('Report directory must be a real directory');
+  const root = await reportDirectory(config.root);
   const browser = await browserPath();
+  report.browserChecks = { status: 'unavailable', physicalDevices: 'not tested', screenReaders: 'not tested',
+    method: 'Headless Chromium device emulation, accessibility tree and CDP keyboard input', keyboardSampleLimit: 12, results: [] };
   if (!browser) {
+    report.browserChecks.reason = 'No installed Chromium browser was found.';
     return { status: 'unavailable', reason: 'Install Microsoft Edge, Chrome, or Chromium to capture page screenshots and PDF evidence.' };
   }
 
@@ -407,6 +443,10 @@ export async function addVisualEvidence(config, report) {
   const pdfPath = resolve(root, 'page-check.pdf');
   let reportServer;
   let browserSession;
+  const browserSessions=[];
+  const runInBrowsers=async(items,task)=>Promise.all(browserSessions.map(async(session,worker)=>{
+    for(let index=worker;index<items.length;index+=browserSessions.length)await task(session,items[index],index);
+  }));
   try {
     await mkdir(evidenceDirectory, { recursive: true });
     const evidenceInfo = await lstat(evidenceDirectory);
@@ -418,6 +458,8 @@ export async function addVisualEvidence(config, report) {
     for (const locale of config.i18n.locales) {
       const prefix = locale === config.i18n.defaultLocale ? '' : locale + '/';
       candidates.add(prefix + 'index.html');
+      candidates.add(prefix + 'archives/index.html');
+      candidates.add(prefix + 'search/index.html');
       candidates.add(prefix + 'privacy-policy/index.html');
     }
     for (const issue of report.issues) {
@@ -469,8 +511,38 @@ export async function addVisualEvidence(config, report) {
       }
     }
     reportServer = await startReportServer(config.resolvedPaths.output, evidenceDirectory, htmlPath);
-    browserSession = await startHeadlessBrowser(browser, profile);
-    for (const screenshot of screenshots) {
+    for(let worker=0;worker<Math.min(3,available.length||1);worker++){
+      const browserProfile=resolve(profile,'browser-'+worker);await mkdir(browserProfile);
+      browserSessions.push(await startHeadlessBrowser(browser,browserProfile));
+    }
+    browserSession=browserSessions[0];
+    let reviewed=0;
+    const pageResults=new Array(available.length);
+    await runInBrowsers(available,async(browserSession,relativeFile,index)=>{
+      const results=[];
+      for (const device of deviceProfiles) for (const colorScheme of ['light', 'dark']) {
+        const emulation = { ...device, colorScheme };
+        await browserSession.setViewport(emulation);
+        await browserSession.navigate('http://127.0.0.1:' + reportServer.port + siteAddress(relativeFile));
+        const result = { page: relativeFile, profile: device.name, colorScheme, ...await browserSession.audit(emulation) };
+        results.push(result);
+      }
+      pageResults[index]=results;
+      report.browserChecks.results=pageResults.filter(Boolean).flat();
+      reviewed+=1;if(reviewed%25===0||reviewed===available.length)console.log('Browser checks: '+reviewed+'/'+available.length+' pages');
+    });
+    report.browserChecks.results=pageResults.flat();
+    for(const result of report.browserChecks.results)for(const check of result.checks.filter(item=>!item.passed)){
+      report.issues.push({severity:'error',category:'browser-'+check.group,page:result.page,
+        message:result.profile+'/'+result.colorScheme+': '+check.name+(check.detail?' ('+check.detail+')':'')+'.'});
+    }
+    report.browserChecks.status = report.browserChecks.results.every(result => result.status === 'pass') ? 'pass' : 'fail';
+    if (!report.browserChecks.results.length) {
+      report.browserChecks.status = 'unavailable';
+      report.browserChecks.reason = 'No generated pages were available for browser checks.';
+    }
+    let captured=0;
+    await runInBrowsers(screenshots,async(browserSession,screenshot)=>{
       const viewport = screenshot.viewport === 'mobile' ? mobile : desktop;
       await browserSession.setViewport(viewport);
       await browserSession.navigate('http://127.0.0.1:' + reportServer.port + siteAddress(screenshot.page));
@@ -502,7 +574,7 @@ export async function addVisualEvidence(config, report) {
       if (!image) {
         report.issues.push({ severity: 'error', category: screenshot.capture === 'consent' ? 'consent-ui' : 'visual-evidence',
           page: screenshot.page, message: 'The requested screenshot area was not present in the browser.' });
-        continue;
+        return;
       }
       await writeFile(screenshot.target, image);
       const imageInfo = await lstat(screenshot.target);
@@ -519,7 +591,8 @@ export async function addVisualEvidence(config, report) {
         report.issues.push({ severity: 'error', category: 'responsive-layout', page: screenshot.page,
           message: 'Page content width is ' + dimensions.pageDocumentWidth + ' CSS pixels for a ' + dimensions.viewportWidth + ' pixel viewport; consent UI is measured separately.' });
       }
-    }
+      captured+=1;if(captured%50===0||captured===screenshots.length)console.log('Report screenshots: '+captured+'/'+screenshots.length);
+    });
     if (report.consentUi?.visualChecks) {
       const visualChecks = report.consentUi.visualChecks;
       report.consentUi.checks += visualChecks.length;
@@ -534,7 +607,7 @@ export async function addVisualEvidence(config, report) {
       if (findings.some((item) => item.severity === 'error')) document.status = 'fail';
       else if (findings.length) document.status = 'warning';
     }
-    report.visualEvidence = { status: 'complete', pdf: 'tools/page-check.pdf', screenshots: screenshots.filter((item) => item.viewportWidth).map((item) => ({
+    report.visualEvidence = { status: 'complete', pdf: 'tools/reports/page-check.pdf', screenshots: screenshots.filter((item) => item.viewportWidth).map((item) => ({
       page: item.page, type: item.type, capture: item.capture, title: item.title, viewport: item.viewport, width: item.width, height: item.height,
       viewportWidth: item.viewportWidth, documentWidth: item.documentWidth,
       consentWidth: item.consentWidth, consentHeight: item.consentHeight, consentWithinViewport: item.consentWithinViewport,
@@ -544,7 +617,7 @@ export async function addVisualEvidence(config, report) {
     const reportAccessibility = checkReportReadingStructure(initialHtml);
     report.visualEvidence.reportAccessibility = reportAccessibility;
     for (const check of reportAccessibility.results.filter((item) => !item.passed)) {
-      report.issues.push({ severity: 'error', category: 'report-accessibility', page: 'tools/page-check.pdf',
+      report.issues.push({ severity: 'error', category: 'report-accessibility', page: 'tools/reports/page-check.pdf',
         message: 'Report reading requirement failed: ' + check.name + '.' });
     }
     report.errors = report.issues.filter((item) => item.severity === 'error').length;
@@ -562,7 +635,7 @@ export async function addVisualEvidence(config, report) {
     await writeFile(pdfPath, pdf);
     return report.visualEvidence;
   } finally {
-    if (browserSession) await browserSession.close();
+    await Promise.allSettled(browserSessions.map(session=>session.close()));
     if (reportServer) await new Promise((resolveClose) => reportServer.server.close(resolveClose));
     await rm(profile, { recursive: true, force: true, maxRetries: 5, retryDelay: 250 });
   }

package/src/revision-cards.js

@@ -0,0 +1,30 @@
+import {renderMarkdown} from './markdown.js';
+const escape=value=>String(value).replace(/[&<>"']/g,char=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[char]));
+
+// Git is a build-time source of history. Readers see changed passages, not patches.
+export function changedPassages(diff){
+ const groups=[];let before=[],after=[];
+ const finish=()=>{if(before.length||after.length)groups.push({before:before.join('\n'),after:after.join('\n')});before=[];after=[];};
+ for(const line of String(diff).split(/\r?\n/)){
+  if(/^(?:diff --git|index |--- |\+\+\+ |\\)/.test(line))continue;
+  if(line.startsWith('-'))before.push(line.slice(1));
+  else if(line.startsWith('+'))after.push(line.slice(1));
+  else finish();
+ }
+ finish();return groups.filter(group=>group.before.trim()||group.after.trim());
+}
+export async function renderRevisionCards(diff,label,images,options={}){
+ const groups=changedPassages(diff);if(!groups.length)return '';
+ const cards=[];
+ for(const group of groups){
+  const sides=[];
+  for(const side of ['before','after'])if(group[side].trim()){
+   const key=side==='before'?(group.after.trim()?'postChangeBefore':'postChangeRemoved'):(group.before.trim()?'postChangeAfter':'postChangeAdded');
+   const known=new Set(Object.values(images?.[side]||{}));
+   const content=(await renderMarkdown(group[side],{allowImages:!!images,allowVideo:false,...(options.linkResolver?{linkResolver:options.linkResolver}:{}),...(images?{imageResolver:href=>images[side]?.[href]||(known.has(href)?href:null)}:{})})).replace(/<h[1-6]\b[^>]*>/g,'<p class="post-change-heading">').replace(/<\/h[1-6]>/g,'</p>');
+   sides.push('<div class="post-change-side post-change-'+side+'"><p class="post-change-label">'+escape(label(key))+'</p><div class="post-change-content">'+content+'</div></div>');
+  }
+  cards.push('<div class="post-change-passage">'+sides.join('')+'</div>');
+ }
+ return '<details class="post-changes"><summary>'+escape(label('postChanges'))+'</summary><div class="post-changes-list">'+cards.join('')+'</div></details>';
+}

package/src/revision-images.js

@@ -0,0 +1,44 @@
+import {createHash} from 'node:crypto';
+import {readFile} from 'node:fs/promises';
+import {relative,resolve,sep,extname} from 'node:path';
+import {imageSize} from 'image-size';
+import {renderMarkdown} from './markdown.js';
+
+const decode=value=>value.replace(/&(?:amp|quot|apos|lt|gt);/g,entity=>({'&amp;':'&','&quot;':'"','&apos;':"'",'&lt;':'<','&gt;':'>'}[entity]));
+export async function revisionImageReferences(text){
+ const html=await renderMarkdown(text,{allowVideo:false}),images=new Map();
+ for(const match of html.matchAll(/<img\b[^>]*>/gi)){
+  const attr=name=>decode(match[0].match(new RegExp('\\b'+name+'="([^"]*)"','i'))?.[1]||'');
+  const src=attr('src');if(src)images.set(src,attr('alt'));
+ }
+ return images;
+}
+export function revisionImageFile(href,assetsRoot){
+ if(!assetsRoot||!href.startsWith('/')||href.startsWith('//'))return null;
+ let path;try{path=decodeURIComponent(href.split(/[?#]/)[0]);}catch{return null;}
+ if(/[\\\0]/.test(path)||!/\.(?:png|jpe?g|gif|webp|avif|svg)$/i.test(path))return null;
+ const root=resolve(assetsRoot),file=resolve(root,'.'+path);return file.startsWith(root+sep)?file:null;
+}
+export async function revisionImageState(text,assetsRoot,root,commit,git){
+ const refs=await revisionImageReferences(text),images=new Map();
+ for(const [href,alt] of refs){
+  const file=revisionImageFile(href,assetsRoot);if(!file)continue;
+  try{const path=relative(root,file).split(sep).join('/'),oid=(await git(root,commit?['rev-parse',commit+':'+path]:['hash-object','--',file])).trim();images.set(href,{file,path,oid,alt});}catch{}
+ }
+ return images;
+}
+export async function snapshotRevisionImages(before,after,diff,root,binaryGit){
+ const changed=await revisionImageReferences(diff.split(/\r?\n/).filter(line=>/^[+-](?![+-])/.test(line)).map(line=>line.slice(1)).join('\n'));
+ const assets=new Map(),sides={before:Object.create(null),after:Object.create(null)};
+ for(const [side,state] of [['before',before],['after',after]])for(const [href,image] of state.images){
+  if(!changed.has(href))continue;
+  try{
+   const content=state.commit?await binaryGit(root,['show',state.commit+':'+image.path]):await readFile(image.file);
+   if(content.length>20_000_000)continue;
+   const size=imageSize(content);if(!(size.width>0&&size.height>0))continue;
+   const hash=createHash('sha256').update(content).digest('hex').slice(0,16),path='edgepress/revisions/image.'+hash+extname(image.file).toLowerCase();
+   assets.set(path,{path,content});sides[side][href]='/'+path;
+  }catch{ /* Missing historical bytes never produce a broken image request. */ }
+ }
+ return {revisionImages:sides,revisionAssets:[...assets.values()]};
+}

package/src/revisions.js

@@ -0,0 +1,77 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdtemp, writeFile, stat, unlink, rmdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, relative, join } from 'node:path';
+import { parse } from 'yaml';
+import {revisionImageReferences,revisionImageFile,revisionImageState,snapshotRevisionImages} from './revision-images.js';
+
+const run = promisify(execFile);
+const git = (cwd, args) => run('git', args, {cwd, maxBuffer: 2_000_000}).then(result => result.stdout);
+function articleText(source) {
+  const match = source.replace(/^\uFEFF/, '').match(/^---\r?\n([\s\S]*?)\r?\n(?:---|\.\.\.)\r?\n([\s\S]*)$/);
+  if (!match) return source.replace(/\r\n/g, '\n').trim();
+  const metadata = parse(match[1]);
+  const body=match[2].replace(/\r\n/g, '\n').trim();
+  // A post may expose the same cover in front matter and in its Markdown body.
+  // Include the synthetic cover only when the body does not already reference it;
+  // otherwise one edit produces two identical before/after passages.
+  const image=typeof metadata?.image==='string' && !body.includes(']('+metadata.image+')')
+    ? '![Cover]('+metadata.image+')\n\n' : '';
+  return '# ' + String(metadata?.title || '') + '\n\n' + image + body;
+}
+async function difference(before, after) {
+  const folder = await mkdtemp(join(tmpdir(), 'edgepress-revision-'));
+  const left = join(folder, 'before.md'), right = join(folder, 'after.md');
+  try {
+    await writeFile(left, before + '\n'); await writeFile(right, after + '\n');
+    let output;
+    try { output = await git(folder, ['diff', '--no-index', '--no-color', '--unified=3', '--', left, right]); }
+    catch (error) { if (error.code !== 1) throw error; output = error.stdout; }
+    return output.split('\n').filter(line => !/^(diff --git|index |--- |\+\+\+ )/.test(line)).join('\n').trim();
+  } finally {
+    await Promise.all([unlink(left).catch(()=>{}), unlink(right).catch(()=>{})]);
+    await rmdir(folder);
+  }
+}
+
+// Release numbering and front-matter-only changes do not change article history.
+export async function readPostRevision(file, source, showChanges = false, assetsRoot = null) {
+  const empty = {updated: null, changes: ''};
+  try {
+    const root = (await git(dirname(file), ['rev-parse', '--show-toplevel'])).trim();
+    const path = relative(root, file).split('\\').join('/');
+    const current = articleText(source),refs=await revisionImageReferences(current);
+    const imagePaths=[...refs.keys()].map(href=>revisionImageFile(href,assetsRoot)).filter(Boolean).map(file=>relative(root,file).split('\\').join('/'));
+    const entries = (await git(root, ['log', '-n', '20', '--format=%H%x09%cI', '--', path,...imagePaths])).trim().split('\n').filter(Boolean);
+    if (!entries.length) return empty;
+    const working={text:current,commit:null,images:await revisionImageState(current,assetsRoot,root,null,git)};
+    const signature=state=>state.text+'\n'+JSON.stringify([...state.images].map(([href,image])=>[href,image.oid]));
+    const result=async(before,after,updated)=>{
+      if(!showChanges)return {updated,changes:''};
+      let changes=await difference(before.text,after.text);
+      for(const [href,image] of after.images){const old=before.images.get(href);if(old&&old.oid!==image.oid&&!changes.includes(href))changes+='\n-!['+old.alt.replace(/[\[\]\r\n]/g,'')+']('+href+')\n+!['+image.alt.replace(/[\[\]\r\n]/g,'')+']('+href+')';}
+      const snapshots=await snapshotRevisionImages(before,after,changes,root,(cwd,args)=>run('git',args,{cwd,maxBuffer:20_000_000,encoding:'buffer'}).then(result=>result.stdout));
+      return {updated,changes,...snapshots};
+    };
+    const history = [];
+    for (const entry of entries) {
+      const [commit, timestamp] = entry.split('\t');
+      let text;try{text=articleText(await git(root,['show',commit+':'+path]));}catch{break;}
+      const state={text,commit,updated:new Date(timestamp),images:await revisionImageState(text,assetsRoot,root,commit,git)};
+      history.push(state);
+      if (history.length === 1 && signature(state) !== signature(working)) {
+        const updated = (await stat(file)).mtime;
+        return result(state,working,updated);
+      }
+      if (history.length > 1 && signature(history.at(-2)) !== signature(state)) {
+        const latest = history.at(-2);
+        return result(state,latest,latest.updated);
+      }
+    }
+    return empty;
+  } catch (error) {
+    // Missing Git or shallow history must never fabricate previous content.
+    return empty;
+  }
+}

package/src/rss.js

@@ -0,0 +1,100 @@
+import { renderMarkdown, plainText } from './markdown.js';
+import { localizedContentUrl, localizedUrl } from './i18n.js';
+import { authorForPost, normalizeCategory } from './post-details.js';
+
+function xml(value) {
+  return String(value ?? '')
+    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g, '')
+    .replace(/[&<>"']/g, char => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' })[char]);
+}
+
+function decodeAttribute(value) {
+  return String(value).replace(/&(?:amp|quot|apos|lt|gt);/gi, entity => ({
+    '&amp;': '&', '&quot;': '"', '&apos;': "'", '&lt;': '<', '&gt;': '>'
+  })[entity.toLowerCase()]);
+}
+
+// Feed HTML has no reliable base URL. Its images and internal links must work
+// independently of the original article page, without adding active embeds.
+export function absoluteContentUrls(html, articleUrl) {
+  return String(html).replace(/\b(href|src)="([^"]*)"/g, (attribute, name, encoded) => {
+    const value = decodeAttribute(encoded);
+    if (/^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(value)) return attribute;
+    try {
+      const url = new URL(value, articleUrl);
+      if (url.protocol !== 'https:' && url.protocol !== 'http:') return attribute;
+      return name + '="' + url.href.replace(/&/g, '&amp;').replace(/"/g, '&quot;') + '"';
+    } catch {
+      return attribute;
+    }
+  });
+}
+
+function canonicalUrl(post, config) {
+  return config.site.url + '/' + String(post.path).split('/').filter(Boolean).map(encodeURIComponent).join('/') + '/';
+}
+
+function lastChanged(post) {
+  return post.updated instanceof Date && post.updated > post.date ? post.updated : post.date;
+}
+
+function categories(post) {
+  const category = normalizeCategory(post.category);
+  return [...new Set([...(category === 'uncategorized' ? [] : [category]), ...(post.tags || [])])];
+}
+
+function isSiteImage(href, config) {
+  const value = String(href ?? '');
+  if (value.startsWith('/') && !value.startsWith('//')) return value;
+  try {
+    const url = new URL(value);
+    return url.protocol === 'https:' && url.origin === new URL(config.site.url).origin ? value : '';
+  } catch { return ''; }
+}
+
+// Returns a single standard RSS 2.0 document; no hand-maintained XML assets.
+export async function generateRssRoute(posts, config, locale) {
+  const prefix = locale === config.i18n.defaultLocale ? '' : locale + '/';
+  const homeUrl = config.site.url + localizedUrl(config, locale, '');
+  const rssUrl = config.site.url + localizedUrl(config, locale, 'rss.xml');
+  const items = await Promise.all(posts.slice(0, 20).map(async post => {
+    const url = canonicalUrl(post, config);
+    // Re-render static Markdown with the normal sanitizer. Omit interactive
+    // embed/player markup and remote images that may bypass reader consent.
+    const rendered = await renderMarkdown(post.markdown || '', {
+      ...config.markdown,
+      linkResolver: href => localizedContentUrl(config, post.locale, href),
+      imageResolver: href => isSiteImage(href, config),
+      allowVideo: false
+    });
+    return {
+      url, title: post.title,
+      author: authorForPost(post, config).name || config.site.title,
+      locale: post.locale, published: post.date, updated: lastChanged(post),
+      summary: plainText(post.description || post.markdown).slice(0, 220),
+      content: absoluteContentUrls(rendered, url), categories: categories(post)
+    };
+  }));
+  const lastBuild = items.reduce((latest, item) => item.updated > latest ? item.updated : latest, new Date(0));
+  const rssItems = items.map(item =>
+    '<item><title>' + xml(item.title) + '</title><link>' + xml(item.url) + '</link>' +
+    '<guid isPermaLink="true">' + xml(item.url) + '</guid>' +
+    '<pubDate>' + item.published.toUTCString() + '</pubDate>' +
+    '<dc:date>' + item.updated.toISOString() + '</dc:date>' +
+    '<dc:creator>' + xml(item.author) + '</dc:creator>' +
+    '<dc:language>' + xml(item.locale) + '</dc:language>' +
+    '<description>' + xml(item.summary) + '</description>' +
+    item.categories.map(category => '<category>' + xml(category) + '</category>').join('') +
+    '<content:encoded>' + xml(item.content) + '</content:encoded></item>'
+  ).join('');
+  const rss = '<?xml version="1.0" encoding="utf-8"?>' +
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" ' +
+    'xmlns:content="http://purl.org/rss/1.0/modules/content/" ' +
+    'xmlns:dc="http://purl.org/dc/elements/1.1/"><channel>' +
+    '<title>' + xml(config.site.title) + '</title><link>' + xml(homeUrl) + '</link>' +
+    '<description>' + xml(config.site.description) + '</description><language>' + xml(locale) + '</language>' +
+    '<lastBuildDate>' + lastBuild.toUTCString() + '</lastBuildDate>' +
+    '<atom:link href="' + xml(rssUrl) + '" rel="self" type="application/rss+xml"/>' +
+    rssItems + '</channel></rss>';
+  return { path: prefix + 'rss.xml', body: rss, contentType: 'application/rss+xml; charset=utf-8' };
+}

package/src/service-block.js

@@ -0,0 +1,18 @@
+import {translate, translateValue} from './i18n.js';
+const escape = value => String(value ?? '').replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+export function renderServiceBlock(document, locale, config, id, page = false) {
+  const service = config.browserPlugins.services.find(item => item.id === id);
+  if (service?.enabled === false) return '';
+  if (!service && !config.browserPlugins.services.some(item => item.enabled !== false && item.provider === 'external-widget')) return '';
+  if (!service || service.provider !== 'external-widget') throw new Error('Service block needs a registered external-widget: ' + id);
+  if (!document?.bundlePath) throw new Error('Service block needs a published document');
+  const thread = (page ? 'page:' : '') + document.bundlePath;
+  return '<section class="edgepress-service" data-edgepress-service="' + escape(id) + '" data-service-thread="' + escape(thread) + '" data-service-title="' + escape(document.title) + '"><h2>' + escape(translateValue(config, locale, service.name)) + '</h2><button type="button" data-service-load="' + escape(id) + '">' + escape(translate(config, locale, 'serviceLoad')) + '</button><button type="button" data-service-consent-settings>' + escape(translate(config, locale, 'privacySettings')) + '</button></section>';
+}
+export function renderPostServices(document, locale, config) {
+  return config.browserPlugins.services.filter(item => item.enabled !== false && item.provider === 'external-widget' && item.placement === 'posts').map(item => renderServiceBlock(document, locale, config, item.id)).join('');
+}
+export function hasServiceBlock(rows) {
+  const contains = blocks => blocks.some(block => block.type === 'service' || (block.type === 'section' && contains(block.blocks || [])));
+  return (rows || []).some(row => (row.cells || []).some(contains));
+}