@@ -50,6 +50,6 @@ The output holds paths real visitors requested, search terms included. Keep it,
 node test/parity/perf.mjs [--corpus traffic] [--format html,api] [--only john] [--runs 5] [--max-live 200] [--refresh-live] [--json out.json]
 ```
 
-It prints, per format and overall, the p50 and p95 across URLs of each URL's median on Node and live, and the ratio of the Node p50 to the live p50 over URLs timed on both. A URL is flagged when its Node median is more than 1.5 times live's and more than 300 ms slower. Live requests are spaced at least 250 ms apart and capped by `--max-live` (warm-ups count); URLs past the cap get Node times only. Live times are cached with a timestamp in `.cache/perf-live.json`, so later runs reuse them until `--refresh-live`.
+It prints, per format and overall, the p50 and p95 across URLs of each URL's median on Node and live, and the ratio of the Node p50 to the live p50 over URLs timed on both. A URL is flagged when its Node median is more than 1.5 times live's and more than 300 ms slower. Responses other than 2xx/3xx are listed apart: a Node error leaves the URL out of the stats, a live one leaves it without a live time. Live requests are spaced at least 250 ms apart and capped by `--max-live` (warm-ups count); URLs past the cap get Node times only. Live times are cached with a timestamp in `.cache/perf-live.json`, so later runs reuse them until `--refresh-live`.
 
 Against a local app and database the comparison is indicative only: live times include the network round trip from your machine, Node times do not, and a laptop with a local copy of the database is not the production host. Time on staging for numbers that decide anything.
@@ -12,7 +12,7 @@
 import { performance } from 'node:perf_hooks';
 import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
 import { CACHE_ROOT, NODE_BASE, LIVE_SCHEME, USER_AGENT, cliOptions, loadCorpus, selectRequests, get, hostFor } from './harness.mjs';
-import { report, cachedLive, FLAG_RATIO, FLAG_MS } from './perfStats.mjs';
+import { report, cachedLive, isOk, FLAG_RATIO, FLAG_MS } from './perfStats.mjs';
 
 const LIVE_GAP_MS = 250;
 const LIVE_CACHE = CACHE_ROOT + '/perf-live.json';
@@ -41,7 +41,7 @@ async function series(url, headers, { gap = 0 } = {}) {
   for (let i = 0; i <= runs; i++) { // i = 0 is the warm-up
     if (gap && i) await new Promise(r => setTimeout(r, gap));
     const t = await timed(url, headers);
-    status = t.status;
+    if (status === undefined || isOk(status)) status = t.status; // keep the first error status
     if (i) times.push(Math.round(t.ms * 10) / 10);
   }
   return { times, status };
@@ -50,19 +50,20 @@ async function series(url, headers, { gap = 0 } = {}) {
 let liveSpent = 0;
 let liveSkipped = 0;
 let lastLive = 0;
+// { times, status } for the live URL, or null without live times
 async function liveTimes(format, path) {
   const url = `${LIVE_SCHEME}://${hostFor(format)}${path}`;
   const cached = cachedLive(liveCache, url, runs, { refresh: refreshLive });
-  if (cached) return cached;
+  if (cached) return { times: cached, status: liveCache[url].status };
   if (liveSpent + runs + 1 > maxLive) { liveSkipped++; return null; }
   const wait = lastLive + LIVE_GAP_MS - Date.now();
   if (wait > 0) await new Promise(r => setTimeout(r, wait));
   liveSpent += runs + 1;
   try {
-    const { times } = await series(url, {}, { gap: LIVE_GAP_MS });
-    liveCache[url] = { at: new Date().toISOString(), times };
+    const { times, status } = await series(url, {}, { gap: LIVE_GAP_MS });
+    liveCache[url] = { at: new Date().toISOString(), times, status };
     writeFileSync(LIVE_CACHE, JSON.stringify(liveCache, null, 1));
-    return times;
+    return { times, status };
   } catch (e) {
     console.error(`live ${url}: ${e.message}`);
     return null;
@@ -75,13 +76,13 @@ const results = [];
 for (const [format, path] of requests) {
   let node;
   try {
-    node = (await series(NODE_BASE + path, { Host: hostFor(format) })).times;
+    node = await series(NODE_BASE + path, { Host: hostFor(format) });
   } catch (e) {
     console.error(`node ${format} ${path}: ${e.message}`);
     continue;
   }
   const live = await liveTimes(format, path);
-  results.push({ format, path, node, live });
+  results.push({ format, path, node: node.times, nodeStatus: node.status, live: live?.times ?? null, liveStatus: live?.status });
   process.stderr.write('.');
 }
 process.stderr.write('\n');
@@ -92,7 +93,7 @@ const x = v => (v == null ? '-' : v.toFixed(2));
 const row = (name, g, n) => `${name.padEnd(14)} ${String(n).padStart(4)} ${ms(g.node.p50).padStart(8)} ${ms(g.node.p95).padStart(8)} ` +
   `${ms(g.live.p50).padStart(8)} ${ms(g.live.p95).padStart(8)} ${x(g.ratio).padStart(6)} ${String(g.flagged).padStart(7)}`;
 
-console.log(`${runs} runs per URL, median per URL; p50/p95 across URLs, in ms. Ratio = Node p50 / live p50 over URLs timed on both.`);
+console.log(`${runs} runs per URL, median per URL; p50/p95 across URLs, in ms. Ratio = Node p50 / live p50 over URLs timed on both. Error responses are listed apart.`);
 console.log('format         urls node p50 node p95 live p50 live p95  ratio flagged');
 for (const [f, g] of Object.entries(r.formats)) console.log(row(f, g, r.urls.filter(u => u.format === f).length));
 console.log(row('overall', r.overall, r.urls.length));
@@ -104,6 +105,10 @@ console.log('\nSlowest on Node:');
 for (const u of [...r.urls].sort((a, b) => b.node - a.node).slice(0, 10)) {
   console.log(`  ${ms(u.node).padStart(6)}  live ${ms(u.live).padStart(6)}  ${u.format.padEnd(8)} ${u.path}`);
 }
+if (r.errors.length) {
+  console.log(`\nError responses (not 2xx/3xx; a Node error leaves the URL out of the stats, a live one its live time): ${r.errors.length}`);
+  for (const e of r.errors) console.log(`  ${e.format.padEnd(8)} ${e.path}  node ${e.nodeStatus ?? '-'}  live ${e.liveStatus ?? '-'}`);
+}
 console.log(`\nLive: ${liveSpent} requests made, ${liveSkipped} URLs without live times (--max-live ${maxLive}).`);
 
 if (jsonOut) {
 
@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'vitest';
-import { percentile, summarize, ratio, isFlagged, cachedLive, report } from './perfStats.mjs';
+import { percentile, summarize, ratio, isFlagged, cachedLive, report, isOk } from './perfStats.mjs';
 
 describe('percentile', () => {
   test('interpolates between the closest ranks', () => {
@@ -100,3 +100,30 @@ describe('report', () => {
     expect(r.overall.ratio).toBeCloseTo(530 / 200);
   });
 });
+
+describe('error responses', () => {
+  test('isOk: 2xx and 3xx', () => {
+    expect([200, 204, 301, 304, 399].every(isOk)).toBe(true);
+    expect([400, 404, 410, 500, 503, undefined, null].some(isOk)).toBe(false);
+  });
+  const results = [
+    { format: 'html', path: '/a', node: [100, 100], nodeStatus: 200, live: [50, 50], liveStatus: 200 },
+    { format: 'html', path: '/missing', node: [5, 5], nodeStatus: 404, live: [900, 900], liveStatus: 404 },
+    { format: 'html', path: '/broken-live', node: [20, 20], nodeStatus: 200, live: [3000, 3000], liveStatus: 500 },
+    { format: 'html', path: '/old-cache', node: [30, 30], nodeStatus: 200, live: [40, 40] },
+  ];
+  const r = report(results);
+  test('a Node error response is left out of the stats and listed', () => {
+    expect(r.urls.map(u => u.path)).toEqual(['/a', '/broken-live', '/old-cache']);
+    expect(r.errors).toEqual([
+      { format: 'html', path: '/missing', nodeStatus: 404, liveStatus: 404 },
+      { format: 'html', path: '/broken-live', nodeStatus: 200, liveStatus: 500 },
+    ]);
+  });
+  test('a live error response leaves the URL without a live time', () => {
+    const u = r.urls.find(x => x.path === '/broken-live');
+    expect(u.live).toBeNull();
+    expect(u.flagged).toBe(false);
+    expect(r.formats.html.live.n).toBe(2); // /a and /old-cache (cached before statuses were kept)
+  });
+});
@@ -20,6 +20,11 @@ export function summarize(values) {
   return { n: values.length, p50: percentile(values, 50), p95: percentile(values, 95) };
 }
 
+// A response worth timing: 2xx or 3xx. Error pages (404 probes, 5xx) are reported apart.
+export function isOk(status) {
+  return Number.isInteger(status) && status >= 200 && status < 400;
+}
+
 export function ratio(node, live) {
   return node == null || !live ? null : node / live;
 }
@@ -47,16 +52,22 @@ function group(urls) {
 }
 
 /**
- * @param {{format:string, path:string, node:number[], live:number[]|null}[]} results
+ * @param {{format:string, path:string, node:number[], live:number[]|null, nodeStatus?:number, liveStatus?:number}[]} results
  * Per URL: the median of its runs. Per format and overall: p50/p95 across those URL medians.
+ * A URL whose Node response is an error is left out (listed in `errors`); a live error response
+ * leaves the URL without a live time. A missing liveStatus (cached before statuses were kept)
+ * counts as ok.
  */
 export function report(results) {
-  const urls = results.map(({ format, path, node, live }) => {
+  const errors = results
+    .filter(r => !isOk(r.nodeStatus ?? 200) || !isOk(r.liveStatus ?? 200))
+    .map(({ format, path, nodeStatus, liveStatus }) => ({ format, path, nodeStatus, liveStatus }));
+  const urls = results.filter(r => isOk(r.nodeStatus ?? 200)).map(({ format, path, node, live, liveStatus }) => {
     const n = percentile(node, 50);
-    const l = live?.length ? percentile(live, 50) : null;
+    const l = live?.length && isOk(liveStatus ?? 200) ? percentile(live, 50) : null;
     return { format, path, node: n, live: l, ratio: ratio(n, l), flagged: isFlagged(n, l) };
   });
   const formats = {};
   for (const f of new Set(urls.map(u => u.format))) formats[f] = group(urls.filter(u => u.format === f));
-  return { urls, formats, overall: group(urls) };
+  return { urls, formats, overall: group(urls), errors };
 }