eaa-kit 0.6.0 → 0.7.0

package/README.md

@@ -9,11 +9,19 @@ in the DACH region — the BFSG in Germany, the BaFG in Austria — and the stat
 the statute and supervisory body of **seven countries**: Austria, Germany, Switzerland,
 Spain, France, Italy and the Netherlands, each in its own language as well as English.
 
-0.6.0 adds the half no engine can do. Of the 55 WCAG 2.2 A and AA success criteria, 34 have
-no automated rule at all: `checklist` writes those down as a review somebody works through,
-`audit --review` reads the answers back beside what the run measured, and `statement` now
-refuses to publish a claim of full conformance that either one contradicts. Sites behind a
-login or a preview protection are auditable too.
+0.7.0 makes a run cost what it should. A page that has not changed byte for byte is not
+audited again, and a run with nothing to re-audit never loads an engine at all: twenty
+pages go from ~2,520 ms to ~230 ms, which is about what starting the process costs. A
+reused result is never passed off as a fresh one — every report says how much was reused
+and from when, and `diff` will not call a page fixed that this run did not look at. The
+statement now also says how many of WCAG's 55 criteria a person checked by hand, and
+`pnpm bench` prints the numbers in this paragraph for your own machine.
+
+0.6.0 added the half no engine can do. Of the 55 WCAG 2.2 A and AA success criteria, 34
+have no automated rule at all: `checklist` writes those down as a review somebody works
+through, `audit --review` reads the answers back beside what the run measured, and
+`statement` refuses to publish a claim of full conformance that either one contradicts.
+Sites behind a login or a preview protection are auditable too.
 
 ```bash
 npx eaa-kit audit                 # WCAG 2.2 AA report; finds your build itself
@@ -114,13 +122,20 @@ eaa-kit audit --review eaa-review.json --coverage
 ```
 
 **Says how much of WCAG it could reach.** WCAG 2.2 has 55 success criteria at Levels A and
-AA. axe-core has rules touching 23 of them. Every run says so, and `--coverage` lists all
-55 with what this run reached on each — never as a percentage, because most of WCAG cannot
-be automated and a score would present that as a fact about your site.
+AA. This tool has rules for 21 of them, and 34 need a person. Every run says so, and
+`--coverage` lists all 55 with what this run reached on each — never as a percentage,
+because most of WCAG cannot be automated and a score would present that as a fact about
+your site.
 
 **Says what it did not measure.** A crawl that stopped at its page limit, or could not
 fetch forty URLs, no longer produces a report that looks like a complete one.
 
+**Audits only what changed.** A page whose markup is byte-identical to the last run's keeps
+the result it already had, and a run with nothing to re-audit never loads an engine —
+twenty pages in ~230 ms instead of ~2,520 ms, which is about what starting the process
+costs. Reuse is counted apart from auditing in all four reports, and `diff` will not call a
+page fixed that this run did not look at. `--no-cache` audits everything regardless.
+
 **Reports in four shapes**: a console report for whoever ran it, JSON for other tools,
 SARIF for GitHub code scanning, and a self-contained HTML page for the client whose site
 it is.

package/dist/astro/index.d.ts

@@ -1,4 +1,4 @@
-import { n as IntegrationOptions } from "../run-YiqyQA2b.js";
+import { n as IntegrationOptions } from "../run-BK2blxMI.js";
 //#region src/astro/index.d.ts
 /**
  * An Astro integration that audits the build Astro just produced.

package/dist/astro/index.js

@@ -1,4 +1,4 @@
-import { n as auditBuild, t as BuildAuditError } from "../run-D7hdVXLA.js";
+import { n as auditBuild, t as BuildAuditError } from "../run-DrS0Komf.js";
 import { fileURLToPath } from "node:url";
 //#region src/astro/index.ts
 var AstroAuditError = class extends Error {

package/dist/audit/runners/worker.js

@@ -1,4 +1,4 @@
-import { t as auditPage } from "../../jsdom-CQar6OQS.js";
+import { t as auditPage } from "../../jsdom-CsW_xVcA.js";
 import { enableCompileCache } from "node:module";
 import { parentPort, workerData } from "node:worker_threads";
 //#region src/audit/runners/worker.ts

package/dist/audit-Bwm1xBdJ.js

@@ -0,0 +1,2 @@
+import { n as runAuditCommand } from "./audit-DRjAY2iY.js";
+export { runAuditCommand };

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

@@ -1,12 +1,13 @@
 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 { c as runEngine } from "./result-DfUru6y_.js";
-import { a as emitDocument, c as runEngine$1, l as warn, o as fail, s as note, t as advise } from "./command-CZKp9Wi_.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 { i as reviewSummary, n as buildCoverage, o as manualCheckFor, r as coverageSummary, s as understandingUrl } from "./coverage-BD2_CYns.js";
-import { a as blindRules, c as isShared, i as remediationFor, l as issueTotals, o as coverageParts, r as runCompleteness, s as groupIssues } from "./completeness-Dwq3CPB3.js";
-import { n as buildSummary } from "./json-PNg6BeXp.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";
@@ -77,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) {
@@ -90,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 = runEngine(audits) === "browser" ? "chromium" : "jsdom (browserless)";
-	return [render(ctx, [{
+	return [render$1(ctx, [{
 		text: "eaa-kit audit",
 		paint: ctx.c.bold
 	}, {
@@ -118,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 [...audit.violations].sort(byImpactThenRule)) 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.incomplete.filter((item) => item.reason === "needs-review")) lines.push(render$1(ctx, [
 		{
 			text: `  ${ctx.symbol("review")} `,
 			paint: ctx.c.yellow
@@ -141,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
 		}, {
@@ -162,7 +163,7 @@ function coverageLine(audit, ctx) {
 }
 function violationLines(finding, ctx) {
 	const impact = impactLabel(finding.impact);
-	const lines = [render(ctx, [
+	const lines = [render$1(ctx, [
 		{
 			text: `  ${ctx.symbol("violation")} `,
 			paint: ctx.c.red
@@ -195,7 +196,7 @@ function summary(audits, ctx) {
 		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, [{
+		lines.push(render$1(ctx, [{
 			text: `  ${count(totals.violations, "violation")} on ${totals.pagesWithViolations} of ${count(audited, "page")}`,
 			paint: ctx.c.red
 		}, {
@@ -239,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
@@ -274,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";
@@ -309,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 },
 			{
@@ -356,7 +359,7 @@ function issuesSection(audits, ctx) {
 	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,
@@ -397,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) }]));
@@ -408,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 ? [] : [{
@@ -496,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,
@@ -515,6 +513,22 @@ 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
@@ -549,12 +563,11 @@ 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) {
@@ -569,10 +582,7 @@ async function crawlPages(url, options) {
 		completeness: {
 			discovery: result.discovery,
 			collected: result.pages.length,
-			unreachable: [...result.failures.map((failure) => ({
-				location: failure.url,
-				reason: failure.reason
-			})), ...collapsed.map((redirect) => ({
+			unreachable: [...failed, ...collapsed.map((redirect) => ({
 				location: redirect.requested,
 				reason: `answered at ${redirect.landedOn} instead, so this page was not audited`
 			}))],
@@ -639,9 +649,11 @@ async function runAuditCommand(dir, options = {}) {
 	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$1(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 },
@@ -651,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);
@@ -688,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
@@ -696,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-BscHfFSW.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`);
@@ -749,25 +828,29 @@ async function loadReview(options) {
 */
 async function describeEngine(pages, options) {
 	if (options.browser) return " with Chromium";
-	const { plannedWorkers } = await import("./pool-dkexq5xo.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, review) {
-	const body = await renderReport(audits, dir, failOn, completeness, options.format ?? "console", typeof options.output === "string", 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, review) {
-	switch (format) {
+async function render(audits, dir, failOn, completeness, toFile, options, review) {
+	switch (options.format ?? "console") {
 		case "json": {
-			const { buildJsonReport, serialiseJsonReport } = await import("./json-HJDgJp09.js");
+			const { buildJsonReport, serialiseJsonReport } = await import("./json-CrQmoTj6.js");
 			return serialiseJsonReport(buildJsonReport(audits, {
 				directory: dir,
 				...options.url === void 0 ? {} : { sourceKind: "url" },
@@ -778,7 +861,7 @@ async function renderReport(audits, dir, failOn, completeness, format, toFile, o
 			}));
 		}
 		case "sarif": {
-			const { buildSarifReport, serialiseSarifReport } = await import("./sarif-BKvq_AUm.js");
+			const { buildSarifReport, serialiseSarifReport } = await import("./sarif-BNCE0PNT.js");
 			return serialiseSarifReport(buildSarifReport(audits, {
 				directory: dir,
 				completeness,
@@ -786,46 +869,52 @@ async function renderReport(audits, dir, failOn, completeness, format, toFile, o
 			}));
 		}
 		case "html": {
-			const { buildHtmlReport } = await import("./html-Bmh7X_sM.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,
 				...review === void 0 ? {} : { review },
-				...framework === void 0 ? {} : { framework },
 				...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,
-				...review === void 0 ? {} : { review },
-				...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);

package/dist/{baseline-D2qWmUC6.js → baseline-BpE7DbDq.js}

@@ -1,7 +1,7 @@
 import { c as nullable, d as optional, h as string, l as number, m as safeParse, o as isoDate, t as array, u as object, y as withDefault } from "./schema-DJSF4K05.js";
 import { a as isoDate$1 } from "./text-BF1LHMiV.js";
 import { t as elementFingerprint } from "./fingerprint-BjYV_0F7.js";
-import { o as findingElements } from "./result-DfUru6y_.js";
+import { s as findingElements } from "./result-B7_zVxAX.js";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 /** Default filename, used by the CLI when no path is given. */

package/dist/{baseline-BscHfFSW.js → baseline-rtnj3RHB.js}

@@ -1,2 +1,2 @@
-import { o as readBaseline, r as applyBaseline, t as BaselineError } from "./baseline-D2qWmUC6.js";
+import { o as readBaseline, r as applyBaseline, t as BaselineError } from "./baseline-BpE7DbDq.js";
 export { BaselineError, applyBaseline, readBaseline };