eaa-kit 0.5.0 → 0.7.0

package/dist/{audit-B282A3EA.js → audit-DRjAY2iY.js}

@@ -1,9 +1,13 @@
-import { a as impactRank, i as impactLabel, r as countAtOrAbove } from "./impact-DZt2oBCP.js";
-import { a as plural, n as count, t as collapse } from "./text-CKKpzkYM.js";
-import { a as isShared, c as runCompleteness, i as groupIssues, n as blindRules, r as coverageParts, t as remediationFor } from "./remediation-CMBIrnpN.js";
-import { r as componentPath } from "./component-C3GL1Mnu.js";
-import { i as understandingUrl, n as coverageSummary, r as manualCheckFor, t as buildCoverage } from "./coverage-B_Y6l-Ra.js";
-import { a as emitDocument, c as runEngine, l as warn, o as fail, s as note, t as advise } from "./command-C3D7JWn6.js";
+import { a as impactLabel, i as countAtOrAbove, r as byImpactThenRule } from "./impact-luGCnN8F.js";
+import { n as count, o as plural, t as collapse } from "./text-BF1LHMiV.js";
+import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
+import { n as DEFAULT_TAGS, u as runEngine } from "./result-B7_zVxAX.js";
+import { a as emitDocument, c as runEngine$1, l as warn, o as fail, s as note, t as advise } from "./command-3r4fht5f.js";
+import { l as reviewSentence } from "./review-CdMK2GpQ.js";
+import { a as isShared, i as groupIssues, l as reusedPart, n as blindRules, o as issueTotals, r as coverageParts, t as remediationFor, u as runCompleteness } from "./remediation-C0klJblu.js";
+import { r as componentPath } from "./component-ChisoFyY.js";
+import { a as manualCheckFor, n as coverageSummary, o as understandingUrl, r as reviewSummary, t as buildCoverage } from "./coverage-cb5kPp48.js";
+import { n as buildSummary } from "./json-Bus6YhxB.js";
 import { i as holdsHtml, n as collectPages, r as emptyDirectoryHint, t as BuildDirectoryError } from "./collect-Cu1q9NTB.js";
 import path from "node:path";
 import pc from "picocolors";
@@ -51,6 +55,7 @@ function context(options) {
 		manual: options.manual ?? false,
 		coverage: options.coverage ?? false,
 		framework: options.framework,
+		review: options.review,
 		completeness: options.completeness,
 		c,
 		symbol: (kind) => {
@@ -73,7 +78,7 @@ function supportsUnicode() {
 * Joins segments into one line, trimming the group to the terminal width.
 * Colour codes are applied after trimming, so they never count towards it.
 */
-function render(ctx, segments) {
+function render$1(ctx, segments) {
 	let remaining = ctx.width;
 	const parts = [];
 	for (const segment of segments) {
@@ -86,14 +91,14 @@ function render(ctx, segments) {
 }
 /** One line from a single segment, which is what most of this report is. */
 function line(ctx, text, paint) {
-	return render(ctx, paint === void 0 ? [{ text }] : [{
+	return render$1(ctx, paint === void 0 ? [{ text }] : [{
 		text,
 		paint
 	}]);
 }
 function headerLines(audits, ctx) {
-	const engineLabel = (audits[0]?.engine ?? "jsdom") === "browser" ? "chromium" : "jsdom (browserless)";
-	return [render(ctx, [{
+	const engineLabel = runEngine(audits) === "browser" ? "chromium" : "jsdom (browserless)";
+	return [render$1(ctx, [{
 		text: "eaa-kit audit",
 		paint: ctx.c.bold
 	}, {
@@ -114,14 +119,14 @@ function legendLines(ctx) {
 function pageSection(audit, ctx) {
 	const lines = [line(ctx, audit.relativePath, ctx.c.underline)];
 	if (audit.error) {
-		lines.push(render(ctx, [{
+		lines.push(render$1(ctx, [{
 			text: `  ${ctx.symbol("error")} not audited: `,
 			paint: ctx.c.red
 		}, { text: audit.error }]), "");
 		return lines;
 	}
-	for (const finding of sortByImpact(audit.violations)) lines.push(...violationLines(finding, ctx));
-	for (const finding of audit.incomplete.filter((item) => item.reason === "needs-review")) lines.push(render(ctx, [
+	for (const finding of [...audit.violations].sort(byImpactThenRule)) lines.push(...violationLines(finding, ctx));
+	for (const finding of audit.incomplete.filter((item) => item.reason === "needs-review")) lines.push(render$1(ctx, [
 		{
 			text: `  ${ctx.symbol("review")} `,
 			paint: ctx.c.yellow
@@ -137,7 +142,7 @@ function pageSection(audit, ctx) {
 	]));
 	if (audit.violations.length === 0) {
 		const clean = (audit.accepted ?? []).length === 0;
-		lines.push(render(ctx, [{
+		lines.push(render$1(ctx, [{
 			text: `  ${ctx.symbol("clean")} `,
 			paint: clean ? ctx.c.green : ctx.c.dim
 		}, {
@@ -145,7 +150,7 @@ function pageSection(audit, ctx) {
 			paint: clean ? ctx.c.green : ctx.c.dim
 		}]));
 	}
-	for (const finding of sortByImpact(audit.accepted ?? [])) {
+	for (const finding of [...audit.accepted ?? []].sort(byImpactThenRule)) {
 		const elements = count(finding.nodes.length, "element");
 		lines.push(line(ctx, `  · ${finding.ruleId} accepted by the baseline (${elements})`, ctx.c.dim));
 	}
@@ -157,8 +162,8 @@ function coverageLine(audit, ctx) {
 	return line(ctx, `    ${coverageParts(audit).join(" · ")}`, ctx.c.dim);
 }
 function violationLines(finding, ctx) {
-	const impact = finding.impact ?? "unknown";
-	const lines = [render(ctx, [
+	const impact = impactLabel(finding.impact);
+	const lines = [render$1(ctx, [
 		{
 			text: `  ${ctx.symbol("violation")} `,
 			paint: ctx.c.red
@@ -181,35 +186,31 @@ function violationLines(finding, ctx) {
 	return lines;
 }
 function summary(audits, ctx) {
-	const withViolations = audits.filter((audit) => audit.violations.length > 0);
-	const errored = audits.filter((audit) => audit.error);
-	const ruleCount = audits.reduce((total, audit) => total + audit.violations.length, 0);
-	const elementCount = audits.reduce((total, audit) => total + audit.violations.reduce((sum, finding) => sum + finding.nodes.length, 0), 0);
+	const totals = buildSummary(audits, ctx.failOn);
 	const reviewCount = countRules(audits, "needs-review");
 	const pages = count(audits.length, "page");
-	const audited = audits.length - errored.length;
+	const audited = totals.pages - totals.pagesNotAudited;
 	const lines = [line(ctx, "Summary", ctx.c.bold), ...completenessLines(ctx)];
-	if (ruleCount === 0 && audited === 0 && errored.length > 0) lines.push(line(ctx, "  Nothing was audited: no page could be read.", ctx.c.red));
-	else if (ruleCount === 0) {
-		const clean = errored.length > 0 || ctx.completeness && !ctx.completeness.complete ? `  No violations across the ${count(audited, "page")} that were audited.` : `  No violations across ${pages}.`;
+	if (totals.violations === 0 && audited === 0 && totals.pagesNotAudited > 0) lines.push(line(ctx, "  Nothing was audited: no page could be read.", ctx.c.red));
+	else if (totals.violations === 0) {
+		const clean = totals.pagesNotAudited > 0 || ctx.completeness && !ctx.completeness.complete ? `  No violations across the ${count(audited, "page")} that were audited.` : `  No violations across ${pages}.`;
 		lines.push(line(ctx, clean, ctx.c.green));
 	} else {
-		lines.push(render(ctx, [{
-			text: `  ${count(ruleCount, "violation")} on ${withViolations.length} of ${count(audited, "page")}`,
+		lines.push(render$1(ctx, [{
+			text: `  ${count(totals.violations, "violation")} on ${totals.pagesWithViolations} of ${count(audited, "page")}`,
 			paint: ctx.c.red
 		}, {
-			text: ` (${count(elementCount, "element")})`,
+			text: ` (${count(totals.violatingElements, "element")})`,
 			paint: ctx.c.dim
 		}]));
-		lines.push(thresholdLine(audits, ctx));
+		lines.push(thresholdLine(totals.failing, ctx));
 	}
 	if (reviewCount > 0) {
 		const verb = reviewCount === 1 ? "needs" : "need";
 		lines.push(line(ctx, `  ${count(reviewCount, "rule")} ${verb} manual review`, ctx.c.yellow));
 	}
-	if (errored.length > 0) lines.push(line(ctx, `  ${count(errored.length, "page")} could not be audited`, ctx.c.red));
-	const accepted = audits.reduce((total, audit) => total + (audit.accepted ?? []).reduce((sum, finding) => sum + finding.nodes.length, 0), 0);
-	if (accepted > 0) lines.push(line(ctx, `  ${count(accepted, "element")} accepted by the baseline, not counted above`, ctx.c.dim));
+	if (totals.pagesNotAudited > 0) lines.push(line(ctx, `  ${count(totals.pagesNotAudited, "page")} could not be audited`, ctx.c.red));
+	if (totals.accepted > 0) lines.push(line(ctx, `  ${count(totals.accepted, "element")} accepted by the baseline, not counted above`, ctx.c.dim));
 	lines.push(...blindSection(audits, ctx));
 	lines.push(...coverageSection(audits, ctx));
 	return lines;
@@ -223,12 +224,14 @@ function summary(audits, ctx) {
 * it could be read as boilerplate.
 */
 function coverageSection(audits, ctx) {
-	const coverage = buildCoverage(audits);
+	const coverage = buildCoverage(audits, void 0, ctx.review);
 	const lines = ["", ...wrap(coverageSummary(coverage), ctx.width - 2).map((text) => line(ctx, `  ${text}`, ctx.c.dim))];
 	if (coverage.browserWouldAnswer > 0) {
 		const verb = coverage.browserWouldAnswer === 1 ? "criterion" : "criteria";
 		lines.push(line(ctx, `  --browser would answer ${coverage.browserWouldAnswer} more ${verb}.`, ctx.c.dim));
 	}
+	const review = reviewSummary(coverage);
+	if (review !== void 0) lines.push(...wrap(review, ctx.width - 2).map((text) => line(ctx, `  ${text}`, ctx.c.dim)));
 	if (!ctx.coverage) {
 		lines.push(line(ctx, "  Run with --coverage for the criterion-by-criterion breakdown.", ctx.c.dim));
 		return lines;
@@ -237,7 +240,7 @@ function coverageSection(audits, ctx) {
 	for (const criterion of coverage.criteria) {
 		const paint = criterion.status === "evaluated" ? ctx.c.green : ctx.c.dim;
 		const note = criterion.browserWouldAnswer ? " (--browser would answer this)" : "";
-		lines.push(render(ctx, [
+		lines.push(render$1(ctx, [
 			{
 				text: `  ${criterion.number} `,
 				paint: ctx.c.bold
@@ -248,6 +251,8 @@ function coverageSection(audits, ctx) {
 				paint
 			}
 		]));
+		const recorded = criterion.review;
+		if (recorded !== void 0) lines.push(line(ctx, `        ${reviewSentence(recorded)}`, ctx.c.dim));
 	}
 	return lines;
 }
@@ -270,8 +275,10 @@ const STATUS_WORDS = {
 */
 function completenessLines(ctx) {
 	const completeness = ctx.completeness;
-	if (completeness === void 0 || completeness.complete) return [];
-	const lines = [];
+	if (completeness === void 0) return [];
+	const reused = reusedPart(completeness);
+	const lines = reused === void 0 ? [] : [line(ctx, `  ${reused}`, ctx.c.dim)];
+	if (completeness.complete) return lines;
 	if (completeness.unreachable.length > 0) {
 		const noun = plural(completeness.unreachable.length, "page");
 		const verb = completeness.unreachable.length === 1 ? "was" : "were";
@@ -285,9 +292,8 @@ function completenessLines(ctx) {
 * Why the run passed or failed. Without this, a build that exits 0 while the
 * report lists violations looks like a bug rather than a threshold choice.
 */
-function thresholdLine(audits, ctx) {
+function thresholdLine(failing, ctx) {
 	const failOn = ctx.failOn;
-	const failing = countAtOrAbove(audits, failOn);
 	if (failing === 0) return line(ctx, `  none at or above ${failOn} (--fail-on ${failOn}), so this run passes`, ctx.c.green);
 	return line(ctx, `  ${failing} at or above ${failOn} (--fail-on ${failOn})`, ctx.c.red);
 }
@@ -306,7 +312,7 @@ function blindSection(audits, ctx) {
 		line(ctx, "  They are never reported as passing.", ctx.c.dim)
 	];
 	for (const { ruleId, pages, finding } of blind) {
-		lines.push(render(ctx, [
+		lines.push(render$1(ctx, [
 			{ text: `  ${ctx.symbol("blind")} ` },
 			{ text: ruleId },
 			{
@@ -332,9 +338,6 @@ function countRules(audits, reason) {
 	for (const audit of audits) for (const finding of audit.incomplete) if (finding.reason === reason) ruleIds.add(finding.ruleId);
 	return ruleIds.size;
 }
-function sortByImpact(findings) {
-	return [...findings].sort((a, b) => impactRank(a.impact) - impactRank(b.impact) || a.ruleId.localeCompare(b.ruleId));
-}
 function criteria(finding) {
 	return finding.successCriteria.length > 0 ? `, WCAG ${finding.successCriteria.join(" ")}` : "";
 }
@@ -350,14 +353,13 @@ function criteria(finding) {
 function issuesSection(audits, ctx) {
 	const issues = groupIssues(audits);
 	if (issues.length === 0) return [];
-	const elements = issues.reduce((total, issue) => total + issue.elements.length, 0);
-	const occurrences = issues.reduce((total, issue) => total + issue.occurrences, 0);
+	const { elements, occurrences } = issueTotals(issues);
 	const lines = [line(ctx, "Issues", ctx.c.bold)];
 	const intro = occurrences === elements ? `  ${count(elements, "distinct element")} to fix.` : `  ${count(occurrences, "violation")} across the site come from ${count(elements, "distinct element")}.`;
 	lines.push(line(ctx, intro, ctx.c.dim));
 	for (const issue of issues) {
 		lines.push("");
-		lines.push(render(ctx, [
+		lines.push(render$1(ctx, [
 			{ text: `  ${ctx.symbol("violation")} ` },
 			{
 				text: issue.ruleId,
@@ -398,7 +400,7 @@ function remediationLines(ruleId, html, ctx) {
 	const width = ctx.width - 6 - 2;
 	const lines = [...wrap(remediation.why, width).map((text) => line(ctx, `${indent}${text}`, ctx.c.dim)), ...wrap(`Fix: ${remediation.fix}`, width).map((text) => line(ctx, `${indent}${text}`))];
 	const example = html === void 0 ? void 0 : remediation.example?.(html);
-	if (example !== void 0) lines.push(render(ctx, [{
+	if (example !== void 0) lines.push(render$1(ctx, [{
 		text: `${indent}→ `,
 		paint: ctx.c.green
 	}, { text: collapse(example) }]));
@@ -409,14 +411,14 @@ function whereLines(element, ctx) {
 	const shown = element.pages.slice(0, ctx.maxNodes);
 	const rest = element.pages.length - shown.length;
 	const component = ctx.componentFor(element.html);
-	const lines = component === void 0 ? [] : [render(ctx, [{
+	const lines = component === void 0 ? [] : [render$1(ctx, [{
 		text: "        written in ",
 		paint: ctx.c.dim
 	}, { text: componentPath(component) }])];
 	lines.push(line(ctx, `        on ${count(element.pages.length, "page")}:`, ctx.c.dim));
 	for (const page of shown) {
 		const source = ctx.sourceFor(page);
-		lines.push(render(ctx, [{
+		lines.push(render$1(ctx, [{
 			text: `          ${page}`,
 			paint: ctx.c.dim
 		}, ...source === void 0 ? [] : [{
@@ -497,12 +499,7 @@ async function resolvePages(directory, options = {}) {
 		warn(await emptyDirectoryHint(shown, cwd));
 		return;
 	}
-	if (unreachable.length > 0) {
-		const verb = unreachable.length === 1 ? "file was" : "files were";
-		warn(`${unreachable.length} ${verb} not readable, and so not audited:`);
-		for (const file of unreachable.slice(0, 10)) note(`  ${file.location} — ${file.reason}`);
-		if (unreachable.length > 10) note(`  …and ${unreachable.length - 10} more`);
-	}
+	warnUnmeasured(unreachable, "file", "readable");
 	return {
 		pages,
 		directory,
@@ -516,13 +513,29 @@ async function resolvePages(directory, options = {}) {
 	};
 }
 /**
+* Name what was missed, up to ten of them, and count the rest.
+*
+* Both collectors need this and neither may skip it: a file that could not be
+* read and a URL that could not be fetched are pages with no verdict, and a run
+* that mentioned neither would report the rest of the site as though it were
+* the site. Ten because the point is to make the problem recognisable, and two
+* hundred failures usually have the one reason the first few show — the count
+* that follows is what says the list was cut.
+*/
+function warnUnmeasured(missed, noun, reached) {
+	if (missed.length === 0) return;
+	warn(`${count(missed.length, noun)} ${missed.length === 1 ? "was" : "were"} not ${reached}, and so not audited:`);
+	for (const item of missed.slice(0, 10)) note(`  ${item.location} — ${item.reason}`);
+	if (missed.length > 10) note(`  …and ${missed.length - 10} more`);
+}
+/**
 * Fetch the pages of a running site, reporting what happened on the way.
 *
 * Returns undefined when the crawl could not start, which the caller turns into
 * exit 2 — a run that reached no verdict, not a clean one.
 */
 async function crawlPages(url, options) {
-	const { crawlSite, CrawlError, parseEntryUrl } = await import("./crawl-BUWPgaGW.js");
+	const { collapsedOnto, crawlSite, CrawlError, parseEntryUrl } = await import("./crawl-BHkJmUkA.js");
 	let entry;
 	try {
 		entry = parseEntryUrl(url, options.allowRemote ?? false);
@@ -540,7 +553,8 @@ async function crawlPages(url, options) {
 		...options.sitemap === void 0 ? {} : { sitemap: options.sitemap },
 		...options.maxPages === void 0 ? {} : { maxPages: options.maxPages },
 		...options.maxDepth === void 0 ? {} : { maxDepth: options.maxDepth },
-		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+		...options.headers === void 0 ? {} : { headers: options.headers }
 	});
 	if (result.pages.length === 0 && result.failures.length > 0) {
 		fail(`Could not fetch ${entry.href} (${result.failures[0]?.reason})`);
@@ -549,23 +563,29 @@ async function crawlPages(url, options) {
 	}
 	const found = result.discovery === "sitemap" ? "sitemap.xml and links" : "links";
 	note(`Found ${count(result.pages.length, "page")} from ${found}`);
-	if (result.failures.length > 0) {
-		const verb = result.failures.length === 1 ? "URL was" : "URLs were";
-		warn(`${result.failures.length} ${verb} not fetched, and so not audited:`);
-		for (const failure of result.failures.slice(0, 10)) note(`  ${failure.url} — ${failure.reason}`);
-		if (result.failures.length > 10) note(`  …and ${result.failures.length - 10} more`);
-	}
+	const failed = result.failures.map((failure) => ({
+		location: failure.url,
+		reason: failure.reason
+	}));
+	warnUnmeasured(failed, "URL", "fetched");
 	if (result.truncated) warn(`Stopped at ${count(result.pages.length, "page")}; the site has more. Raise --max-pages to go further.`);
+	const collapsed = collapsedOnto(result);
+	if (collapsed.length > 0) {
+		const landedOn = collapsed[0]?.landedOn ?? "";
+		warn(`Every page requested answered at ${landedOn}, which is not where it was asked.`);
+		note("  A sign-in page in front of the site looks like this.");
+		note("  If it is behind one, pass --basic-auth user:password or --header \"Cookie: …\".");
+	}
 	return {
 		pages: result.pages,
 		origin: result.origin,
 		completeness: {
 			discovery: result.discovery,
 			collected: result.pages.length,
-			unreachable: result.failures.map((failure) => ({
-				location: failure.url,
-				reason: failure.reason
-			})),
+			unreachable: [...failed, ...collapsed.map((redirect) => ({
+				location: redirect.requested,
+				reason: `answered at ${redirect.landedOn} instead, so this page was not audited`
+			}))],
 			truncated: result.truncated
 		}
 	};
@@ -627,11 +647,15 @@ async function runAuditCommand(dir, options = {}) {
 		exitCode: 2
 	};
 	const { pages, origin, label, cleanup, directory, completeness: collection } = resolved;
+	if (options.headers !== void 0 && directory !== void 0 && !options.browser) warn("--header and --basic-auth apply to pages that are fetched; this run read files.");
 	try {
-		note(`Auditing ${count(pages.length, "page")} in ${label}${await describeEngine(pages, options)}…`);
 		const baseUrl = options.baseUrl ?? origin;
-		let audits = await runEngine(pages, {
+		const { hits, misses, cache } = await splitByCache(pages, baseUrl, options);
+		if (misses.length === 0) note(`Nothing changed in ${label}: reusing ${count(hits.length, "page")} from the cache.`);
+		else note(`Auditing ${count(misses.length, "page")} in ${label}${await describeEngine(misses, options)}${hits.length === 0 ? "" : `, reusing ${count(hits.length, "unchanged page")}`}…`);
+		const fresh = misses.length === 0 ? [] : await runEngine$1(misses, {
 			cwd: options.cwd ?? process.cwd(),
+			...options.headers === void 0 ? {} : { headers: options.headers },
 			...baseUrl === void 0 ? {} : { baseUrl },
 			...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
 			...options.browser ? { browser: true } : {},
@@ -639,10 +663,16 @@ async function runAuditCommand(dir, options = {}) {
 			...options.concurrency === void 0 ? {} : { concurrency: options.concurrency },
 			...directory === void 0 ? {} : { directory }
 		});
-		if (!audits) return {
+		if (!fresh) return {
 			audits: [],
 			exitCode: 2
 		};
+		for (const [index, page] of misses.entries()) {
+			const audit = fresh[index];
+			if (audit) cache?.put(page, audit);
+		}
+		await cache?.flush();
+		let audits = inCollectedOrder(pages, [...hits, ...fresh]);
 		const failOn = options.failOn ?? "serious";
 		if (options.baseline) {
 			const applied = await acceptBaseline(audits, options);
@@ -653,7 +683,12 @@ async function runAuditCommand(dir, options = {}) {
 			audits = applied;
 		}
 		const completeness = runCompleteness(audits, collection);
-		await emit(audits, label, failOn, completeness, options);
+		const review = await loadReview(options);
+		if (review === FAILED) return {
+			audits,
+			exitCode: 2
+		};
+		await emit(audits, label, failOn, completeness, options, review);
 		const unaudited = audits.filter((audit) => audit.error);
 		if (unaudited.length > 0) {
 			fail(`${unaudited.length} of ${audits.length} pages could not be audited`);
@@ -671,6 +706,67 @@ async function runAuditCommand(dir, options = {}) {
 	}
 }
 /**
+* Which pages already have a result, and which have to be audited.
+*
+* Runs before the engine is imported, which is the point: a build where nothing
+* changed produces no misses, and a run with no misses never loads jsdom. The
+* cache itself is opened here rather than earlier so that a run given
+* `--no-cache` does not read one at all.
+*/
+async function splitByCache(pages, baseUrl, options) {
+	if (options.noCache) return {
+		hits: [],
+		misses: [...pages],
+		cache: void 0
+	};
+	const { fromEntry, openCache } = await import("./cache-D4dOIuOi.js");
+	const { pageUrl } = await import("./result-CRmjjoAA.js");
+	const axe = (await import("axe-core")).default;
+	const engine = options.browser ? "browser" : "jsdom";
+	const cache = await openCache({
+		toolVersion: TOOL_VERSION,
+		axeVersion: axe.version,
+		tags: DEFAULT_TAGS,
+		engine,
+		fast: options.fast === true && options.browser !== true,
+		...baseUrl === void 0 ? {} : { baseUrl },
+		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+		...options.headers === void 0 ? {} : { headers: options.headers }
+	}, { ...options.cwd === void 0 ? {} : { cwd: options.cwd } });
+	const hits = [];
+	const misses = [];
+	for (const page of pages) {
+		const entry = cache.get(page);
+		if (entry === void 0) misses.push(page);
+		else hits.push(fromEntry(entry, page, {
+			url: pageUrl(page, baseUrl),
+			engine
+		}));
+	}
+	return {
+		hits,
+		misses,
+		cache
+	};
+}
+/**
+* The audits back in the order their pages were collected in.
+*
+* Collection sorts by path so two runs of one build produce the same report,
+* and splitting the pages into hits and misses would otherwise undo that: the
+* same site would report its pages in a different order depending on which of
+* them somebody had edited since yesterday.
+*/
+function inCollectedOrder(pages, audits) {
+	const byPath = new Map(audits.map((audit) => [audit.relativePath, audit]));
+	const ordered = [];
+	for (const page of pages) {
+		const audit = byPath.get(page.relativePath);
+		if (audit) ordered.push(audit);
+	}
+	return ordered;
+}
+/**
 * Move the violations the baseline accounts for out of the failing set.
 *
 * Returns undefined when the baseline could not be read, which the caller
@@ -679,7 +775,7 @@ async function runAuditCommand(dir, options = {}) {
 * would be as wrong as silently passing.
 */
 async function acceptBaseline(audits, options) {
-	const { applyBaseline, BaselineError, readBaseline } = await import("./baseline-0u4df12v.js");
+	const { applyBaseline, BaselineError, readBaseline } = await import("./baseline-rtnj3RHB.js");
 	try {
 		const outcome = applyBaseline(audits, await readBaseline(options.baseline, options.cwd ?? process.cwd()));
 		if (outcome.accepted > 0) note(`Baseline accepted ${outcome.accepted} violating elements`);
@@ -697,6 +793,32 @@ async function acceptBaseline(audits, options) {
 		throw cause;
 	}
 }
+/** Distinguishes "no review asked for" from "the review could not be read". */
+const FAILED = Symbol("review-failed");
+/**
+* Read the review record, when one was asked for.
+*
+* Returns undefined when no `--review` was given, which is the ordinary case,
+* and the sentinel when one was given and could not be read.
+*/
+async function loadReview(options) {
+	if (options.review === void 0) return void 0;
+	const { answeredCount, readReview, ReviewError } = await import("./review-DIbOTmOM.js");
+	try {
+		const record = await readReview(options.review, options.cwd ?? process.cwd());
+		note(`Review record: ${count(answeredCount(record), "criterion")} answered`);
+		return {
+			record,
+			...options.reviewMaxAge === void 0 ? {} : { maxAgeDays: options.reviewMaxAge }
+		};
+	} catch (cause) {
+		if (cause instanceof ReviewError) {
+			fail(cause.message);
+			return FAILED;
+		}
+		throw cause;
+	}
+}
 /**
 * What the progress line says about the engine.
 *
@@ -706,79 +828,93 @@ async function acceptBaseline(audits, options) {
 */
 async function describeEngine(pages, options) {
 	if (options.browser) return " with Chromium";
-	const { plannedWorkers } = await import("./pool-BO25OIez.js");
+	const { plannedWorkers } = await import("./pool-B4tEUa2S.js");
 	const workers = options.concurrency ?? plannedWorkers(pages);
 	const threads = workers > 1 ? ` across ${workers} threads` : "";
 	return options.fast ? `${threads}, skipping what this engine cannot decide` : threads;
 }
 /**
-* Emit the chosen format, to a file when --output is given and to stdout
-* otherwise. Colour is dropped when writing to a file, since escape codes in a
-* saved report are noise.
+* Render the chosen format and put it where it was asked for: a file under
+* --output, stdout otherwise. Colour is dropped when writing to a file, since
+* escape codes in a saved report are noise.
+*
+* One function rather than a renderer and a writer, because the renderer needed
+* to know where the document was going anyway — which is the whole of what the
+* split was carrying between them.
 */
-async function emit(audits, dir, failOn, completeness, options) {
-	const body = await renderReport(audits, dir, failOn, completeness, options.format ?? "console", typeof options.output === "string", options);
+async function emit(audits, dir, failOn, completeness, options, review) {
+	const body = await render(audits, dir, failOn, completeness, typeof options.output === "string", options, review);
 	await emitDocument(body, options.output, options.cwd ?? process.cwd());
 	if (options.output !== void 0) note(`Report written to ${options.output}`);
 }
-async function renderReport(audits, dir, failOn, completeness, format, toFile, options) {
-	switch (format) {
+async function render(audits, dir, failOn, completeness, toFile, options, review) {
+	switch (options.format ?? "console") {
 		case "json": {
-			const { buildJsonReport, serialiseJsonReport } = await import("./json-D_Mnnft5.js");
+			const { buildJsonReport, serialiseJsonReport } = await import("./json-CrQmoTj6.js");
 			return serialiseJsonReport(buildJsonReport(audits, {
 				directory: dir,
 				...options.url === void 0 ? {} : { sourceKind: "url" },
 				failOn,
 				completeness,
+				...review === void 0 ? {} : { review },
 				...options.baseUrl ? { baseUrl: options.baseUrl } : {}
 			}));
 		}
 		case "sarif": {
-			const { buildSarifReport, serialiseSarifReport } = await import("./sarif-B-UBcVu8.js");
+			const { buildSarifReport, serialiseSarifReport } = await import("./sarif-BNCE0PNT.js");
 			return serialiseSarifReport(buildSarifReport(audits, {
 				directory: dir,
-				completeness
+				completeness,
+				...review === void 0 ? {} : { review }
 			}));
 		}
 		case "html": {
-			const { buildHtmlReport } = await import("./html-C4vktg0A.js");
-			const framework = await detectedFramework(options.cwd ?? process.cwd());
+			const { buildHtmlReport } = await import("./html-BIxxF3FC.js");
 			return buildHtmlReport(audits, {
-				...await sourceLookups(options.cwd ?? process.cwd(), audits),
+				...await fromTheProject(audits, options),
 				directory: dir,
 				failOn,
 				completeness,
-				...framework === void 0 ? {} : { framework },
+				...review === void 0 ? {} : { review },
 				...options.baseUrl ? { baseUrl: options.baseUrl } : {}
 			});
 		}
-		case "console": {
-			const framework = await detectedFramework(options.cwd ?? process.cwd());
-			return `${formatConsoleReport(audits, {
-				...await sourceLookups(options.cwd ?? process.cwd(), audits),
-				dir,
-				failOn,
-				completeness,
-				...options.perPage ? { perPage: true } : {},
-				...options.manual ? { manual: true } : {},
-				...options.coverage ? { coverage: true } : {},
-				...framework === void 0 ? {} : { framework },
-				...toFile ? { color: false } : {}
-			})}\n`;
-		}
+		case "console": return `${formatConsoleReport(audits, {
+			...await fromTheProject(audits, options),
+			dir,
+			failOn,
+			completeness,
+			...review === void 0 ? {} : { review },
+			...options.perPage ? { perPage: true } : {},
+			...options.manual ? { manual: true } : {},
+			...options.coverage ? { coverage: true } : {},
+			...toFile ? { color: false } : {}
+		})}\n`;
 	}
 }
 /**
-* Where a page and a failing element were written, for the two reports that say
-* so. Best-effort: a project using no convention this recognises gets the
-* report it always got, with no source named.
+* What the two human-readable reports both take from the project on disk: where
+* each page and each failing element was written, and what built the site.
+*
+* Only those two ask. JSON and SARIF are read by other programs, which have the
+* project in front of them already, and building the component index for one of
+* them would be several hundred milliseconds spent on nobody's behalf.
 */
-/** The registry id of whatever built this project, for framework-shaped advice. */
-async function detectedFramework(cwd) {
+async function fromTheProject(audits, options) {
+	const cwd = options.cwd ?? process.cwd();
 	const { detectFramework } = await import("./frameworks-etFg_O8K.js");
 	const { readPackageJson } = await import("./project-MFrXcw1M.js");
-	return (await detectFramework(cwd, await readPackageJson(cwd)))?.framework.id;
+	const detected = await detectFramework(cwd, await readPackageJson(cwd));
+	return {
+		...await sourceLookups(cwd, audits),
+		...detected === void 0 ? {} : { framework: detected.framework.id }
+	};
 }
+/**
+* Where a page and a failing element were written, for the two reports that say
+* so. Best-effort: a project using no convention this recognises gets the
+* report it always got, with no source named.
+*/
 async function sourceLookups(cwd, audits) {
 	const { buildRouteMap, sourceFor } = await import("./routes-CmdRUuOs.js");
 	const routes = await buildRouteMap(cwd);
@@ -786,7 +922,7 @@ async function sourceLookups(cwd, audits) {
 		sourceFor: (page) => sourceFor(routes, page),
 		componentFor: () => void 0
 	};
-	const { buildComponentIndex, componentFor } = await import("./component-DKd3EHOg.js");
+	const { buildComponentIndex, componentFor } = await import("./component-DcCn3BJS.js");
 	const components = await buildComponentIndex(cwd);
 	return {
 		sourceFor: (page) => sourceFor(routes, page),