edgepress 2026.10.1 → 2026.10.13

package/tests/post-list.test.mjs

@@ -0,0 +1,96 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { renderBlocks } from '../src/page-blocks.js';
+import { postsForLocale } from '../src/content.js';
+import { categorySlug, categoryFilter, readingMinutes, safeAvatar, authorForPost } from '../src/post-details.js';
+
+const config = {
+  site: { archive: { categories: ['博客', '未分类'] } },
+  markdown: { gfm: true, breaks: false },
+  i18n: { defaultLocale: 'en', translationsByLocale: { en: { noPosts: 'No posts', allPosts: 'All posts' } } }
+};
+function post(id, locale, category, day = 1) {
+  return { bundlePath: id, locale, category, tags: ['edgepress'], title: id + '-' + locale, path: locale + '/' + id + '/',
+    date: new Date('2026-09-' + String(day).padStart(2, '0') + 'T00:00:00Z'), description: '**Formatted** excerpt', author: '' };
+}
+function render(block, posts, locale = 'en') {
+  return renderBlocks([{ columns: 1, cells: [[{ type: 'post-list', title: 'Project articles', ...block }]] }],
+    { config, locale, site: { posts } });
+}
+
+test('pinned and recent lists display each article once per page, filling remaining slots',async()=>{
+  const posts=[{...post('latest','en','blog',5),pinned:true},post('second','en','blog',4),post('third','en','blog',3)];
+  const rows=[{columns:2,cells:[[
+    {type:'section',title:'Featured',blocks:[{type:'post-list',title:'Pinned',category:'blog',count:1}]}
+  ],[{type:'latest-posts',title:'Recent',category:'blog',count:2}]]}];
+  const context={config,locale:'en',site:{posts}};
+  const html=await renderBlocks(rows,context);
+  assert.equal((html.match(/latest-en/g)||[]).length,1);
+  assert.match(html,/second-en/);assert.match(html,/third-en/);
+  assert.equal((html.match(/class="post-card"/g)||[]).length,3);
+  assert.match(await renderBlocks([{columns:1,cells:[[{type:'latest-posts',title:'Other page',count:1}]]}],context),/latest-en/);
+});
+
+test('categories select translations, sort before limiting, and ignore tags', async () => {
+  const posts = [post('old', 'en', 'edgepress'), post('new', 'en', 'EdgePress', 3),
+    post('new', 'zh-SG', 'edgepress', 3), post('other', 'zh-SG', 'blog', 4)];
+  const html = await render({ category: 'edgepress', count: 1 }, posts, 'zh-SG');
+  assert.match(html, /new-zh-SG/);
+  assert.doesNotMatch(html, /new-en|other-zh-SG|old-en/);
+  assert.match(html, /href="\/zh-SG\/categories\/edgepress\/"/);
+  assert.match(html, /<strong>Formatted<\/strong>/);
+});
+
+test('journal accepts Chinese aliases and missing categories, excluding project articles', async () => {
+  const html = await render({ categories: ['博客', '未分類'] }, [post('blog', 'en', 'blog'), post('new', 'en'), post('project', 'en', 'edgepress')]);
+  assert.match(html, /blog-en/);
+  assert.match(html, /new-en/);
+  assert.doesNotMatch(html, /project-en/);
+  assert.deepEqual(categoryFilter(['博客', 'BLOG', '未分类']), ['blog', 'uncategorized']);
+  assert.equal(categorySlug('技术'), 'category-6280-672f');
+});
+
+test('empty results, validation, and archive-matched homepage pagination', async () => {
+  assert.match(await render({ category: 'edgepress' }, []), /No posts/);
+  for (const tag of ['edgepress', '', null]) await assert.rejects(render({ tag }, []), /no longer supported/);
+  await assert.rejects(render({ category: 'edgepress', paginate: true }, []), /same categories/);
+  await assert.rejects(render({ count: 13 }, []), /1 to 12/);
+  await assert.rejects(render({ category: 'blog', categories: ['blog'] }, []), /not both/);
+  assert.match(await render({ type: 'latest-posts', paginate: true, categories: ['博客', '未分类'] }, [post('blog','en','blog')]), /blog-en/);
+});
+
+test('author defaults and avatar validation preserve safe paths without script URLs', () => {
+  assert.deepEqual(authorForPost({ author: 'Guest', authorAvatar: '/guest.png' }, { site: { author: { name: 'Site', avatar: '/site.png' } } }), { name: 'Guest', avatar: '/guest.png' });
+  assert.equal(safeAvatar('https://example.org/avatar.png'), 'https://example.org/avatar.png');
+  for (const src of ['javascript:alert(1)', '//elsewhere/avatar.png', 'http://example.org/a.png', '/bad\\a.png', 'https://user:pass@example.org/a.png']) assert.throws(() => safeAvatar(src), /safe site path/);
+});
+
+test('reading estimates count Chinese characters and English words together', () => {
+  assert.equal(readingMinutes(''), 1);
+  assert.equal(readingMinutes('word '.repeat(201)), 2);
+  assert.equal(readingMinutes('文'.repeat(301)), 2);
+  assert.equal(readingMinutes('文'.repeat(150)+' word'.repeat(100)), 1);
+});
+
+test('fallback language selection stays stable when neither requested nor default language exists', () => {
+  const simplified = post('only-Chinese', 'zh-SG', 'blog');
+  const traditional = post('only-Chinese', 'zh-TW', 'blog');
+  assert.equal(postsForLocale([traditional, simplified], 'en', 'en')[0].locale, 'zh-SG');
+  assert.equal(postsForLocale([simplified, traditional], 'en', 'en')[0].locale, 'zh-SG');
+  assert.equal(postsForLocale([simplified, traditional], 'zh-TW', 'en')[0].locale, 'zh-TW');
+});
+
+test('post-list places pinned articles before the count limit while latest-posts keep date order', async () => {
+  const old = {...post('old-pin','en','edgepress',1),pinned:true};
+  const recent = post('recent','en','edgepress',8);
+  const translated = {...post('old-pin','zh-TW','edgepress',1),pinned:true};
+  const posts=[recent,old,translated];
+  const featured=await render({category:'edgepress',count:1},posts,'zh-TW');
+  assert.match(featured,/old-pin-zh-TW/);
+  assert.match(featured,/post-pinned/);
+  assert.doesNotMatch(featured,/recent-en|old-pin-en/);
+  const latest=await render({type:'latest-posts',category:'edgepress',count:1},posts);
+  assert.match(latest,/recent-en/);
+  assert.doesNotMatch(latest,/old-pin-en/);
+  assert.equal(posts[0],recent,'Sorting must not mutate the source used by archives and feeds');
+});

package/tests/project-demo.test.mjs

@@ -0,0 +1,73 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {readFile} from 'node:fs/promises';
+import {createServer} from 'node:http';
+import {chromium} from 'playwright';
+import {renderBlocks} from '../src/page-blocks.js';
+import {loadConfig} from '../src/config.js';
+import {loadLanguagePacks} from '../src/i18n.js';
+import {renderLayout} from '../src/theme.js';
+
+test('the complete theme initializes and includes the recording runtime',async()=>{
+ const config=await loadConfig(process.cwd());await loadLanguagePacks(config);
+ const html=await renderLayout(config,{filter:async(_key,value)=>value},{title:'Demo',locale:'en',urlPath:'/demo/'},'<main data-project-demo></main>');
+ assert.match(html,/src="\/edgepress\/project-demo\.js"/);
+});
+
+test('a progressive recording begins playback before the entire response arrives',async()=>{
+ const bytes=await readFile('tests/fixtures/recording.mp4'),runtime=await readFile('static/edgepress/project-demo.js');let completed=false;
+ const server=createServer((request,response)=>{
+  if(request.url==='/demo.js'){response.setHeader('Content-Type','text/javascript');response.end(runtime);return;}
+  if(request.url==='/recording.mp4'){
+   response.setHeader('Content-Type','video/mp4');response.setHeader('Content-Length',bytes.length);response.write(bytes.subarray(0,Math.floor(bytes.length*.9)));
+   const tail=setTimeout(()=>{completed=true;response.end(bytes.subarray(Math.floor(bytes.length*.9)));},3000);response.on('close',()=>clearTimeout(tail));return;
+  }
+  response.setHeader('Content-Type','text/html');response.end('<html><body><div data-project-demo data-animation="/recording.mp4" data-play="Play" data-resume="Continue" data-pause="Pause" data-replay="Replay" data-loading="Loading" data-error="Unavailable"><div class="project-demo-media" style="width:320px;height:180px"><video muted playsinline preload="none" aria-label="Demo"></video></div><button>Play</button><span role="status"></span></div><script src="/demo.js"></script></body></html>');
+ });
+ await new Promise(done=>server.listen(0,'127.0.0.1',done));const browser=await chromium.launch({headless:true,...(process.platform==='win32'?{channel:'msedge'}:{})});
+ try{const page=await browser.newPage();await page.goto('http://127.0.0.1:'+server.address().port+'/',{waitUntil:'domcontentloaded'});await page.getByRole('button',{name:'Play: Demo'}).click();await page.waitForFunction(()=>document.querySelector('video').currentTime>.2);assert.equal(completed,false,'First playback must not wait for the full file');}
+ finally{await browser.close();server.closeAllConnections();await new Promise(done=>server.close(done));}
+});
+
+test('recording blocks accept local streaming media and reject foreign or GIF sources',async()=>{
+ const config={site:{},i18n:{defaultLocale:'en',translationsByLocale:{en:{demoPlay:'Play',demoResume:'Continue',demoPause:'Pause',demoReplay:'Replay',demoLoading:'Loading',demoError:'Unavailable'}}}};
+ const block={type:'media-text',mediaType:'image',src:'/poster.webp',animationSrc:'/demo.mp4',alt:'Publish a post',title:'Publishing',text:'One story.'};
+ const render=override=>renderBlocks([{columns:1,cells:[[{...block,...override}]]}],{config,locale:'en',site:{posts:[]}});
+ assert.match(await render({}),/<video muted playsinline preload="none"/);assert.match(await render({animationSrc:'/demo.webm'}),/data-project-demo/);
+ for(const animationSrc of ['https://foreign.example/demo.mp4','//foreign.example/demo.mp4','/demo.gif','/file.txt'])await assert.rejects(render({animationSrc}));
+});
+
+test('manual recordings support seeking and preserve the playhead without automatic playback',async()=>{
+ // Twelve-second silent test-pattern fixture, generated with FFmpeg and faststart.
+ const bytes=await readFile('tests/fixtures/recording.mp4'),browser=await chromium.launch({headless:true,...(process.platform==='win32'?{channel:'msedge'}:{})});
+ try{
+  const context=await browser.newContext({viewport:{width:600,height:600}}),page=await context.newPage(),errors=[];let downloads=0;
+  page.on('pageerror',error=>errors.push(error.message));
+  await context.route('**/*',async route=>{
+   const url=new URL(route.request().url());assert.equal(url.hostname,'demo.test');
+   if(url.pathname==='/demo.js')return route.fulfill({contentType:'text/javascript',body:await readFile('static/edgepress/project-demo.js')});
+   if(url.pathname==='/demo.mp4'){downloads++;return route.fulfill({contentType:'video/mp4',headers:{'Accept-Ranges':'bytes'},body:bytes});}
+   return route.fulfill({contentType:'text/html',body:'<html><style>body{margin:0}.spacer{height:2500px}.project-demo-media{position:relative;width:400px;height:225px}.project-demo-media img,.project-demo-media video{position:absolute;width:100%;height:100%}[hidden]{display:none!important}input[type=range]{display:block;width:400px;min-height:44px;touch-action:pan-y}</style><body><div class="spacer"></div><div data-project-demo data-animation="/demo.mp4" data-play="Play" data-resume="Continue" data-pause="Pause" data-replay="Replay" data-loading="Loading" data-error="Unavailable"><div class="project-demo-media"><img alt="Demo" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw=="><video hidden muted playsinline preload="none" aria-label="Demo"></video></div><button aria-label="Play: Demo">Play</button><input data-demo-seek type="range" min="0" max="1" value="0" step="0.1" disabled aria-label="Demo progress"><span data-demo-time></span><span role="status"></span></div><div class="spacer"></div><script src="/demo.js"></script></body></html>'});
+  });
+  await page.goto('https://demo.test/');await page.waitForTimeout(300);assert.equal(downloads,0,'Far-away recordings must not load');
+  await page.locator('[data-project-demo]').scrollIntoViewIfNeeded();await page.waitForFunction(()=>document.querySelector('video').duration===12);assert.equal(await page.locator('video').evaluate(v=>v.paused),true);assert.equal(await page.locator('video').evaluate(v=>v.currentTime),0);await page.getByRole('button',{name:'Play: Demo'}).click();await page.waitForFunction(()=>document.querySelector('video').currentTime>.4);assert.ok(downloads>0);assert.equal(await page.locator('video').evaluate(v=>v.currentSrc), 'https://demo.test/demo.mp4');
+  await page.evaluate(()=>scrollTo(0,0));await page.waitForFunction(()=>document.querySelector('video').paused);const paused=await page.locator('video').evaluate(v=>v.currentTime);await page.waitForTimeout(400);assert.equal(await page.locator('video').evaluate(v=>v.currentTime),paused);
+  await page.locator('[data-project-demo]').scrollIntoViewIfNeeded();await page.waitForTimeout(200);assert.equal(await page.locator('video').evaluate(v=>v.currentTime),paused);await page.getByRole('button',{name:'Continue: Demo'}).click();await page.waitForFunction(at=>document.querySelector('video').currentTime>at+.3,paused);
+  await page.getByRole('button',{name:'Pause: Demo'}).click();const chosen=await page.locator('video').evaluate(v=>v.currentTime);await page.evaluate(()=>scrollTo(0,0));await page.waitForTimeout(100);await page.locator('[data-project-demo]').scrollIntoViewIfNeeded();await page.waitForTimeout(350);assert.equal(await page.locator('video').evaluate(v=>v.currentTime),chosen);assert.equal(await page.locator('video').evaluate(v=>v.paused),true);
+  await page.getByRole('button',{name:'Continue: Demo'}).click();await page.waitForFunction(at=>document.querySelector('video').currentTime>at+.3,chosen);
+  await page.evaluate(()=>dispatchEvent(new PageTransitionEvent('pagehide')));const before=await page.locator('video').evaluate(v=>v.currentTime);await page.waitForTimeout(100);await page.evaluate(()=>dispatchEvent(new PageTransitionEvent('pageshow')));await page.waitForTimeout(200);assert.equal(await page.locator('video').evaluate(v=>v.currentTime),before);const seek=page.getByRole('slider',{name:'Demo progress'});await seek.fill('6');await seek.dispatchEvent('input');await page.waitForFunction(()=>document.querySelector('video').currentTime===6);assert.equal(await page.locator('video').evaluate(v=>v.paused),true);assert.equal(await page.locator('[data-demo-time]').textContent(),'0:06 / 0:12');const bounds=await seek.boundingBox();
+  await page.mouse.click(bounds.x+bounds.width*.9,bounds.y+2);assert.equal(await page.locator('video').evaluate(v=>v.currentTime),6,'Range padding must not seek');
+  await seek.evaluate(input=>{const box=input.getBoundingClientRect();for(const [type,x,y]of [['pointerdown',box.x+80,box.y+22],['pointermove',box.x+82,box.y+50],['pointerup',box.x+82,box.y+50]])input.dispatchEvent(new PointerEvent(type,{pointerId:7,pointerType:'touch',button:0,clientX:x,clientY:y,bubbles:true}));});
+  assert.equal(await page.locator('video').evaluate(v=>v.currentTime),6,'Vertical touch scrolling must not seek');
+  const touch=await context.newCDPSession(page);
+  const swipe=async(points)=>{await touch.send('Input.dispatchTouchEvent',{type:'touchStart',touchPoints:[{x:points[0][0],y:points[0][1]}]});for(const[x,y]of points.slice(1))await touch.send('Input.dispatchTouchEvent',{type:'touchMove',touchPoints:[{x,y}]});await touch.send('Input.dispatchTouchEvent',{type:'touchEnd',touchPoints:[]});};
+  await swipe([[bounds.x+80,bounds.y+22],[bounds.x+100,bounds.y+22],[bounds.x+270,bounds.y+22]]);
+  await page.waitForFunction(()=>document.querySelector('video').currentTime>7);
+  assert.equal(await page.locator('video').evaluate(v=>v.paused),true,'Real touch seeking preserves pause');
+  await seek.fill('6');await seek.dispatchEvent('input');await touch.detach();
+  await page.mouse.move(bounds.x+bounds.width*.5,bounds.y+22);await page.mouse.down();await page.mouse.move(bounds.x+bounds.width*.75,bounds.y+22,{steps:10});await page.mouse.up();await page.waitForFunction(()=>document.querySelector('video').currentTime>8);assert.equal(await page.locator('video').evaluate(v=>v.paused),true);
+  await seek.fill('6');await seek.dispatchEvent('input');await seek.focus();await seek.press('ArrowRight');await page.waitForFunction(()=>document.querySelector('video').currentTime>6);await page.getByRole('button',{name:'Continue: Demo'}).click();
+  await page.locator('video').evaluate(v=>v.currentTime=11.8);await page.waitForFunction(()=>document.querySelector('video').ended);await page.evaluate(()=>scrollTo(0,0));await page.waitForTimeout(100);await page.locator('[data-project-demo]').scrollIntoViewIfNeeded();assert.equal(await page.locator('video').evaluate(v=>v.currentTime),12);await page.getByRole('button',{name:'Replay: Demo'}).click();await page.waitForFunction(()=>document.querySelector('video').currentTime>.1&&document.querySelector('video').currentTime<1);
+  assert.deepEqual(errors,[]);await context.close();
+ }finally{await browser.close();}
+});

package/tests/publication-time.test.mjs

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {spawnSync} from 'node:child_process';
+import {mkdtemp,mkdir,writeFile,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {parsePublicationDate,publicationTimestamp,validateTimeZone} from '../src/publication-time.js';
+import {readDocuments} from '../src/content.js';
+
+test('publication timezone defaults to Taipei and calendar dates remain dates',()=>{
+  assert.equal(parsePublicationDate('2026-10-03').toISOString(),'2026-10-03T00:00:00.000Z');
+  assert.equal(parsePublicationDate('2026-10-03T09:15').toISOString(),'2026-10-03T01:15:00.000Z');
+  assert.equal(parsePublicationDate('2026-10-03 09:15:30.123').toISOString(),'2026-10-03T01:15:30.123Z');
+  assert.equal(parsePublicationDate('2026-10-03T09:15:00+02:00').toISOString(),'2026-10-03T07:15:00.000Z');
+  assert.equal(publicationTimestamp(new Date('2026-10-02T20:00:00Z')),'2026-10-03T04:00:00+08:00');
+  assert.equal(parsePublicationDate('2026-10-03T09:15','America/Los_Angeles').toISOString(),'2026-10-03T16:15:00.000Z');
+  for(const value of ['2026-02-30','2026-10-03T24:00','2026-10-03T08:70'])assert.throws(()=>parsePublicationDate(value));
+  assert.throws(()=>validateTimeZone('not/a-zone'),/time zone/);
+  assert.throws(()=>parsePublicationDate('2026-03-08T02:30','America/New_York'),/nonexistent/);
+  assert.throws(()=>parsePublicationDate('2026-11-01T01:30','America/New_York'),/Ambiguous/);
+});
+
+test('build host timezone cannot affect publication parsing or writing timestamps',()=>{
+  const module=new URL('../src/publication-time.js',import.meta.url).href;
+  const script=`import {parsePublicationDate,publicationTimestamp} from ${JSON.stringify(module)}; console.log(parsePublicationDate('2026-10-03T09:15').toISOString(), publicationTimestamp(new Date('2026-10-02T20:00:00Z')));`;
+  const outputs=['UTC','America/Los_Angeles','Asia/Tokyo'].map(TZ=>{
+    const result=spawnSync(process.execPath,['--input-type=module','-e',script],{encoding:'utf8',env:{...process.env,TZ}});
+    assert.equal(result.status,0,result.stderr);return result.stdout;
+  });
+  assert.equal(new Set(outputs).size,1);
+});
+
+test('month boundary permalink follows written publication date, not UTC conversion',async()=>{
+  const folder=await mkdtemp(join(tmpdir(),'edgepress-date-'));
+  try{
+    await mkdir(join(folder,'posts/article'),{recursive:true});
+    await writeFile(join(folder,'posts/article/en.md'),'---\ntitle: Article\ndate: 2026-10-01T01:00\nlang: en\n---\nText');
+    const config={site:{timeZone:'Asia/Taipei'},resolvedPaths:{content:folder},i18n:{defaultLocale:'en',locales:['en']},concurrency:1,permalink:'/:year/:month/:day/:slug/'};
+    const [post]=await readDocuments(config);assert.equal(post.date.toISOString(),'2026-09-30T17:00:00.000Z');assert.equal(post.path,'2026/10/01/article/');assert.equal(post.dateOnly,false);
+    await writeFile(join(folder,'posts/article/en.md'),'---\ntitle: Article\ndate: 2026-10-01\nlang: en\n---\nText');
+    const [dateOnly]=await readDocuments(config);assert.equal(dateOnly.dateOnly,true);assert.equal(dateOnly.path,post.path);
+  }finally{await rm(folder,{recursive:true,force:true});}
+});

package/tests/release-version.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { nextReleaseVersion } from '../tools/release/next-version.mjs';
+
+const october = new Date('2026-10-23T23:30:00Z');
+test('the third number counts releases within the same UTC month, not calendar day', () => {
+  assert.equal(nextReleaseVersion({ currentVersion: '2026.10.12', now: october }), '2026.10.13');
+});
+test('a new UTC month resets the update count to one', () => {
+  assert.equal(nextReleaseVersion({ currentVersion: '2026.10.12', now: new Date('2026-11-01T00:00:00Z') }), '2026.11.1');
+});
+test('npm versions and repository tags prevent reuse of an existing release number', () => {
+  assert.equal(nextReleaseVersion({
+    currentVersion: '2026.10.12', tags: ['v2026.10.15', 'v2026.9.8'],
+    publishedVersions: ['2026.10.14', '2026.10.16'], now: october
+  }), '2026.10.17');
+});
+test('older months do not change the count for the current month', () => {
+  assert.equal(nextReleaseVersion({
+    currentVersion: '2026.9.8', tags: ['v2026.9.9'], publishedVersions: ['2026.9.10'], now: october
+  }), '2026.10.1');
+});
+test('reject unsupported manifests and future-month versions', () => {
+  assert.throws(() => nextReleaseVersion({ currentVersion: '2026.10.0', now: october }), /YYYY/);
+  assert.throws(() => nextReleaseVersion({
+    currentVersion: '2026.10.12', publishedVersions: ['2026.11.1'], now: october
+  }), /future-month/);
+});

package/tests/revisions.test.mjs

@@ -0,0 +1,93 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import {mkdtemp,writeFile,readFile,rm,realpath,mkdir,cp} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join,relative,isAbsolute} from 'node:path';
+import {chromium} from 'playwright';
+import {readPostRevision} from '../src/revisions.js';
+import {changedPassages,renderRevisionCards} from '../src/revision-cards.js';
+import {revisionImageFile} from '../src/revision-images.js';
+import {collectImageDimensions} from '../src/image-dimensions.js';
+import {writeAssets} from '../src/assets.js';
+import {buildSite} from '../src/build.js';
+const exec=promisify(execFile);
+const source=(body,extra='')=>`---\ntitle: Article\n${extra}---\n${body}\n`;
+test('builder restores actual old/new images, detects same-path pixel changes, and fingerprints only recent snapshots',async t=>{
+ const folder=await mkdtemp(join(tmpdir(),'edgepress-image-history-')),assetsRoot=join(folder,'content/assets'),postRoot=join(folder,'content/posts/2000-01-01-scene'),file=join(postRoot,'en.md');
+ t.after(async()=>{const parent=await realpath(tmpdir()),target=await realpath(folder),path=relative(parent,target);assert.ok(!isAbsolute(path)&&!path.startsWith('..'));await rm(target,{recursive:true,force:true});});
+ await mkdir(assetsRoot,{recursive:true});await mkdir(postRoot,{recursive:true});const git=args=>exec('git',args,{cwd:folder});await git(['init','-q']);await git(['config','user.name','Test']);await git(['config','user.email','test@example.invalid']);
+ const svg=color=>Buffer.from('<svg xmlns="http://www.w3.org/2000/svg" width="120" height="80"><rect width="120" height="80" fill="'+color+'"/></svg>');
+ const commit=async()=>{await git(['add','.']);await git(['commit','-qm','update']);};
+ const old=svg('red'),now=svg('blue');await writeFile(join(assetsRoot,'old.svg'),old);await writeFile(file,source('Previous wording.\n\n![Scene](/old.svg)'));await commit();
+ await rm(join(assetsRoot,'old.svg'));await writeFile(join(assetsRoot,'new.svg'),now);await writeFile(file,source('Clearer wording.\n\n![Scene](/new.svg)'));await commit();
+ let current=await readFile(file,'utf8'),revision=await readPostRevision(file,current,true,assetsRoot);assert.equal(revision.revisionAssets.length,2);assert.ok(revision.revisionAssets.some(asset=>asset.content.equals(old)));assert.ok(revision.revisionAssets.some(asset=>asset.content.equals(now)));
+ const labels={postChanges:'Recent changes',postChangeBefore:'Previously',postChangeAfter:'Now',postChangeAdded:'Added',postChangeRemoved:'Removed'},html=await renderRevisionCards(revision.changes,key=>labels[key],revision.revisionImages);assert.match(html,/Previous wording/);assert.match(html,/Clearer wording/);assert.equal((html.match(/<img /g)||[]).length,2);assert.doesNotMatch(html,/src="\/(?:old|new)\.svg"/);assert.match(html,/loading="lazy"/);
+ const output=join(folder,'output');await writeAssets({assets:revision.revisionAssets,existingHeaders:''},output);for(const asset of revision.revisionAssets)assert.deepEqual(await readFile(join(output,asset.path)),asset.content);assert.match(await readFile(join(output,'_headers'),'utf8'),/max-age=31536000, immutable/);const dimensions=await collectImageDimensions(revision.revisionAssets);assert.equal(dimensions.size,2);
+ await mkdir(join(folder,'languages/base'),{recursive:true});await writeFile(join(folder,'languages/base/en.json'),'{}');await writeFile(join(folder,'config.yml'),'site:\n  title: Revision fixture\n  url: https://revision.example\n  language: en\nplugins:\n  consent:\n    enabled: false\n    proposedDate: 2026-10-06\n    expiresDays: 180\n');await cp(new URL('../themes/default',import.meta.url),join(folder,'themes/default'),{recursive:true});
+ await buildSite(folder);const published=await readFile(join(folder,'dist/2000/01/scene/index.html'),'utf8');assert.match(published,/Most recent changes/);assert.match(published,/<img[^>]*src="\/edgepress\/revisions\/image\.[a-f0-9]{16}\.svg"[^>]*width="120"[^>]*height="80"/);for(const asset of revision.revisionAssets)assert.deepEqual(await readFile(join(folder,'dist',asset.path)),asset.content);
+ await writeFile(join(assetsRoot,'new.svg'),svg('green'));await commit();revision=await readPostRevision(file,current,true,assetsRoot);assert.equal(revision.revisionAssets.length,2);assert.equal(revision.revisionImages.before['/new.svg']===revision.revisionImages.after['/new.svg'],false);assert.doesNotMatch(revision.changes,/Previous wording/);
+ await writeFile(file,source('Clearer wording.','image: /new.svg\n'));await commit();await writeFile(file,source('Clearer wording.','image: /old.svg\n'));await commit();revision=await readPostRevision(file,await readFile(file,'utf8'),true,assetsRoot);assert.match(revision.changes,/-!\[Cover\]\(\/new.svg\)/);assert.match(revision.changes,/\+!\[Cover\]\(\/old.svg\)/);assert.equal(revision.revisionAssets.length,1,'Missing bytes retain description without a broken request');
+ for(const href of ['https://outside.invalid/photo.png','//outside.invalid/a.png','/../en.md','/%2e%2e/secret.png','/a\\b.png'])assert.equal(revisionImageFile(href,assetsRoot),null);
+});
+test('article updates show safe readable before/after passages rather than Git patch data',async()=>{
+ const patch='@@ -1,3 +1,3 @@\n unchanged\n-Previous **explanation**\n+Updated **explanation** <script>bad()</script>\n unchanged\n@@ -9 +9,2 @@\n+An added [link](javascript:alert(1))\n';
+ assert.equal(changedPassages(patch).length,2);
+ const labels={postChanges:'Recent changes',postChangeBefore:'Previously',postChangeAfter:'Now',postChangeAdded:'Added',postChangeRemoved:'Removed'};
+ const html=await renderRevisionCards(patch,key=>labels[key]);
+ assert.match(html,/Previously/);assert.match(html,/Now/);assert.match(html,/<strong>explanation<\/strong>/);assert.match(html,/Added/);
+ assert.doesNotMatch(html,/@@|diff --git|unchanged|<script|javascript:|bad\(\)/);
+ assert.equal(await renderRevisionCards('@@ -1 +1 @@\n unchanged',key=>labels[key]),'');
+ assert.doesNotMatch(await renderRevisionCards('-# Old heading\n+# New heading',key=>labels[key]),/<h[1-6][ >]/);
+ const pictures=await renderRevisionCards('-![Old cover](/removed.svg)\n+![New cover](/new.webp)',key=>labels[key]);assert.match(pictures,/Old cover/);assert.match(pictures,/New cover/);assert.doesNotMatch(pictures,/<img|removed.svg|new.webp/);
+});
+test('revision cards wrap on narrow screens, follow each theme and support keyboard disclosure',async()=>{
+ const browser=await chromium.launch({headless:true,...(process.platform==='win32'?{channel:'msedge'}:{})});
+ const labels={postChanges:'What changed',postChangeBefore:'Previously',postChangeAfter:'Now',postChangeAdded:'Added',postChangeRemoved:'Removed'};
+ const html=await renderRevisionCards('-Images open directly in the page.\n+Click a picture to open the **full-size viewer**. Close it to return to your reading position.\n unchanged\n+The player adapts to your website colors.',key=>labels[key]);
+ try{for(const theme of ['default','folio','signal','atelier'])for(const width of [320,1000])for(const mode of ['light','dark']){
+  const context=await browser.newContext({viewport:{width,height:700},colorScheme:mode}),page=await context.newPage();
+  const css=await readFile(new URL('../themes/'+theme+'/assets/style.css',import.meta.url),'utf8');
+  await page.setContent('<!doctype html><html lang="en" data-theme="'+mode+'"><head><title>Article update preview</title><style>'+css+'</style></head><body><main><article class="post"><header><h1>Small improvements, explained.</h1></header>'+html+'</article></main></body></html>');
+  await page.locator('summary').focus();await page.keyboard.press('Enter');assert.equal(await page.locator('details').getAttribute('open'),'');
+  assert.ok(await page.evaluate(()=>document.documentElement.scrollWidth<=innerWidth+1),theme+' '+mode+' '+width);
+  await page.evaluate(()=>document.documentElement.style.setProperty('--accent','#7242b4'));const color=await page.locator('.post-change-after').first().evaluate(node=>getComputedStyle(node).borderInlineStartColor);assert.equal(color,'rgb(114, 66, 180)');
+  if(process.env.EDGEPRESS_CAPTURE && theme==='default' && width===1000 && mode==='light'){await mkdir('content/assets/images/previews',{recursive:true});await page.locator('main').screenshot({path:'content/assets/images/previews/edgepress-revisions-en.png'});}
+  await context.close();
+ }}finally{await browser.close();}
+});
+test('actual content history excludes metadata and hides the diff by default',async t=>{
+ const prefix=join(tmpdir(),'edgepress-history-');const folder=await mkdtemp(prefix);
+ t.after(async()=>{const parent=await realpath(tmpdir()), target=await realpath(folder), path=relative(parent,target);assert.ok(!isAbsolute(path)&&!path.startsWith('..')&&target.startsWith(prefix));await rm(target,{recursive:true,force:true});});
+ const git=args=>exec('git',args,{cwd:folder});const file=join(folder,'en.md');
+ await git(['init','-q']);await git(['config','user.name','Test']);await git(['config','user.email','test@example.invalid']);
+ const commit=async text=>{await writeFile(file,text);await git(['add','en.md']);await git(['commit','-qm','update']);};
+ await commit(source('Original content'));assert.deepEqual(await readPostRevision(file,source('Original content'),true),{updated:null,changes:''});
+ await commit(source('Changed content <script>danger</script>'));
+ await commit(source('Changed content <script>danger</script>','pinned: true\n'));
+ const current=await readFile(file,'utf8');const hidden=await readPostRevision(file,current);
+ assert.ok(hidden.updated instanceof Date);assert.equal(hidden.changes,'');
+ const visible=await readPostRevision(file,current,true);
+ assert.equal(visible.updated.toISOString(),hidden.updated.toISOString());
+ assert.match(visible.changes,/-Original content/);assert.match(visible.changes,/\+Changed content/);assert.doesNotMatch(visible.changes,/pinned:|diff --git|before\.md|after\.md/);
+ await writeFile(file,source('Working content'));
+ assert.match((await readPostRevision(file,source('Working content'),true)).changes,/\+Working content/);
+ assert.deepEqual(await readPostRevision(join(folder,'untracked.md'),source('Never published'),true),{updated:null,changes:''});
+});
+test('reader timezone changes timestamps while preserving date-only publication dates',async()=>{
+ const script=await readFile(new URL('../static/edgepress/local-time.js',import.meta.url),'utf8');
+ const browser=await chromium.launch({headless:true,...(process.platform==='win32'?{channel:'msedge'}:{})});
+ try{
+  const values=[];
+  for(const timeZone of ['Asia/Tokyo','America/Los_Angeles']) {
+   const context=await browser.newContext({timezoneId:timeZone});const page=await context.newPage();
+   await page.setContent('<time data-local-time data-time-locale="en" datetime="2026-10-03T00:30:00Z"></time><time data-local-time data-time-locale="en" data-date-only="true" datetime="2026-10-03T00:00:00Z"></time>');
+   await page.addScriptTag({content:script});values.push(await page.locator('time').allTextContents());
+   assert.equal(await page.locator('time').last().getAttribute('title'),'2026-10-03');
+   await context.close();
+  }
+  assert.match(values[0][0],/October 3/);assert.match(values[1][0],/October 2/);
+  assert.equal(values[0][1],values[1][1]);assert.match(values[0][1],/October 3/);
+ }finally{await browser.close();}
+});

package/tests/rss.test.mjs

@@ -0,0 +1,54 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { generateRssRoute, absoluteContentUrls } from '../src/rss.js';
+
+const config = {
+  site: { url: 'https://example.test', title: 'A & B', description: 'News <analysis>', author: { name: 'Editor' } },
+  i18n: { defaultLocale: 'en', locales: ['en', 'zh-CN'] },
+  markdown: { gfm: true, breaks: false }
+};
+
+function post(overrides = {}) {
+  return {
+    title: 'Title & <tag>', author: 'Writer', locale: 'en', path: '2026/10/scene/',
+    date: new Date('2026-10-15T09:00:00Z'), updated: new Date('2026-10-17T10:00:00Z'),
+    category: 'science', tags: ['AI', 'science'],
+    description: 'Summary & details',
+    markdown: '## Introduction\n\nLong **article** text with [local link](/notes/?a=1&b=2), a ![figure](/images/scene.webp) and <script>unsafe()</script>.\n\nA second paragraph.',
+    ...overrides
+  };
+}
+
+test('RSS 2.0 gives AI readers a stable canonical item, full safe HTML, and correct update metadata', async () => {
+  const route = await generateRssRoute([post()], config, 'en');
+  assert.equal(route.path, 'rss.xml');
+  assert.equal(route.contentType, 'application/rss+xml; charset=utf-8');
+  assert.match(route.body, /<rss version="2\.0" /);
+  assert.match(route.body, /<atom:link href="https:\/\/example\.test\/rss\.xml" rel="self" type="application\/rss\+xml"\/>/);
+  assert.match(route.body, /<title>Title &amp; &lt;tag&gt;<\/title>/);
+  assert.match(route.body, /<guid isPermaLink="true">https:\/\/example\.test\/2026\/10\/scene\/<\/guid>/);
+  assert.match(route.body, /<dc:creator>Writer<\/dc:creator>/);
+  assert.match(route.body, /<dc:date>2026-10-17T10:00:00\.000Z<\/dc:date>/);
+  assert.match(route.body, /<pubDate>Thu, 15 Oct 2026 09:00:00 GMT<\/pubDate>/);
+  assert.match(route.body, /<lastBuildDate>Sat, 17 Oct 2026 10:00:00 GMT<\/lastBuildDate>/);
+  assert.match(route.body, /<content:encoded>[\s\S]*Introduction[\s\S]*second paragraph[\s\S]*<\/content:encoded>/i);
+  assert.match(route.body, /https:\/\/example\.test\/images\/scene\.webp/);
+  assert.match(route.body, /https:\/\/example\.test\/notes\/\?a=1&amp;amp;b=2/);
+  assert.doesNotMatch(route.body, /unsafe\(\)|<script|<iframe/);
+  assert.equal((route.body.match(/<category>/g) || []).length, 2);
+});
+
+test('RSS locale paths, item limit, empty feeds and special characters', async () => {
+  const localized = await generateRssRoute([post({ title: '中文 & 新闻', locale: 'zh-CN', path: 'zh-CN/中文/' })], config, 'zh-CN');
+  assert.equal(localized.path, 'zh-CN/rss.xml');
+  assert.match(localized.body, /<language>zh-CN<\/language>/);
+  assert.match(localized.body, /<dc:language>zh-CN<\/dc:language>/);
+  assert.match(localized.body, /%E4%B8%AD%E6%96%87/);
+  assert.match(localized.body, /中文 &amp; 新闻/);
+  const empty = await generateRssRoute([], config, 'en');
+  assert.doesNotMatch(empty.body, /<item>/);
+  const limited = await generateRssRoute(Array.from({ length: 22 }, (_, i) => post({ title: String(i) })), config, 'en');
+  assert.equal((limited.body.match(/<item>/g) || []).length, 20);
+  assert.match(absoluteContentUrls('<a href="../x?a=1&amp;b=2">X</a>', 'https://example.test/section/article/'),
+    /href="https:\/\/example\.test\/section\/x\?a=1&amp;b=2"/);
+});

package/tests/services.test.mjs

@@ -0,0 +1,35 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {callService} from '../static/edgepress/services.js';
+import {choiceSnapshot} from '../static/edgepress/plugins/consent/choices.js';
+import {extendConsentPolicy} from '../src/consent-csp.js';
+import {deploymentCommand} from '../src/deploy.js';
+
+test('optional API calls use a fixed endpoint and header actions after current service consent',async()=>{
+  const names=['document','localStorage','sessionStorage','fetch'];
+  const original=Object.fromEntries(names.map(name=>[name,Object.getOwnPropertyDescriptor(globalThis,name)]));
+  const privacy={controller:{name:'Publisher',contact:'publisher@example.com'},policyUrl:'/privacy/',consent:{proposedDate:'2026-10-03',expiresDays:180},integrations:[{id:'lookup',provider:'external-api',backendUrl:'https://service.example/backend/cloudflare/'}]};
+  const config={privacy,choiceFingerprint:choiceSnapshot(privacy)};
+  let saved=null,calls=0;
+  try {
+    globalThis.document={getElementById:()=>({textContent:JSON.stringify(config)}),cookie:''};
+    globalThis.localStorage=globalThis.sessionStorage={getItem:()=>saved};
+    globalThis.fetch=async(address,options)=>{calls++;assert.equal(address.href,'https://service.example/backend/cloudflare/');assert.equal(options.credentials,'omit');assert.equal(options.headers.get('X-Service-Action'),'resolve');assert.equal(options.headers.get('X-Service-Context'),'example.com');return Response.json({ok:true});};
+    await assert.rejects(callService('lookup','resolve',{headers:{'X-Service-Context':'example.com'}}),/consent/);assert.equal(calls,0);
+    saved=JSON.stringify({proposedDate:'2026-10-03',effectiveDate:'',fingerprint:config.choiceFingerprint,expiresAt:Date.now()+60000,allowed:['lookup']});
+    await callService('lookup','resolve',{headers:{'X-Service-Context':'example.com'}});assert.equal(calls,1);
+    for(const path of ['https://attacker.example','//attacker.example','../private','%2e%2e/private','\\private'])await assert.rejects(callService('lookup',path));
+    config.privacy.integrations[0].backendUrl='https://changed.example/';config.choiceFingerprint=choiceSnapshot(config.privacy);
+    await assert.rejects(callService('lookup','resolve'),/consent/);assert.equal(calls,1);
+  }finally{for(const [name,descriptor] of Object.entries(original)){if(descriptor)Object.defineProperty(globalThis,name,descriptor);else delete globalThis[name];}}
+});
+
+test('CSP permits only enabled configured service origins and deployment selects native static CLIs',()=>{
+  assert.deepEqual(deploymentCommand('netlify','dist'),['netlify-cli','deploy','--prod','--dir','dist']);
+  const header="/*\n  Content-Security-Policy: default-src 'self'; script-src 'self'; connect-src 'none'";
+  const services=[{enabled:false,provider:'external-widget',moduleUrl:'https://comments.example/widget.js',backendUrl:'https://comments.example'}];
+  assert.equal(extendConsentPolicy(header,{browserPlugins:{services}}),header);
+  services[0].enabled=true;const policy=extendConsentPolicy(header,{browserPlugins:{services}});
+  assert.match(policy,/script-src 'self' https:\/\/comments.example/);assert.match(policy,/frame-src 'self' https:\/\/comments.example/);assert.doesNotMatch(policy,/connect-src 'none'/);
+  assert.deepEqual(deploymentCommand('vercel'),['vercel','deploy','--prod']);assert.deepEqual(deploymentCommand('edgeone','dist',['-n','site']),['edgeone','pages','deploy','dist','-n','site']);assert.throws(()=>deploymentCommand('invalid'),/Platform/);
+});

package/tests/theme-layout.test.mjs

@@ -0,0 +1,95 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { chromium } from 'playwright';
+import { loadConfig } from '../src/config.js';
+import { loadLanguagePacks } from '../src/i18n.js';
+import { createExtensions } from '../src/plugin-api.js';
+import { renderBlocks } from '../src/page-blocks.js';
+import { renderLayout } from '../src/theme.js';
+
+const root = fileURLToPath(new URL('../', import.meta.url));
+const portrait = '<svg xmlns="http://www.w3.org/2000/svg" width="300" height="900"><rect width="300" height="900" fill="#7d9688"/></svg>';
+const landscape = '<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="675"><rect width="1200" height="675" fill="#b6b09a"/></svg>';
+
+test('theme layouts keep navigation, portrait media, columns and floating controls readable', async () => {
+  const browser = await chromium.launch({ headless: true });
+  try {
+    for (const theme of ['default', 'atelier', 'signal', 'folio']) {
+      const config = await loadConfig(root);
+      await loadLanguagePacks(config);
+      config.resolvedPaths.theme = config.realPaths.theme = resolve(root, 'themes', theme);
+      config.site.title = config.site.header.brandLabel = 'Signal';
+      config.site.navigation = ['home', 'archives', 'search'].map(key => ({ key, url: '@' + key }));
+      config.site.navigation.push({ key: 'about', url: '/about/', labels: { en: 'About', 'zh-CN': '关于' } });
+      const extensions = await createExtensions(config);
+      const blocks = [
+        { columns: 1, cells: [[{ type: 'hero', title: 'A readable magazine spread', text: 'A whole paragraph introducing the current issue.',
+          bannerSrc: '/landscape.svg', bannerAlt: 'Landscape fixture', bannerWidth: 1200, bannerHeight: 675,
+          bannerWebpSrcset: undefined }]] },
+        { columns: 2, cells: [[{ type: 'image', src: '/portrait.svg', alt: 'Complete portrait fixture', caption: 'A complete caption below the image.' }],
+          [{ type: 'code', title: 'Local command', code: 'npm run build' }]] },
+        { columns: 1, cells: [[{ type: 'media-text', mediaType: 'image', src: '/portrait.svg', alt: 'Another complete portrait',
+          caption: 'No crop and no horizontal overflow.', placement: 'right', title: 'Media with text', text: 'A complete argument stays alongside the illustration.' }]] }
+      ];
+      const content = await renderBlocks(blocks, { config, locale: 'en', site: { posts: [], pages: [] }, isHomepage: true });
+      const controls = '<div class="post-toc-widget"><button class="post-toc-toggle">Contents</button><div class="post-toc-panel" hidden><ol><li><a href="#main">Section</a></li></ol></div></div>' +
+        '<form class="local-search-form"><div class="local-search-controls"><input type="search" aria-label="Search"><button>Search</button></div></form>';
+      const html = await renderLayout(config, extensions, { title: 'Fixture', locale: 'en', urlPath: '/' }, '<article class="page-builder">' + content + controls + '</article>');
+      const context = await browser.newContext();
+      await context.route('**/*', async route => {
+        const path = new URL(route.request().url()).pathname;
+        if (path === '/') return route.fulfill({ contentType: 'text/html', body: html });
+        if (path === '/style.css') return route.fulfill({ contentType: 'text/css', body: await readFile(resolve(root, 'themes', theme, 'assets/style.css')) });
+        if (path === '/portrait.svg' || path === '/landscape.svg') return route.fulfill({ contentType: 'image/svg+xml', body: path === '/portrait.svg' ? portrait : landscape });
+        if (path.startsWith('/folio/')) return route.fulfill({ contentType: 'text/javascript', body: await readFile(resolve(root, 'themes', theme, 'assets', '.' + path)) });
+        try { return route.fulfill({ body: await readFile(resolve(root, 'static', '.' + path)), contentType: path.endsWith('.js') ? 'text/javascript' : path.endsWith('.svg') ? 'image/svg+xml' : 'image/png' }); }
+        catch { return route.fulfill({ status: 404, body: '' }); }
+      });
+      const page = await context.newPage();
+      for (const colorScheme of ['light', 'dark']) for (const width of [320, 390, 768, 1440]) {
+        await page.setViewportSize({ width, height: 900 });
+        await page.emulateMedia({ colorScheme });
+        await page.goto('https://layout.invalid/');
+        await page.locator('.privacy-settings-button').waitFor();
+        const label = `${theme} ${width} ${colorScheme}`;
+        assert.equal(await page.locator('main h1').count(), 1, label);
+        if (theme === 'folio') assert(await page.locator('.brand-description').evaluate(p => { const style=getComputedStyle(p); return style.display !== 'none' && style.whiteSpace !== 'nowrap' && p.scrollWidth <= p.clientWidth + 1 && p.scrollHeight <= p.clientHeight + 1; }), label + ': clipped masthead description');
+        assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1), label + ': overflow');
+        const brand = await page.locator('.brand').boundingBox();
+        const locale = await page.locator('.locale-nav').boundingBox();
+        const nav = await page.locator('.primary-navigation').boundingBox();
+        const overlaps = (a,b) => a.x < b.x+b.width-1 && a.x+a.width > b.x+1 && a.y < b.y+b.height-1 && a.y+a.height > b.y+1;
+        assert(!overlaps(brand,locale) && !overlaps(brand,nav) && !overlaps(locale,nav), label + ': header overlap');
+        for (const image of await page.locator('.image-block img,.media-text-block img,.hero-banner').all()) {
+          await image.scrollIntoViewIfNeeded();
+          await image.evaluate(img => img.decode());
+          const ratio = await image.evaluate(img => { const box = img.getBoundingClientRect(); return box.width / box.height / (img.naturalWidth / img.naturalHeight); });
+          assert(Math.abs(ratio-1) < .01, label + ': image cropped or distorted (' + ratio + ')');
+        }
+        const figure = await page.locator('.image-block').boundingBox();
+        const cell = await page.locator('.image-block').locator('..').boundingBox();
+        assert(Math.abs(figure.x-cell.x) < 1 && Math.abs(figure.width-cell.width) < 1, label + ': figure inset');
+        const copy = await page.locator('.code-widget').boundingBox();
+        const copyCell = await page.locator('.code-widget').locator('..').boundingBox();
+        assert(Math.abs(copy.x-copyCell.x) < 1, label + ': code inset');
+        assert(!overlaps(await page.locator('.post-toc-toggle').boundingBox(), await page.locator('.privacy-settings-button').boundingBox()), label + ': controls overlap');
+        assert.equal(await page.locator('.post-toc-panel ol').evaluate(list => getComputedStyle(list).listStyleType), 'none', label + ': numbered TOC');
+        assert(await page.locator('input[type="search"]').evaluate(input => {
+          const style = getComputedStyle(input);
+          const luminance = value => { const rgb = value.match(/[\d.]+/g).slice(0,3).map(Number).map(x=>{x/=255;return x<=.04045?x/12.92:((x+.055)/1.055)**2.4;}); return rgb[0]*.2126+rgb[1]*.7152+rgb[2]*.0722; };
+          const a=luminance(style.color),b=luminance(style.backgroundColor);
+          return (Math.max(a,b)+.05)/(Math.min(a,b)+.05)>=4.5;
+        }), label + ': unreadable input');
+        if (theme === 'folio' && width === 1440) {
+          const title = await page.locator('.hero-main').boundingBox();
+          const image = await page.locator('.hero-banner').boundingBox();
+          assert(image.x >= title.x + title.width, label + ': spread does not have two columns');
+        }
+      }
+      await context.close();
+    }
+  } finally { await browser.close(); }
+});

package/tests/video-metadata.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {collectVideoMetadata, reserveVideoMetadata} from '../src/video-metadata.js';
+import {dataSaverHtml, configureDataSaver} from '../src/data-saver.js';
+import {loadConfig} from '../src/config.js';
+
+test('local video sidecars reserve measured previews without downloading media and survive text-view gating', async () => {
+  const assets = [
+    {path:'media/clip.mp4'}, {path:'media/clip.mp4.poster.jpg'},
+    {path:'media/clip.mp4.json', content:Buffer.from(JSON.stringify({duration:150.001,width:960,height:540,poster:'clip.mp4.poster.jpg'}))}
+  ];
+  const metadata = await collectVideoMetadata(assets);
+  const source = '<figure><video data-edgepress-video preload="none" aria-label="Clip"><source src="/media/clip.mp4" type="video/mp4"></video><figcaption>Caption</figcaption></figure>';
+  const html = reserveVideoMetadata(source, metadata, '2026/10/report/index.html', 'https://site.example');
+  assert.match(html, /data-duration="150\.001" poster="\/media\/clip\.mp4\.poster\.jpg" width="960" height="540"/);
+  assert.equal(reserveVideoMetadata(html, metadata, 'index.html', 'https://site.example'),html);
+  assert.equal(reserveVideoMetadata(source.replace('/media/clip.mp4','https://other.example/media/clip.mp4'),metadata,'index.html','https://site.example'),source.replace('/media/clip.mp4','https://other.example/media/clip.mp4'));
+  assert.match(reserveVideoMetadata(source.replace('preload="none"','preload="none" poster="/chosen.jpg"'),metadata,'index.html','https://site.example'),/poster="\/chosen.jpg"/);
+  const config = await loadConfig(process.cwd()); config.site.dataSaver.enabled=true; await configureDataSaver(config);
+  const gated = dataSaverHtml('<html><head></head><body>'+html+'</body></html>',config,{});
+  assert.match(gated,/<template data-edgepress-data-html>.*data-duration=&quot;150\.001&quot;.*poster=&quot;\/media\/clip\.mp4\.poster\.jpg&quot;/s);
+  assert.match(gated,/<\/div><figcaption>Caption<\/figcaption>/);
+  assert.deepEqual(await collectVideoMetadata([{path:'media/clip.mp4'}]),new Map());
+  for (const change of [{duration:0},{poster:'https://external.example/image.jpg'},{poster:'missing.jpg'}]) {
+    const bad=assets.map(item=>item.path.endsWith('.json')?{...item,content:Buffer.from(JSON.stringify({duration:150,width:960,height:540,poster:'clip.mp4.poster.jpg',...change}))}:item);
+    await assert.rejects(collectVideoMetadata(bad));
+  }
+});