edgepress 2026.10.1 → 2026.10.13

package/src/assets.js

@@ -1,8 +1,16 @@
 import { createHash } from 'node:crypto';
-import { copyFile, readdir, readFile, writeFile, mkdir } from 'node:fs/promises';
+import { copyFile, readdir, readFile, writeFile, mkdir, stat } from 'node:fs/promises';
 import { dirname, extname, relative, resolve, sep } from 'node:path';
 import * as posix from 'node:path/posix';
+import {fileURLToPath} from 'node:url';
 import { mapLimit } from './concurrency.js';
+import {extendConsentPolicy,serializeConsentHeaders} from './consent-csp.js';
+import {imageViewerAssets, mediaViewerAssets} from './media-assets.js';
+import {documentViewerAssets} from '@jsw-teams/document-viewer/assets';
+import {collectImageDimensions} from './image-dimensions.js';
+import {collectVideoMetadata} from './video-metadata.js';
+import {dataSaverLayout} from './data-saver.js';
+import { build, transform } from 'esbuild';
 
 async function walk(directory) {
   let entries;
@@ -19,15 +27,15 @@ async function walk(directory) {
 
 function isCodeAsset(path) {
   const extension = extname(path).toLowerCase();
-  return extension === '.css' || extension === '.js';
+  return extension === '.css' || extension === '.js' || extension === '.mjs';
 }
 
 function referencedPaths(path, content, known) {
   if (!isCodeAsset(path)) return [];
   const text = content.toString('utf8');
-  const expression = extname(path).toLowerCase() === '.js'
-    ? /\b(?:from\s*|import\s*(?:\(\s*)?)['"]([^'"]+)['"]/g
-    : /(?:@import\s+(?:url\()?\s*|url\(\s*)['"]?([^'")\s;]+)['"]?\s*\)?/gi;
+  const expression = ['.js', '.mjs'].includes(extname(path).toLowerCase())
+    ? /\b(?:from\s*|import\s*(?:\(\s*)?|new\s+URL\s*\(\s*)['"]([^'"]+)['"]/g
+    : /(?:@import\s*(?:url\()?\s*|url\(\s*)['"]?([^'")\s;]+)['"]?\s*\)?/gi;
   const refs = [];
   for (const match of text.matchAll(expression)) {
     const specifier = match[1];
@@ -62,22 +70,22 @@ function rewriteCodeReferences(item, text, outputByOriginal) {
     return rewritten + tail;
   };
 
-  if (extension === '.js') {
-    const expression = /(\b(?:from\s*|import\s*(?:\(\s*)?))(['"])([^'"]+)\2/g;
+  if (extension === '.js' || extension === '.mjs') {
+    const expression = /(\b(?:from\s*|import\s*(?:\(\s*)?|new\s+URL\s*\(\s*))(['"])([^'"]+)\2/g;
     return text.replace(expression, (match, prefix, quote, specifier) => {
       const rewritten = rewriteSpecifier(specifier);
       return rewritten === null ? match : prefix + quote + rewritten + quote;
     });
   }
 
-  const expression = /((?:@import\s+(?:url\()?\s*|url\(\s*))(['"]?)([^)'"\s;]+)(['"]?\s*\)?)/gi;
+  const expression = /((?:@import\s*(?:url\()?\s*|url\(\s*))(['"]?)([^)'"\s;]+)(['"]?\s*\)?)/gi;
   return text.replace(expression, (match, prefix, quote, specifier, suffix) => {
     const rewritten = rewriteSpecifier(specifier);
     return rewritten === null ? match : prefix + quote + rewritten + suffix;
   });
 }
 
-export async function collectAssets(config) {
+export async function collectAssets(config, { documentViewer = false, mediaViewer = false } = {}) {
   const sources = [];
   const directories = [
     { root: config.resolvedPaths.static, name: 'static' },
@@ -91,6 +99,24 @@ export async function collectAssets(config) {
       sources.push({ source, path, sourceName: name });
     }
   }
+  // Library consumers do not need to copy framework runtime source into their
+  // repositories. Project-owned overrides keep precedence for existing sites.
+  const runtimeRoot=fileURLToPath(new URL('../static/edgepress/',import.meta.url));
+  const supplied=new Set(sources.map(item=>item.path));
+  if (documentViewer) for (const item of await documentViewerAssets('edgepress/document-viewer')) if (!supplied.has(item.path)) sources.push(item);
+  for(const item of await imageViewerAssets())if(!supplied.has(item.path))sources.push(item);
+  if (mediaViewer) for (const item of await mediaViewerAssets()) if (!supplied.has(item.path)) sources.push(item);
+  for(const source of await walk(runtimeRoot)) {
+    const path='edgepress/'+relative(runtimeRoot,source).split(sep).join('/');
+    if(!supplied.has(path))sources.push({source,path,sourceName:'EdgePress runtime'});
+  }
+  // Built-in navigation and page icons live with the package's content assets,
+  // not its browser scripts. Include only this library, not example-site media.
+  const iconsRoot=fileURLToPath(new URL('../content/assets/edgepress/icons/',import.meta.url));
+  for(const source of await walk(iconsRoot)) {
+    const path='edgepress/icons/'+relative(iconsRoot,source).split(sep).join('/');
+    if(!supplied.has(path))sources.push({source,path,sourceName:'EdgePress icons'});
+  }
 
   const headers = [];
   const assetSources = [];
@@ -100,11 +126,71 @@ export async function collectAssets(config) {
   }
   const [headerContents, items] = await Promise.all([
     mapLimit(headers, config.concurrency, async (item) => (await readFile(item.source)).toString('utf8')),
-    mapLimit(assetSources, config.concurrency, async (item) => ({
-      ...item,
-      content: isCodeAsset(item.path) ? await readFile(item.source) : null
-    }))
+    mapLimit(assetSources, config.concurrency, async (item) => {
+      if (!isCodeAsset(item.path)) return { ...item, content: null };
+      const source = item.content ?? await readFile(item.source);
+      const result = await transform(source.toString('utf8'), {
+        loader: item.path.endsWith('.css') ? 'css' : 'js',
+        minifyWhitespace: true,
+        minifySyntax: true,
+        minifyIdentifiers: item.path === 'edgepress/data-saver.js',
+        legalComments: 'inline',
+        charset: 'utf8',
+        sourcefile: item.path
+      });
+      return { ...item, content: Buffer.from(result.code) };
+    })
   ]);
+  const coreEntries = ['edgepress/plugins/consent/manager.js', 'edgepress/external-links.js'];
+  const sourceByPath = new Map(items.map(item => [item.path, item]));
+  const bundleControl = async entry => {
+    const item = sourceByPath.get(entry);
+    if (!item) return;
+    const output = await build({
+      entryPoints: [entry],
+      bundle: true,
+      write: false,
+      format: 'esm',
+      minifyWhitespace: true,
+      minifySyntax: true,
+      minifyIdentifiers: false,
+      legalComments: 'inline',
+      charset: 'utf8',
+      plugins: [{
+        name: 'local-core-controls',
+        setup(builder) {
+          builder.onResolve({filter:/.*/}, args => {
+            const target = args.kind === 'entry-point' ? args.path : args.path.startsWith('/') ? args.path.slice(1) : posix.normalize(posix.join(posix.dirname(args.importer),args.path));
+            if (args.kind === 'dynamic-import' || !sourceByPath.has(target)) {
+              const path = sourceByPath.has(target) ? '/' + target : args.path;
+              return {path,external:true};
+            }
+            return {path:target,namespace:'local-core-controls'};
+          });
+          builder.onLoad({filter:/.*/,namespace:'local-core-controls'}, args => ({contents:sourceByPath.get(args.path).content.toString('utf8'),loader:'js'}));
+        }
+      }]
+    });
+    item.content = Buffer.from(output.outputFiles[0].contents);
+  };
+  for (const entry of coreEntries) await bundleControl(entry);
+  if (config.site.dataSaver?.enabled) {
+    const candidates = [...coreEntries, 'edgepress/language-select.js', 'edgepress/local-time.js', 'edgepress/navigation-select.js', 'edgepress/services-consent.js'];
+    const scripts = candidates.filter(path => {
+      const source = sourceByPath.get(path)?.source;
+      return source && relative(runtimeRoot,source).split(sep).join('/') === path.slice('edgepress/'.length);
+    });
+    if (scripts.length) {
+      const entry = 'edgepress/data-saver-controls.js';
+      const item = {path:entry,content:Buffer.from(scripts.map(path => 'import "/' + path + '";').join('\n')),sourceName:'Data-saving core controls'};
+      sourceByPath.set(entry,item);
+      items.push(item);
+      await bundleControl(entry);
+      config.dataSaverCore = {path:'/' + entry,scripts:scripts.map(path => '/' + path)};
+    }
+  }
+  const layout = await dataSaverLayout(config, items);
+  if (layout) items.push(layout);
   const originals = new Map();
   for (const item of items) {
     const normalized = item.path.toLowerCase();
@@ -156,7 +242,7 @@ export async function collectAssets(config) {
   const urlMap = Object.create(null);
   for (const item of items) urlMap['/' + item.path] = '/' + outputByOriginal.get(item.path);
   config.assetManifest = urlMap;
-  return { assets, urlMap, existingHeaders: headerContents.join('\n\n') };
+  return { assets, urlMap, imageDimensions:await collectImageDimensions(assets), videoMetadata:await collectVideoMetadata(assets), existingHeaders: extendConsentPolicy(headerContents.join('\n\n'),config) };
 }
 
 export async function writeAssets(bundle, output, concurrency = 8) {
@@ -166,12 +252,54 @@ export async function writeAssets(bundle, output, concurrency = 8) {
     if (asset.source) await copyFile(asset.source, target);
     else await writeFile(target, asset.content);
   });
+  // Cloudflare already revalidates unversioned assets by default. A broad cache
+  // rule would be concatenated with exact immutable rules instead of overridden.
   const securityRules = '/*\n  X-Content-Type-Options: nosniff\n  Referrer-Policy: strict-origin-when-cross-origin';
+  // Unicode fonts contain hundreds of subsets. Static hosts accept 100 header
+  // rules, so group a directory only when every WOFF2 file in it is hashed.
+  const fontsByDirectory = new Map();
+  for (const asset of bundle.assets.filter(asset => asset.path.endsWith('.woff2'))) {
+    const directory = posix.dirname(asset.path);
+    if (!fontsByDirectory.has(directory)) fontsByDirectory.set(directory, []);
+    fontsByDirectory.get(directory).push(asset.path);
+  }
+  const fontDirectories = new Set([...fontsByDirectory].filter(([, paths]) =>
+    paths.length > 1 && paths.every(path => /\.[a-f0-9]{16}\.woff2$/.test(path))
+  ).map(([directory]) => directory));
   const immutableRules = bundle.assets
-    .filter((asset) => /\.[a-f0-9]{16}\.(?:css|js)$/i.test(asset.path))
-    .map((asset) => '/' + asset.path + '\n  Cache-Control: public, max-age=31556952, immutable');
-  const headers = [bundle.existingHeaders.trim(), securityRules, ...immutableRules].filter(Boolean).join('\n\n') + '\n';
-  await writeFile(resolve(output, '_headers'), headers, 'utf8');
+    .filter((asset) => /\.[a-f0-9]{16}\.(?:css|m?js|json|png|jpe?g|webp|avif|svg|gif|mp4|webm|woff2?)$/i.test(asset.path))
+    .filter(asset => !asset.path.endsWith('.woff2') || !fontDirectories.has(posix.dirname(asset.path)))
+    .map((asset) => '/' + asset.path + '\n  Cache-Control: public, max-age=31536000, immutable');
+  for (const directory of fontDirectories) immutableRules.push('/' + (directory === '.' ? '' : directory + '/') + '*.woff2\n  Cache-Control: public, max-age=31536000, immutable');
+  const documentDirectories = new Set(bundle.assets.map(asset => asset.path.match(/^(.*\/pdf-assets\.[a-f0-9]{16})\//)?.[1]).filter(Boolean));
+  for (const directory of documentDirectories) immutableRules.push('/' + directory + '/*\n  Cache-Control: public, max-age=31536000, immutable');
+  const mediaRules = await Promise.all(bundle.assets.filter(asset=>/\.(mp4|webm)$/i.test(asset.path)).map(async asset=>{
+    const {size}=await stat(resolve(output,...asset.path.split('/')));
+    return '/'+asset.path+'\n  Content-Length: '+size+'\n  Accept-Ranges: bytes';
+  }));
+  if (immutableRules.length + mediaRules.length > 85) {
+    const immutablePath = /\.[a-f0-9]{16}\.(?:css|m?js|json|png|jpe?g|webp|avif|svg|gif|mp4|webm|woff2?)$/i;
+    const patterns = new Map();
+    for (const asset of bundle.assets.filter(asset => immutablePath.test(asset.path))) {
+      const directory = posix.dirname(asset.path);
+      const prefix = directory === '.' ? '' : directory + '/';
+      const suffix = posix.extname(asset.path);
+      const matching = bundle.assets.filter(candidate => candidate.path.startsWith(prefix) && candidate.path.endsWith(suffix));
+      if (matching.length > 1 && matching.every(candidate => immutablePath.test(candidate.path))) {
+        patterns.set('/' + prefix + '*' + suffix, matching.map(candidate => '/' + candidate.path));
+      }
+    }
+    for (const [pattern, paths] of [...patterns].sort((first, second) => second[1].length - first[1].length)) {
+      const exact = immutableRules.filter(rule => paths.includes(rule.split('\n')[0]));
+      if (exact.length < 2) continue;
+      for (const rule of exact) immutableRules.splice(immutableRules.indexOf(rule), 1);
+      immutableRules.push(pattern + '\n  Cache-Control: public, max-age=31536000, immutable');
+    }
+  }
+  const headers = [bundle.existingHeaders.trim(), securityRules, ...immutableRules, ...mediaRules].filter(Boolean).join('\n\n') + '\n';
+  const count = headers.split(/\r?\n/).filter(line => line && !/^\s|^#/.test(line)).length;
+  if (count > 100) throw new Error('Static header rules exceed 100 after safe cache grouping; reduce custom rules or per-file media headers.');
+  await writeFile(resolve(output, '_headers'), serializeConsentHeaders(headers), 'utf8');
 }
 
 export function rewriteAssetLinks(html, urlMap) {

package/src/browser-audit.js

@@ -0,0 +1,158 @@
+export const deviceProfiles = [
+  { name: 'desktop', width: 1440, height: 900, deviceScaleFactor: 1, mobile: false, touch: false },
+  { name: 'phone', width: 390, height: 844, deviceScaleFactor: 3, mobile: true, touch: true },
+  { name: 'tablet', width: 820, height: 1180, deviceScaleFactor: 2, mobile: true, touch: true }
+];
+
+// CDP input targets only the isolated headless browser, never the user's desktop.
+async function key(send, name, modifiers = 0) {
+  const code = name === 'Enter' ? 13 : 9;
+  await send('Input.dispatchKeyEvent', { type: name === 'Enter' ? 'keyDown' : 'rawKeyDown',
+    key: name, code: name, windowsVirtualKeyCode: code, nativeVirtualKeyCode: code, modifiers,
+    ...(name === 'Enter' ? { text: '\r', unmodifiedText: '\r' } : {}) });
+  await send('Input.dispatchKeyEvent', { type: 'keyUp', key: name, code: name,
+    windowsVirtualKeyCode: code, nativeVirtualKeyCode: code, modifiers });
+}
+
+async function evaluate(send, fn) {
+  const result = await send('Runtime.evaluate', { expression: '(' + fn.toString() + ')()', returnByValue: true, awaitPromise: true });
+  if (result.exceptionDetails) throw new Error(result.exceptionDetails.text || 'Browser audit evaluation failed');
+  return result.result.value;
+}
+
+export async function auditBrowser(send, profile) {
+  const checks = [];
+  const check = (group, name, passed, detail = '') => checks.push({ group, name, passed: Boolean(passed), ...(detail ? { detail } : {}) });
+  const trace = [];
+  const previous = await evaluate(send, () => {
+    const manager = document.querySelector('[data-consent-ui]');
+    const display = manager?.style.display;
+    if (manager) manager.style.display = 'none';
+    const candidates = [...document.querySelectorAll('a[href],button,input,select,textarea,summary,[tabindex]')];
+    const visual = element => {
+      const style = getComputedStyle(element);
+      return [style.backgroundColor, style.borderColor, style.color, style.textDecorationLine].join('|');
+    };
+    window.__edgepressKeyboardAudit = { candidates, elements: [...document.querySelectorAll('*')], visual,
+      before: new Map(candidates.map(element => [element, visual(element)])) };
+    document.activeElement?.blur();
+    return { display: display ?? '', href: location.href };
+  });
+  try {
+    const measured = await evaluate(send, () => ({ width: innerWidth, density: devicePixelRatio, touch: navigator.maxTouchPoints,
+      overflow: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth) > innerWidth + 1,
+      mainCount: document.querySelectorAll('main,[role="main"]').length,
+      h1Count: document.querySelectorAll('h1').length,
+      heading: document.querySelector('h1')?.textContent.trim() || '',
+      language: document.documentElement.lang,
+      schemes: { dark: matchMedia('(prefers-color-scheme: dark)').matches }
+    }));
+    check('device', 'Viewport matches the emulated device', measured.width === profile.width, String(measured.width));
+    check('device', 'Pixel density matches the emulated device', Math.abs(measured.density - profile.deviceScaleFactor) < .01);
+    check('device', profile.touch ? 'Mobile touch emulation exposes five touch points' : 'Native desktop touch capability is recorded',
+      profile.touch ? measured.touch === 5 : true, String(measured.touch));
+    check('device', 'No page overflow at this device size', !measured.overflow);
+    check('device', 'System color preference is emulated', measured.schemes.dark === (profile.colorScheme === 'dark'));
+    check('structure', 'One main landmark', measured.mainCount === 1);
+    check('structure', 'One page-level h1', measured.h1Count === 1);
+    check('structure', 'Document language is declared', measured.language.trim());
+
+    const { nodes } = await send('Accessibility.getFullAXTree');
+    const exposed = nodes.filter(node => !node.ignored);
+    const role = node => node.role?.value;
+    const name = node => String(node.name?.value || '').trim();
+    check('semantics', 'Main landmark is exposed to assistive technology', exposed.filter(node => role(node) === 'main').length === 1);
+    check('semantics', 'Page heading has its accessible name and level', exposed.some(node => role(node) === 'heading' &&
+      name(node) === measured.heading && node.properties?.some(property => property.name === 'level' && property.value.value === 1)));
+    const navigation = exposed.filter(node => role(node) === 'navigation');
+    check('semantics', 'Exposed navigation landmarks have names', navigation.every(node => name(node)));
+    const namedRoles = new Set(['button', 'link', 'combobox', 'textbox', 'searchbox', 'checkbox', 'radio', 'switch', 'slider', 'spinbutton', 'image']);
+    const unnamed = exposed.filter(node => namedRoles.has(role(node)) && !name(node));
+    check('semantics', 'Exposed controls and meaningful images have names', unnamed.length === 0,
+      unnamed.length ? unnamed.map(node => role(node)).join(', ') : '');
+
+    await send('Emulation.setFocusEmulationEnabled', { enabled: true });
+    const focus = () => evaluate(send, async () => {
+      const element = document.activeElement;
+      if (!element || element === document.body || element === document.documentElement) return null;
+      // Native Tab can start a smooth scroll; observe its result without scrolling for it.
+      await new Promise(resolve=>{
+        const started=performance.now();
+        const visible=()=>{const box=element.getBoundingClientRect();if((box.bottom>0&&box.top<innerHeight&&box.right>0&&box.left<innerWidth)||performance.now()-started>1500)return resolve();requestAnimationFrame(visible);};
+        visible();
+      });
+      const { elements, before, visual } = window.__edgepressKeyboardAudit;
+      const style = getComputedStyle(element), box = element.getBoundingClientRect();
+      const transparent = value => value === 'transparent' || /rgba\([^)]*,\s*0\)$/.test(value);
+      const outline = style.outlineStyle !== 'none' && parseFloat(style.outlineWidth) > 0 && !transparent(style.outlineColor);
+      const indicator = outline || style.boxShadow !== 'none' || (before.has(element) && before.get(element) !== visual(element));
+      const hidden = element.closest('[hidden],[inert],[aria-hidden="true"]');
+      return { index: elements.indexOf(element), tag: element.tagName.toLowerCase(),
+        name: (element.getAttribute('aria-label') || element.innerText || element.labels?.[0]?.textContent || '').trim().slice(0, 160),
+        visible: !hidden && style.visibility === 'visible' && style.display !== 'none' && box.width > 0 && box.height > 0 &&
+          box.bottom > 0 && box.top < innerHeight && box.right > 0 && box.left < innerWidth,
+        indicator, skip: element.matches('a[href^="#"]') &&
+          document.getElementById(element.getAttribute('href').slice(1))?.matches('main,[role="main"]') };
+    });
+    let reverseChecked = false;
+    let unexpectedRepeat = false;
+    for (let step = 0; step < 12; step += 1) {
+      await key(send, 'Tab');
+      const current = await focus();
+      if (!current) break; // Normal wrap through browser chrome is not a focus trap.
+      if (trace.length && current.index === trace[0].index) {
+        // Mobile browser chrome may not appear as a focus stop. A natural wrap
+        // is valid only after visiting all currently tabbable page controls.
+        const expected = await evaluate(send, () => {
+          const { candidates, elements } = window.__edgepressKeyboardAudit;
+          const visible = candidates.filter(element => {
+            const style = getComputedStyle(element), box = element.getBoundingClientRect();
+            return element.tabIndex >= 0 && !element.matches(':disabled') && !element.closest('[hidden],[inert]') &&
+              style.visibility === 'visible' && box.width > 0 && box.height > 0;
+          });
+          return visible.filter(element => {
+            if (!element.matches('input[type="radio"]') || !element.name) return true;
+            const group = visible.filter(other => other.matches('input[type="radio"]') && other.name === element.name && other.form === element.form);
+            return element === (group.find(other => other.checked) || group[0]);
+          }).map(element => elements.indexOf(element));
+        });
+        const visited = new Set(trace.map(item => item.index));
+        const missing = expected.filter(index => !visited.has(index));
+        check('keyboard', 'Native page wrap does not skip tabbable controls', missing.length === 0, missing.length ? String(missing.length) + ' unvisited controls' : '');
+        break;
+      }
+      if (trace.some(item => item.index === current.index)) { unexpectedRepeat = true; break; }
+      trace.push(current);
+      check('keyboard', 'Tab step ' + (step + 1) + ' lands on visible content', current.visible, current.name);
+      check('keyboard', 'Tab step ' + (step + 1) + ' has a visible focus indicator', current.indicator, current.name);
+      if (step === 1) {
+        await key(send, 'Tab', 8); // Shift modifier, scoped to CDP.
+        const reverse = await focus();
+        check('keyboard', 'Shift+Tab returns to the previous focus target', reverse?.index === trace[0].index);
+        reverseChecked = true;
+        await key(send, 'Tab');
+      }
+    }
+    check('keyboard', 'Forward and backward keyboard navigation are available', trace.length >= 2 && reverseChecked);
+    check('keyboard', 'No unexpected focus cycle during the sampled Tab sequence', !unexpectedRepeat);
+    check('keyboard', 'First Tab reaches the skip-to-main link', trace[0]?.skip);
+    const hasSkip = await evaluate(send, () => {
+      const first = window.__edgepressKeyboardAudit.candidates.find(element => element.matches('a[href^="#"]') &&
+        document.getElementById(element.getAttribute('href').slice(1))?.matches('main,[role="main"]'));
+      first?.focus();
+      return Boolean(first && document.activeElement === first);
+    });
+    if (hasSkip) await key(send, 'Enter');
+    const skipReached = hasSkip && await evaluate(send, () => {
+      if (!location.hash) return false;
+      const target = document.getElementById(decodeURIComponent(location.hash.slice(1)));
+      return Boolean(target?.matches('main,[role="main"]') && target.getBoundingClientRect().top < innerHeight);
+    });
+    check('keyboard', 'Enter on the skip link reaches the main landmark', skipReached);
+    return { checks, trace, status: checks.every(item => item.passed) ? 'pass' : 'fail' };
+  } finally {
+    await send('Runtime.evaluate', { expression: '(() => { const manager = document.querySelector("[data-consent-ui]"); if (manager) manager.style.display = ' +
+      JSON.stringify(previous.display) + '; history.replaceState(history.state, "", ' + JSON.stringify(previous.href) +
+      '); delete window.__edgepressKeyboardAudit; })()' });
+  }
+}

package/src/build.js

@@ -5,14 +5,18 @@ import { hostname } from 'node:os';
 import { mapLimit } from './concurrency.js';
 import { loadConfig } from './config.js';
 import { readDocuments, sortPostsNewest } from './content.js';
-import { plainText } from './markdown.js';
+import { plainText, hasMarkdownVideo } from './markdown.js';
 import { createExtensions } from './plugin-api.js';
 import { collectAssets, rewriteAssetLinks, writeAssets } from './assets.js';
 import { loadLanguagePacks } from './i18n.js';
+import { contentPermissions, extendConsentPolicy, injectConsentPolicy } from './consent-csp.js';
 import { generateBuiltinRoutes } from './generators.js';
+import {reserveImageDimensions,collectImageDimensions} from './image-dimensions.js';
+import {reserveVideoMetadata} from './video-metadata.js';
+import { dataSaverHtml, configureDataSaver } from './data-saver.js';
 
 const RENDER_CACHE_VERSION = 3;
-const MARKDOWN_SECURITY_POLICY_VERSION = 4;
+const MARKDOWN_SECURITY_POLICY_VERSION = 5;
 
 async function readCache(file) {
   try {
@@ -28,8 +32,9 @@ async function readCache(file) {
 
 async function markdownRuntimeVersion(root) {
   const lockPath = resolve(root, 'package-lock.json');
-  const rendererSource = await readFile(new URL('./markdown.js', import.meta.url));
-  const implementation = createHash('sha256').update(rendererSource).digest('hex');
+  const rendererSources=await Promise.all(['markdown.js','embed.js','document.js','oembed.js','plugin-api.js','i18n.js'].map(file=>readFile(new URL('./'+file,import.meta.url))));
+  const digest=createHash('sha256');for(const source of rendererSources)digest.update(source);
+  const implementation=digest.digest('hex');
   try {
     const lock = JSON.parse(await readFile(lockPath, 'utf8'));
     const marked = lock.packages?.['node_modules/marked']?.version;
@@ -143,6 +148,16 @@ export async function acquireBuildLock(directory) {
   throw new Error('Unable to acquire the project build lock');
 }
 
+async function renameOutput(source, target) {
+  for(let attempt=0;;attempt++) {
+    try{return await rename(source,target);}
+    catch(error){
+      if(process.platform!=='win32'||!['EPERM','EBUSY'].includes(error.code)||attempt>=5)throw error;
+      await new Promise(resolve=>setTimeout(resolve,200*2**attempt));
+    }
+  }
+}
+
 async function commitOutput(stage, output) {
   const backup = output + '.backup-' + randomUUID();
   let movedPrevious = false;
@@ -152,15 +167,15 @@ async function commitOutput(stage, output) {
       if (info.isSymbolicLink() || !info.isDirectory()) {
         throw new Error('Build output must be a real directory: ' + output);
       }
-      await rename(output, backup);
+      await renameOutput(output, backup);
       movedPrevious = true;
     } catch (error) {
       if (error.code !== 'ENOENT') throw error;
     }
-    await rename(stage, output);
+    await renameOutput(stage, output);
   } catch (error) {
     if (movedPrevious) {
-      try { await rename(backup, output); }
+      try { await renameOutput(backup, output); }
       catch (restoreError) {
         throw new Error('Build commit failed and the previous output could not be restored from ' + backup + ': ' + restoreError.message, { cause: error });
       }
@@ -180,6 +195,10 @@ async function writeRoutes(routes, stage, assetBundle, extensions, site, config)
     let body = await extensions.filter('route:body', route.body, { route, site, config });
     if (typeof body !== 'string') throw new Error('route:body filters must return a string for ' + route.path);
     body = rewriteAssetLinks(body, assetBundle.urlMap);
+    body = reserveImageDimensions(body, assetBundle.imageDimensions, route.path, site.config.site.url);
+    body = reserveVideoMetadata(body, assetBundle.videoMetadata, route.path, site.config.site.url);
+    body = dataSaverHtml(body, config, assetBundle.urlMap);
+    body = injectConsentPolicy(body, assetBundle.existingHeaders);
     await writeFile(file, body, 'utf8');
   });
 }
@@ -187,6 +206,7 @@ async function writeRoutes(routes, stage, assetBundle, extensions, site, config)
 export async function buildSite(root = process.cwd(), options = {}) {
   const started = Date.now();
   const config = await loadConfig(root);
+  await configureDataSaver(config);
   if (options.preview === true) {
     config.preview = true;
     config.previewBuildId = randomUUID();
@@ -198,10 +218,10 @@ export async function buildSite(root = process.cwd(), options = {}) {
   try {
     await loadLanguagePacks(config);
     const extensions = await createExtensions(config);
-    const assetBundle = await collectAssets(config);
     const sourceDocuments = await readDocuments(config);
     const loadedDocuments = await extensions.filter('content:loaded', sourceDocuments, { config });
     if (!Array.isArray(loadedDocuments)) throw new Error('content:loaded filters must return an array');
+    const assetBundle = await collectAssets(config, { documentViewer: loadedDocuments.some(document => /!document\[|"type":"document"/.test(JSON.stringify(document))), mediaViewer: loadedDocuments.some(document => document.video || hasMarkdownVideo(document.markdown) || /"type":"media-viewer"/.test(JSON.stringify(document))) });
 
     const cacheFile = resolve(config.resolvedPaths.cache, 'render-cache.json');
     const oldCache = await readCache(cacheFile);
@@ -216,7 +236,7 @@ export async function buildSite(root = process.cwd(), options = {}) {
       }
       const signature = createHash('sha256')
         .update(document.markdown + '\n' + JSON.stringify(config.markdown) + '\n' + document.locale + '\n' +
-          MARKDOWN_SECURITY_POLICY_VERSION + '\n' + runtimeVersion)
+          MARKDOWN_SECURITY_POLICY_VERSION + '\n' + runtimeVersion + '\n' + JSON.stringify(config.browserPlugins) + '\n' + config.site.url)
         .digest('hex');
       let html = renderer.cacheable ? oldCache[signature] : undefined;
       if (html === undefined) html = await renderer.render(document.markdown, { config, document });
@@ -229,6 +249,9 @@ export async function buildSite(root = process.cwd(), options = {}) {
 
     const now = new Date();
     const visible = documents.filter((document) => !document.draft && publishedByLocalDate(document, now));
+    const revisionAssets=new Map(visible.flatMap(document=>document.revisionAssets??[]).map(asset=>[asset.path,asset]));
+    assetBundle.assets.push(...revisionAssets.values());
+    for(const [path,size] of await collectImageDimensions([...revisionAssets.values()]))assetBundle.imageDimensions.set(path,size);
     let site = {
       config,
       posts: sortPostsNewest(visible.filter((document) => document.kind === 'posts')),
@@ -251,6 +274,8 @@ export async function buildSite(root = process.cwd(), options = {}) {
     }
     routes = await extensions.filter('routes:created', routes, { site, config });
     validateRoutes(routes, output, assetBundle);
+    config.contentCsp = contentPermissions(routes);
+    assetBundle.existingHeaders = extendConsentPolicy(assetBundle.existingHeaders, config);
 
     await mkdir(dirname(output), { recursive: true });
     await mkdir(stage, { recursive: false });