snappy-prerender 2.6.0-rc.3 → 2.6.0

package/src/core/init.js

@@ -1,5 +1,7 @@
 import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { normaliseRoute } from './routes.js';
 
 export const CONFIG_FILE = 'snappy.config.js';
@@ -23,14 +25,55 @@ export async function detectProjectDefaults(dir = process.cwd()) {
   const dependencies = { ...manifest?.dependencies, ...manifest?.devDependencies };
   const usesVite = Boolean(dependencies.vite) || (await anyExists(dir, VITE_CONFIGS));
   const usesCreateReactApp = Boolean(dependencies['react-scripts']) && !usesVite;
+  const vite = usesVite ? await detectViteConfig(dir) : null;
   return {
-    sourceDir: usesCreateReactApp ? 'build' : 'dist',
+    sourceDir: vite?.sourceDir ?? (usesCreateReactApp ? 'build' : 'dist'),
+    base: vite?.base ?? homepageBase(manifest?.homepage) ?? '/',
     usesVite,
     runner: await detectRunner(dir),
     installed: PACKAGE_NAME in dependencies,
   };
 }
 
+/**
+ * Reads the project's real Vite output directory and base when Vite can be resolved
+ * from that project. Falls back to the conventional defaults when the config is
+ * missing, imports an unavailable plugin, or Vite is not installed.
+ */
+async function detectViteConfig(dir) {
+  try {
+    const require = createRequire(path.join(dir, 'package.json'));
+    const entry = require.resolve('vite');
+    const { resolveConfig } = await import(pathToFileURL(entry).href);
+    const resolved = await resolveConfig({ root: dir, logLevel: 'silent' }, 'build');
+    const relative = path.relative(dir, resolved.build.outDir);
+    return {
+      sourceDir: relative.startsWith('..') ? resolved.build.outDir : relative || '.',
+      base: detectedBase(resolved.base),
+    };
+  } catch {
+    return null;
+  }
+}
+
+// Keeps a detected base usable by normaliseBase: only root-relative bases apply here.
+function detectedBase(base) {
+  if (typeof base !== 'string' || !base.startsWith('/') || base.startsWith('//')) return '/';
+  return base.endsWith('/') ? base : `${base}/`;
+}
+
+// Reads Create React App's homepage into a base path, ignoring absolute deployments
+// and values that are not a path.
+function homepageBase(homepage) {
+  if (typeof homepage !== 'string' || homepage.length === 0) return null;
+  try {
+    const url = new URL(homepage, 'https://example.invalid');
+    return url.pathname.endsWith('/') ? url.pathname : `${url.pathname}/`;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Normalises a comma separated route list into include patterns, keeping wildcards as the
  * user wrote them and falling back to the root route so the config always renders something.

package/src/core/inline-css.js

@@ -1,9 +1,12 @@
+import { hasImportRule, rewriteCssUrls } from './css-url.js';
 import { minifyCss } from './minify.js';
 
 /**
  * Inlines every same-origin stylesheet the page loaded, replacing the links with a
  * single style tag. Blob-backed stylesheets work too because the text is read from
- * the live page. Stylesheets that cannot be fetched are left in place.
+ * the live page. Stylesheets that cannot be fetched, or that use @import, are left in
+ * place. Relative url() values are rebased against each sheet before joining so fonts
+ * and images keep working on nested routes.
  */
 export async function inlineStylesheets({ page, minifyCssOptions }) {
   const collected = await page.evaluate(async () => {
@@ -11,7 +14,7 @@ export async function inlineStylesheets({ page, minifyCssOptions }) {
     // applies, so a print stylesheet is left as a link instead of becoming active.
     const INLINEABLE_MEDIA = new Set(['', 'all', 'screen']);
     const links = Array.from(document.querySelectorAll('link[rel="stylesheet"]'));
-    const parts = [];
+    const sheets = [];
     const skipped = [];
     for (const link of links) {
       const media = (link.getAttribute('media') ?? '').trim().toLowerCase();
@@ -22,23 +25,41 @@ export async function inlineStylesheets({ page, minifyCssOptions }) {
       try {
         const response = await fetch(link.href);
         if (!response.ok) throw new Error(String(response.status));
-        parts.push(await response.text());
-        link.remove();
+        sheets.push({ css: await response.text(), href: link.href });
       } catch {
         skipped.push(link.href);
       }
     }
-    return { css: parts.join('\n'), skipped };
+    return { sheets, skipped };
   });
 
-  if (collected.css.trim().length === 0) return { skipped: collected.skipped };
-  const css = minifyCssOptions ? minifyCss(collected.css, minifyCssOptions) : collected.css;
-  await page.evaluate((text) => {
-    const style = document.createElement('style');
-    style.textContent = text;
-    document.head.appendChild(style);
-  }, css);
-  return { skipped: collected.skipped };
+  const inlineable = [];
+  const skipped = [...collected.skipped];
+  for (const sheet of collected.sheets) {
+    if (hasImportRule(sheet.css)) skipped.push(sheet.href);
+    else inlineable.push(sheet);
+  }
+  if (inlineable.length === 0) return { skipped };
+
+  const pageOrigin = new URL(page.url()).origin;
+  const joined = inlineable
+    .map((sheet) => rewriteCssUrls(sheet.css, sheet.href, pageOrigin))
+    .join('\n');
+  const css = minifyCssOptions ? minifyCss(joined, minifyCssOptions) : joined;
+  await page.evaluate(
+    ({ text, hrefs }) => {
+      const style = document.createElement('style');
+      style.setAttribute('data-snappy-inline', '');
+      style.textContent = text;
+      document.head.appendChild(style);
+      const inlined = new Set(hrefs);
+      for (const link of document.querySelectorAll('link[rel="stylesheet"]')) {
+        if (inlined.has(link.href)) link.remove();
+      }
+    },
+    { text: css, hrefs: inlineable.map((sheet) => sheet.href) },
+  );
+  return { skipped };
 }
 
 /**

package/src/core/metadata-origin.js

@@ -1,4 +1,4 @@
-const BUILD_ORIGIN = /https?:\/\/(?:127\.0\.0\.1|localhost|\[::1\])(?::\d+)?/gi;
+const BUILD_ORIGIN = /https?:\/\/(?:127\.0\.0\.1|localhost|\[::1\])(?::\d+)?(?![\w.:-])/gi;
 
 /**
  * Recognises the metadata tags whose value is an absolute URL, and finds URLs pointing at a
@@ -25,12 +25,21 @@ export function collectBuildOrigins(text, limit = 3) {
   return [...new Set(matches)].slice(0, limit);
 }
 
+/**
+ * Scans a serialized document for build-server origins. Used only when the optional
+ * `failOnBuildOriginMetadata` gate is enabled, so a caller that turns stripping off can
+ * still make loopback metadata a build failure.
+ */
+export function findBuildOriginUrls(html) {
+  return collectBuildOrigins(html);
+}
+
 // Reports whether a meta key names a URL, such as og:url, og:image or twitter:image.
 function isUrlKey(key) {
   const [prefix, ...rest] = key.toLowerCase().split(':');
   if (prefix !== 'og' && prefix !== 'twitter') return false;
   const last = rest.at(-1);
-  return last === 'url' || last === 'image';
+  return last === 'url' || last === 'image' || last === 'secure_url';
 }
 
 // Reads an attribute value, defaulting to an empty string.

package/src/core/normalize.js

@@ -17,14 +17,17 @@ export function normaliseHtml(html, options = {}) {
   const stats = {
     removedElements: 0,
     removedAttributes: 0,
+    removedMetadata: 0,
     dedupedStyles: 0,
     hints: 0,
     textSeparators: 0,
     titleElements: 0,
+    noindex: false,
     metadataOrigins: [],
   };
   const seenStyles = new Set();
   cleanChildren(document, stats, seenStyles, false, options);
+  if (options.noindex && !stats.noindex) stats.noindex = appendNoindex(document);
 
   const preconnectOrigins = options.preconnectOrigins ?? [];
   const preloadImages = options.preloadImages ?? [];
@@ -41,6 +44,7 @@ function cleanChildren(parent, stats, seenStyles, inHead, options) {
   const kept = [];
   for (const child of children) {
     const childInHead = inHead || child.tagName === 'head';
+    if (shouldStripMetadata(child, options, stats)) continue;
     if (shouldRemove(child, stats, options)) continue;
     if (child.attrs && options.removeAttributes?.length > 0) {
       stripAttributes(child, options.removeAttributes, stats);
@@ -48,6 +52,7 @@ function cleanChildren(parent, stats, seenStyles, inHead, options) {
     if (childInHead && child.tagName === 'style' && dedupeStyle(child, stats, seenStyles)) continue;
     if (childInHead && child.tagName === 'title') stats.titleElements += 1;
     if (childInHead) collectMetadataOrigins(child, stats);
+    if (childInHead) collectRobots(child, stats);
     if (options.asyncScriptTags && child.tagName === 'script') markScriptAsync(child);
     cleanChildren(child, stats, seenStyles, childInHead, options);
     if (child.content) cleanChildren(child.content, stats, seenStyles, childInHead, options);
@@ -84,13 +89,34 @@ function stripAttributes(node, patterns, stats) {
 
 // Reports whether an attribute name matches a string exactly or a RegExp pattern.
 function matchesAttribute(name, pattern) {
-  return pattern instanceof RegExp ? pattern.test(name) : name === pattern;
+  if (!(pattern instanceof RegExp)) return name === pattern;
+  pattern.lastIndex = 0;
+  const matched = pattern.test(name);
+  pattern.lastIndex = 0;
+  return matched;
+}
+
+// Removes metadata whose absolute URL points at the build server, so a loopback
+// canonical or share image never ships. The origin is recorded first so the run can
+// explain what was dropped.
+function shouldStripMetadata(node, options, stats) {
+  if (!options.stripBuildOriginMetadata || !isMetadataUrlNode(node)) return false;
+  const origins = collectBuildOrigins(metadataUrlValue(node));
+  if (origins.length === 0) return false;
+  for (const origin of origins) {
+    if (stats.metadataOrigins.length >= MAX_METADATA_ORIGINS) break;
+    if (!stats.metadataOrigins.includes(origin)) stats.metadataOrigins.push(origin);
+  }
+  stats.removedMetadata += 1;
+  stats.removedElements += 1;
+  return true;
 }
 
 // Reports whether a node is removed for any of the configured reasons. The metadata script is
 // exempt: the head layer reads it on the client, so stripping it would lose the site defaults.
 function shouldRemove(node, stats, options) {
   if (node.tagName === 'script' && hasAttribute(node, 'data-snappy-meta', null)) return false;
+  if (node.tagName === 'style' && hasAttribute(node, 'data-snappy-inline', null)) return false;
   const reason =
     (node.tagName === 'style' && hasAttribute(node, 'id', FREEZE_STYLE_ID)) ||
     hasAttribute(node, REMOVE_ATTRIBUTE, null) ||
@@ -113,6 +139,14 @@ function collectMetadataOrigins(node, stats) {
   }
 }
 
+// Records a robots noindex so the sitemap can leave the page out.
+function collectRobots(node, stats) {
+  if (node.tagName !== 'meta') return;
+  if (attributeValue(node, 'name').toLowerCase() !== 'robots') return;
+  const content = attributeValue(node, 'content').toLowerCase();
+  if (/\b(noindex|none)\b/.test(content)) stats.noindex = true;
+}
+
 // Drops a style tag whose text was already seen, reporting it through stats.
 function dedupeStyle(node, stats, seenStyles) {
   const text = textContent(node);
@@ -124,9 +158,11 @@ function dedupeStyle(node, stats, seenStyles) {
   return false;
 }
 
-// Adds async to external scripts that are neither async nor defer yet.
+// Adds async to external scripts that are neither async nor defer yet. The injected state
+// script is exempt because it must run before the app bundle so snapStore is available.
 function markScriptAsync(node) {
   const attrs = node.attrs ?? [];
+  if (attrs.some((attribute) => attribute.name === 'data-snappy-state')) return;
   if (!attrs.some((attribute) => attribute.name === 'src')) return;
   if (attrs.some((attribute) => attribute.name === 'async' || attribute.name === 'defer')) return;
   attrs.push({ name: 'async', value: '' });
@@ -139,6 +175,20 @@ function isBlobStylesheet(node) {
   return attributeValue(node, 'href').startsWith('blob:');
 }
 
+// Adds a robots noindex meta to the not-found page, which may be served with a 200 by
+// a host that does not apply 404 status codes. Returns true when the tag was added.
+function appendNoindex(document) {
+  const head = findHead(document);
+  if (!head) return false;
+  head.childNodes.push(
+    createElement('meta', [
+      { name: 'name', value: 'robots' },
+      { name: 'content', value: 'noindex' },
+    ]),
+  );
+  return true;
+}
+
 // Appends preconnect and image preload links to the head, skipping duplicates.
 function appendHints(document, { preconnectOrigins, preloadImages }) {
   const head = findHead(document);

package/src/core/output.js

@@ -27,18 +27,24 @@ export function routeToScreenshotFile(route, { saveAs = 'png' } = {}) {
 
 /**
  * Finds routes that would write the same output file. Two routes can collide, most
- * obviously with flatOutput where both "/" and "/index" map to index.html. Callers
+ * obviously with flatOutput where both "/" and "/index" map to index.html. On a
+ * case-insensitive filesystem, paths that differ only by case collide too. Callers
  * use this to refuse the ambiguous writes instead of letting one overwrite the other.
  */
-export function findOutputCollisions(routes, config) {
+export function findOutputCollisions(
+  routes,
+  config,
+  { caseInsensitive = process.platform === 'darwin' || process.platform === 'win32' } = {},
+) {
   const byFile = new Map();
   const saveAs = config.saveAs ?? 'html';
   for (const route of routes) {
     const file =
       saveAs === 'html' ? routeToFile(route, config) : routeToScreenshotFile(route, config);
-    const existing = byFile.get(file);
+    const key = caseInsensitive ? file.toLowerCase() : file;
+    const existing = byFile.get(key);
     if (existing) existing.push(route);
-    else byFile.set(file, [route]);
+    else byFile.set(key, [route]);
   }
   return new Map([...byFile].filter(([, list]) => list.length > 1));
 }
@@ -61,17 +67,34 @@ export async function writeRouteHtml({ dir, route, html, config }) {
  * files routes reference both go through here so a rebuild only touches what changed.
  */
 export async function writeFileIfChanged({ dir, file, contents }) {
+  return writeIfChanged({ dir, file, contents });
+}
+
+/**
+ * Writes a generated binary file, leaving an identical one untouched. Screenshots use
+ * this so a rebuild only replaces images whose pixels changed.
+ */
+export async function writeBufferIfChanged({ dir, file, buffer }) {
+  return writeIfChanged({ dir, file, contents: buffer });
+}
+
+// Compares the existing file with the new value, handling text and binary payloads,
+// then writes through a temporary file so an interrupted run cannot leave a partial
+// file behind for a host to serve.
+async function writeIfChanged({ dir, file, contents }) {
   const bytes = Buffer.byteLength(contents);
   const target = path.join(dir, file);
-  const existing = await fs.readFile(target, 'utf8').catch(() => null);
-  if (existing === contents) return { file, status: 'unchanged', bytes };
+  const existing = await fs.readFile(target).catch(() => null);
+  const unchanged =
+    typeof contents === 'string'
+      ? existing?.toString('utf8') === contents
+      : existing !== null && Buffer.compare(existing, contents) === 0;
+  if (unchanged) return { file, status: 'unchanged', bytes };
 
   await fs.mkdir(path.dirname(target), { recursive: true });
-  // Written through a temporary file and renamed, so an interrupted run cannot leave a
-  // half-written file behind for a host to serve.
   const temporary = `${target}.snappy-tmp`;
   try {
-    await fs.writeFile(temporary, contents, 'utf8');
+    await fs.writeFile(temporary, contents);
     await fs.rename(temporary, target);
   } catch (error) {
     await fs.rm(temporary, { force: true }).catch(() => {});

package/src/core/page-content.js

@@ -0,0 +1,13 @@
+/**
+ * Reports whether a rendered page carries any app content. A missing container and an
+ * empty container both mean the browser did not receive an app, which is what a 404,
+ * a failed bundle, or an empty build looks like after serialisation.
+ */
+export async function isPageEmpty(page) {
+  return page.evaluate(() => {
+    const container = document.querySelector('#root, #app, #__next') ?? document.body;
+    if (!container) return true;
+    const text = (container.textContent ?? '').trim();
+    return container.childElementCount === 0 && text.length === 0;
+  });
+}

package/src/core/preload-manifest.js

@@ -1,17 +1,71 @@
 import path from 'node:path';
-import { toPublicPath } from './routes.js';
+import { parse } from 'parse5';
+import { toAppPath } from './resources.js';
+import { normaliseRoute, toPublicPath } from './routes.js';
+import { pagePath } from './url-policy.js';
+
+/** A synthetic origin used only to resolve hrefs while reading the generated HTML. */
+const PAGE_ORIGIN = 'http://snappy.local';
+
+/**
+ * Reads the scripts and stylesheets the final HTML actually references. Using the
+ * output rather than the render-time resource list keeps the manifest correct after
+ * inline CSS, tag surgery, or a failed write.
+ */
+export function collectPageResources(html, { base = '/', route = '/' } = {}) {
+  const document = parse(html);
+  const scripts = [];
+  const styles = [];
+  const pageUrl = new URL(toPublicPath(route, base), PAGE_ORIGIN);
+  const add = (node, attribute, target) => {
+    const raw = node.attrs?.find((entry) => entry.name === attribute)?.value;
+    if (!raw || raw.startsWith('data:') || raw.startsWith('blob:')) return;
+    let url;
+    try {
+      url = new URL(raw, pageUrl);
+    } catch {
+      return;
+    }
+    if (url.origin !== PAGE_ORIGIN) return;
+    const appPath = toAppPath(url.href, base);
+    if (appPath) target.push(appPath);
+  };
+  const walk = (node) => {
+    if (node.tagName === 'template') return;
+    if (node.tagName === 'script') add(node, 'src', scripts);
+    if (node.tagName === 'link') {
+      const rel = node.attrs?.find((entry) => entry.name === 'rel')?.value ?? '';
+      if (rel.split(/\s+/).includes('stylesheet')) add(node, 'href', styles);
+    }
+    for (const child of node.childNodes ?? []) walk(child);
+  };
+  walk(document);
+  return { scripts: [...new Set(scripts)], styles: [...new Set(styles)] };
+}
 
 /**
  * Builds the preload manifest: for every route, the same-origin scripts and
- * stylesheets it loaded, rendered as a Link header value. This replaces react-snap's
- * http2PushManifest because browsers removed HTTP/2 push (Chrome in v106); hosts can
- * still use these values for Early Hints or Link response headers. Hints and route keys
- * both carry the base path so they match the URLs a host actually sees.
+ * stylesheets the final page references, rendered as a Link header value. This
+ * replaces react-snap's http2PushManifest because browsers removed HTTP/2 push
+ * (Chrome in v106); hosts can still use these values for Early Hints or Link response
+ * headers. Hints and route keys both carry the base path so they match the URLs a host
+ * actually sees.
  */
-export function buildPreloadManifest(entries, { ignoreForPreload = [], base = '/' } = {}) {
+export function buildPreloadManifest(
+  entries,
+  {
+    ignoreForPreload = [],
+    base = '/',
+    flatOutput = false,
+    trailingSlash = 'preserve',
+    notFoundRoute = null,
+  } = {},
+) {
   const ignored = new Set(ignoreForPreload);
+  const notFound = notFoundRoute ? normaliseRoute(notFoundRoute) : null;
   const manifest = [];
   for (const entry of entries) {
+    if (notFound && normaliseRoute(entry.route) === notFound) continue;
     const hints = [];
     for (const asset of [...entry.scripts, ...entry.styles]) {
       if (ignored.has(path.posix.basename(asset))) continue;
@@ -20,7 +74,7 @@ export function buildPreloadManifest(entries, { ignoreForPreload = [], base = '/
     }
     if (hints.length === 0) continue;
     manifest.push({
-      source: toPublicPath(entry.route, base),
+      source: toPublicPath(pagePath(entry.route, { flatOutput, trailingSlash }), base),
       headers: [{ key: 'Link', value: hints.join(',') }],
     });
   }

package/src/core/prune.js

@@ -0,0 +1,65 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const MANIFEST_FILE = '.snappy-manifest.json';
+
+/**
+ * Reads the file list the previous run wrote. A missing or malformed manifest simply
+ * disables pruning, so an older output directory can be upgraded safely.
+ */
+export async function readPruneManifest(dir) {
+  try {
+    const parsed = JSON.parse(await fs.readFile(path.join(dir, MANIFEST_FILE), 'utf8'));
+    return Array.isArray(parsed.files) ? parsed.files : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Deletes files the previous run generated that this run no longer produces, then
+ * removes emptied route directories. Only paths recorded in the manifest are touched,
+ * so assets and files the user added are never at risk.
+ */
+export async function pruneStaleFiles({ dir, previous, current, log }) {
+  if (!Array.isArray(previous)) return [];
+  const keep = new Set(current);
+  const root = path.resolve(dir);
+  const removed = [];
+  for (const file of previous) {
+    if (typeof file !== 'string' || keep.has(file)) continue;
+    if (file === MANIFEST_FILE || file === 'robots.txt') continue;
+    const target = path.resolve(root, file);
+    if (target !== root && !target.startsWith(`${root}${path.sep}`)) continue;
+    try {
+      await fs.rm(target, { force: true });
+      removed.push(file);
+      await removeEmptyParents(root, path.dirname(target));
+    } catch (error) {
+      log?.warn(`could not prune ${file}: ${error.message}`);
+    }
+  }
+  return removed;
+}
+
+// Writes the manifest for the next run. Files that are not ours to own are excluded.
+export async function writePruneManifest({ dir, files }) {
+  const owned = [...new Set(files)].filter(
+    (file) => file !== MANIFEST_FILE && file !== 'robots.txt',
+  );
+  const contents = `${JSON.stringify({ version: 1, files: owned.sort() }, null, 2)}\n`;
+  await fs.writeFile(path.join(dir, MANIFEST_FILE), contents, 'utf8');
+}
+
+// Removes parent directories that became empty, stopping at the output root.
+async function removeEmptyParents(root, start) {
+  let current = start;
+  while (current !== root && current.startsWith(`${root}${path.sep}`)) {
+    try {
+      await fs.rmdir(current);
+    } catch {
+      return;
+    }
+    current = path.dirname(current);
+  }
+}

package/src/core/render.js

@@ -1,7 +1,6 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import { captureFormState } from './form-state.js';
 import { inlineStylesheets } from './inline-css.js';
+import { isPageEmpty } from './page-content.js';
 import { createResourceCollector } from './resources.js';
 import { toAppRoute, toServerUrl } from './routes.js';
 import { captureRuntimeStyles } from './runtime-styles.js';
@@ -27,20 +26,43 @@ function escapeForScript(value) {
  * storage from leaking between routes. When a screenshot path is supplied the route
  * is captured as an image instead of HTML.
  */
-export async function renderRoute({ browser, origin, route, config, screenshotPath }) {
+export async function renderRoute({ browser, origin, route, config, screenshot = false }) {
   const context = await browser.newContext({
     viewport: config.viewport,
     storageState: config.storageState ?? undefined,
     userAgent: config.userAgent ?? undefined,
     ignoreHTTPSErrors: config.ignoreHTTPSErrors,
     reducedMotion: config.freezeAnimations ? 'reduce' : 'no-preference',
+    serviceWorkers: 'block',
   });
   const page = await context.newPage();
   const pageErrors = [];
+  const consoleErrors = [];
+  const failedRequests = [];
   let inlineCssSkipped = [];
   page.on('pageerror', (error) => pageErrors.push(error.message));
+  page.on('console', (message) => {
+    if (message.type() === 'error') consoleErrors.push(message.text());
+  });
+  // Only same-origin failures are the build's own to fix; a blocked analytics host is
+  // not a broken page. Aborted requests are navigations or cancelled fetches, not 404s.
+  page.on('response', (response) => {
+    if (response.status() < 400) return;
+    const parsed = parseHttpUrl(response.url());
+    if (parsed?.origin !== origin) return;
+    failedRequests.push({ url: response.url(), status: response.status() });
+  });
+  page.on('requestfailed', (request) => {
+    const parsed = parseHttpUrl(request.url());
+    if (parsed?.origin !== origin) return;
+    const error = request.failure()?.errorText ?? 'request failed';
+    if (error.includes('ERR_ABORTED')) return;
+    failedRequests.push({ url: request.url(), status: null, error });
+  });
 
-  const metadataDefaults = config.metadata ? { base: config.base, ...config.metadata } : null;
+  const metadataDefaults = config.metadata
+    ? { base: config.base, flatOutput: config.flatOutput, ...config.metadata }
+    : null;
   if (metadataDefaults) {
     await page.addInitScript((defaults) => {
       window.__SNAPPY_META__ = defaults;
@@ -58,11 +80,17 @@ export async function renderRoute({ browser, origin, route, config, screenshotPa
   await collector.install(page);
   const tracker = trackNetwork(page);
   try {
-    await page.goto(toServerUrl(route, config.base, origin), {
+    const response = await page.goto(toServerUrl(route, config.base, origin), {
       waitUntil: 'domcontentloaded',
       timeout: config.timeout,
     });
+    if (response && response.status() >= 400) {
+      throw new Error(
+        `route responded with HTTP ${response.status()}${response.statusText() ? ` ${response.statusText()}` : ''}`,
+      );
+    }
     await settlePage(page, config, tracker);
+    const empty = await isPageEmpty(page);
 
     if (config.captureRuntimeStyles) await captureRuntimeStyles(page);
     if (config.captureFormState) await captureFormState(page);
@@ -82,22 +110,38 @@ export async function renderRoute({ browser, origin, route, config, screenshotPa
 
     const links = await collectLinks(page, config.base, origin);
 
-    if (screenshotPath) {
-      await fs.mkdir(path.dirname(screenshotPath), { recursive: true });
-      await page.screenshot({ path: screenshotPath, fullPage: true });
+    if (screenshot) {
+      const buffer = await page.screenshot({
+        fullPage: true,
+        type: config.saveAs === 'jpeg' ? 'jpeg' : 'png',
+      });
       return {
         route,
         links,
         pageErrors,
+        consoleErrors,
+        failedRequests,
         collector,
         inlineCssSkipped,
         stateScript,
-        screenshot: true,
+        screenshot: buffer,
+        empty,
       };
     }
 
     const html = await page.content();
-    return { route, html, links, pageErrors, collector, inlineCssSkipped, stateScript };
+    return {
+      route,
+      html,
+      links,
+      pageErrors,
+      consoleErrors,
+      failedRequests,
+      collector,
+      inlineCssSkipped,
+      stateScript,
+      empty,
+    };
   } finally {
     tracker.stop();
     await context.close();
@@ -226,3 +270,13 @@ async function collectLinks(page, base, origin) {
   }
   return routes;
 }
+
+// Parses an HTTP URL, returning null for data, blob and other non-network URLs.
+function parseHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === 'http:' || parsed.protocol === 'https:' ? parsed : null;
+  } catch {
+    return null;
+  }
+}

package/src/core/resources.js

@@ -49,6 +49,7 @@ export function createResourceCollector({
         const url = request.url();
         const parsed = parseUrl(url);
         if (!parsed || parsed.origin !== origin) return;
+        if (response.status() >= 400) return;
         const path = toAppPath(url, base);
         if (!path) return;