eaa-kit 0.2.1 → 0.4.0

package/dist/audit-CpXH2Mk8.js

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

package/dist/{baseline-CV_3lbER.js → baseline-22Y1NWxM.js}

@@ -1,2 +1,2 @@
-import { a as readBaseline, r as applyBaseline, t as BaselineError } from "./baseline-CgBmzFTr.js";
+import { a as readBaseline, r as applyBaseline, t as BaselineError } from "./baseline-DB9CZGnV.js";
 export { BaselineError, applyBaseline, readBaseline };

package/dist/{baseline-CgBmzFTr.js → baseline-DB9CZGnV.js}

@@ -1,5 +1,6 @@
-import { _ as withDefault, c as object, f as safeParse, i as isoDate$1, l as optional, o as nullable, p as string, s as number, t as array } from "./schema-CMZ8ItGk.js";
+import { a as isoDate$1, c as number, l as object, m as string, p as safeParse, s as nullable, t as array, u as optional, v as withDefault } from "./schema-is6CGX2D.js";
 import { t as elementFingerprint } from "./fingerprint-DRoneAjj.js";
+import { a as findingElements } from "./result-DoamKFsp.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. */
@@ -37,12 +38,10 @@ var BaselineError = class extends Error {
 */
 function applyBaseline(audits, baseline, options = {}) {
 	const today = isoDate(options.today ?? /* @__PURE__ */ new Date());
-	const expired = baseline.entries.filter((entry) => entry.expiresOn !== void 0 && entry.expiresOn < today);
+	const expired = [];
 	const live = /* @__PURE__ */ new Map();
-	for (const entry of baseline.entries) {
-		if (entry.expiresOn !== void 0 && entry.expiresOn < today) continue;
-		live.set(key(entry.page, entry.ruleId, entry.fingerprint), entry);
-	}
+	for (const entry of baseline.entries) if (entry.expiresOn !== void 0 && entry.expiresOn < today) expired.push(entry);
+	else live.set(key(entry.page, entry.ruleId, entry.fingerprint), entry);
 	const matched = /* @__PURE__ */ new Set();
 	let accepted = 0;
 	const next = audits.map((audit) => {
@@ -90,7 +89,7 @@ function applyBaseline(audits, baseline, options = {}) {
 	return {
 		audits: next,
 		stale: [...live.entries()].filter(([id, entry]) => !matched.has(id) && audited.has(entry.page)).map(([, entry]) => entry).sort(byEntry),
-		expired: [...expired].sort(byEntry),
+		expired: expired.sort(byEntry),
 		accepted
 	};
 }
@@ -98,26 +97,17 @@ function applyBaseline(audits, baseline, options = {}) {
 function buildBaseline(audits, options = {}) {
 	const acceptedOn = isoDate(options.today ?? /* @__PURE__ */ new Date());
 	const entries = [];
-	for (const audit of audits) for (const finding of audit.violations) {
-		const nodes = finding.nodes.length > 0 ? finding.nodes.map((node) => ({
-			selector: node.target.join(" "),
-			html: node.html
-		})) : [{
-			selector: "",
-			html: ""
-		}];
-		for (const node of nodes) entries.push({
-			page: audit.relativePath,
-			ruleId: finding.ruleId,
-			fingerprint: elementFingerprint(finding.ruleId, node.selector, node.html),
-			selector: node.selector,
-			help: finding.help,
-			impact: finding.impact ?? null,
-			acceptedOn,
-			...options.expiresOn ? { expiresOn: options.expiresOn } : {},
-			...options.note ? { note: options.note } : {}
-		});
-	}
+	for (const audit of audits) for (const finding of audit.violations) for (const node of findingElements(finding)) entries.push({
+		page: audit.relativePath,
+		ruleId: finding.ruleId,
+		fingerprint: elementFingerprint(finding.ruleId, node.selector, node.html),
+		selector: node.selector,
+		help: finding.help,
+		impact: finding.impact ?? null,
+		acceptedOn,
+		...options.expiresOn ? { expiresOn: options.expiresOn } : {},
+		...options.note ? { note: options.note } : {}
+	});
 	return {
 		schemaVersion: 1,
 		createdOn: acceptedOn,

package/dist/cli/index.js

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
-import { l as STATEMENT_LOCALES, o as COUNTRIES, r as loadConfig, s as ConfigError } from "../load-sCkKsvGQ.js";
-import { i as readAuditReport, o as StatementError, t as renderStatement } from "../render-BO0nVrrZ.js";
-import { i as isImpactLevel, n as IMPACT_LEVELS, t as DEFAULT_FAIL_ON } from "../impact-DvgBjupx.js";
+import { c as number, f as record, l as object, m as string, n as boolean, p as safeParse, s as nullable, t as array, u as optional, v as withDefault } from "../schema-is6CGX2D.js";
+import { l as STATEMENT_LOCALES, o as COUNTRIES, r as loadConfig, s as ConfigError } from "../load-5wRGLvub.js";
+import { i as readAuditReport, o as StatementError, t as renderStatement } from "../render-DrvXRCEn.js";
+import { a as impactRank, n as IMPACT_LEVELS, o as isImpactLevel, s as meetsThreshold, t as DEFAULT_FAIL_ON } from "../impact-DZt2oBCP.js";
+import { n as count, t as collapse } from "../text-CKKpzkYM.js";
 import { t as TOOL_VERSION } from "../version-B3v4rNoG.js";
-import { i as buildBaseline, n as DEFAULT_BASELINE_FILE, s as writeBaseline, t as BaselineError } from "../baseline-CgBmzFTr.js";
-import { i as resolvePages, n as isOutputFormat, r as runAuditCommand, t as OUTPUT_FORMATS } from "../audit-DXpKkXsC.js";
-import { mkdir, writeFile } from "node:fs/promises";
+import { t as elementFingerprint } from "../fingerprint-DRoneAjj.js";
+import { i as buildBaseline, n as DEFAULT_BASELINE_FILE, s as writeBaseline, t as BaselineError } from "../baseline-DB9CZGnV.js";
+import { n as runAuditCommand, r as resolvePages, t as OUTPUT_FORMATS } from "../audit-CPoZMXGM.js";
+import { a as runEngine, i as note, n as emitDocument, o as warn, r as fail, t as advise } from "../command-D8l_oYbV.js";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { Command, InvalidArgumentError } from "commander";
 import pc from "picocolors";
@@ -33,38 +37,23 @@ async function runBaselineCommand(dir, options = {}) {
 		exitCode: 2
 	};
 	const { pages, origin, label } = resolved;
-	process.stderr.write(pc.dim(`Auditing ${pages.length} ${pages.length === 1 ? "page" : "pages"} in ${label}…\n`));
-	const effectiveBaseUrl = options.baseUrl ?? origin;
-	const runnerOptions = {
+	note(`Auditing ${count(pages.length, "page")} in ${label}…`);
+	const baseUrl = options.baseUrl ?? origin;
+	const audits = await runEngine(pages, {
 		cwd,
-		...effectiveBaseUrl === void 0 ? {} : { baseUrl: effectiveBaseUrl },
-		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+		...baseUrl === void 0 ? {} : { baseUrl },
+		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+		...options.browser ? { browser: true } : {},
+		...options.concurrency === void 0 ? {} : { concurrency: options.concurrency },
+		...options.url === void 0 ? { directory: path.resolve(cwd, dir) } : {}
+	});
+	if (!audits) return {
+		entries: 0,
+		exitCode: 2
 	};
-	let audits;
-	if (options.browser) {
-		const { BrowserUnavailableError, runBrowserAudit } = await import("../playwright-DSRnXmcd.js");
-		try {
-			audits = await runBrowserAudit(options.url === void 0 ? path.resolve(cwd, dir) : void 0, pages, runnerOptions);
-		} catch (cause) {
-			if (cause instanceof BrowserUnavailableError) {
-				process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
-				return {
-					entries: 0,
-					exitCode: 2
-				};
-			}
-			throw cause;
-		}
-	} else {
-		const { runPooledAudit } = await import("../pool-DixLeu8L.js");
-		audits = await runPooledAudit(pages, {
-			...runnerOptions,
-			...options.concurrency === void 0 ? {} : { concurrency: options.concurrency }
-		});
-	}
 	const unaudited = audits.filter((audit) => audit.error);
 	if (unaudited.length > 0) {
-		process.stderr.write(`${pc.red("error")} ${unaudited.length} of ${audits.length} pages could not be audited, so no baseline was written\n`);
+		fail(`${unaudited.length} of ${audits.length} pages could not be audited, so no baseline was written`);
 		return {
 			entries: 0,
 			exitCode: 2
@@ -79,7 +68,7 @@ async function runBaselineCommand(dir, options = {}) {
 		await writeBaseline(target, baseline, cwd);
 	} catch (cause) {
 		if (cause instanceof BaselineError) {
-			process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
+			fail(cause.message);
 			return {
 				entries: 0,
 				exitCode: 2
@@ -87,21 +76,267 @@ async function runBaselineCommand(dir, options = {}) {
 		}
 		throw cause;
 	}
-	const count = baseline.entries.length;
-	process.stderr.write(pc.dim(`Wrote ${count} ${count === 1 ? "entry" : "entries"} to ${target}\n`));
-	if (count > 0) process.stderr.write(pc.yellow("These are barriers, not exceptions. Commit the file, then work the list down.\n"));
+	const entries = baseline.entries.length;
+	note(`Wrote ${entries} ${entries === 1 ? "entry" : "entries"} to ${target}`);
+	if (entries > 0) advise("These are barriers, not exceptions. Commit the file, then work the list down.");
 	return {
-		entries: count,
+		entries,
 		exitCode: 0
 	};
 }
+var DiffError = class extends Error {
+	name = "DiffError";
+};
+/**
+* Only the fields a comparison reads. `completeness` is optional: a report
+* written before it existed says nothing about coverage, which is not the same
+* as saying the run was complete, and is handled as the unknown it is.
+*/
+const reportSchema = object({
+	schemaVersion: number(),
+	generatedAt: string(),
+	target: withDefault(object({ source: withDefault(string(), () => "") }), () => ({ source: "" })),
+	completeness: optional(object({
+		complete: boolean(),
+		audited: withDefault(number(), () => 0)
+	})),
+	rules: withDefault(record(object({ help: withDefault(string(), () => "") })), () => ({})),
+	pages: withDefault(array(object({
+		path: string(),
+		error: withDefault(nullable(string()), () => null),
+		violations: withDefault(array(object({
+			ruleId: string(),
+			impact: withDefault(nullable(string()), () => null),
+			nodes: withDefault(array(object({
+				html: withDefault(string(), () => ""),
+				target: withDefault(array(string()), () => [])
+			})), () => [])
+		})), () => [])
+	})), () => [])
+});
+/**
+* The elements a violation points at.
+*
+* Mirrors `findingElements` for the JSON shape, including its one subtlety: a
+* rule can fail with no element attached, and it still has an identity. Getting
+* this wrong here would make document-level failures invisible to a diff while
+* remaining visible to the baseline.
+*/
+function elementsOf(violation) {
+	if (violation.nodes.length === 0) return [{
+		selector: "",
+		html: ""
+	}];
+	return violation.nodes.map((node) => ({
+		selector: node.target.join(" "),
+		html: node.html
+	}));
+}
+/** Every violating element in a report, keyed by page and element identity. */
+function entriesOf(report) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const page of report.pages) for (const violation of page.violations) {
+		const impact = violation.impact !== null && isImpactLevel(violation.impact) ? violation.impact : null;
+		for (const { selector, html } of elementsOf(violation)) {
+			const fingerprint = elementFingerprint(violation.ruleId, selector, html);
+			const key = `${page.path}\n${fingerprint}`;
+			if (entries.has(key)) continue;
+			entries.set(key, {
+				page: page.path,
+				ruleId: violation.ruleId,
+				fingerprint,
+				impact,
+				help: report.rules[violation.ruleId]?.help ?? violation.ruleId,
+				selector,
+				html
+			});
+		}
+	}
+	return entries;
+}
+/** Pages a run reached a verdict on. A page that errored is not one of them. */
+function auditedPages(report) {
+	return new Set(report.pages.filter((page) => page.error === null).map((page) => page.path));
+}
+function sideOf(report) {
+	return {
+		source: report.target.source,
+		generatedAt: report.generatedAt,
+		audited: report.completeness?.audited ?? auditedPages(report).size,
+		complete: report.completeness?.complete
+	};
+}
+/** Worst first, then by page, so two runs of one comparison agree. */
+function bySeverityThenPage(a, b) {
+	return impactRank(a.impact) - impactRank(b.impact) || a.page.localeCompare(b.page) || a.ruleId.localeCompare(b.ruleId) || a.selector.localeCompare(b.selector);
+}
+/** Compare two parsed reports, earlier first. */
+function diffReports(base, head) {
+	const before = entriesOf(base);
+	const after = entriesOf(head);
+	const measuredByHead = auditedPages(head);
+	const added = [];
+	const fixed = [];
+	const unchanged = [];
+	const unmeasured = [];
+	for (const [key, entry] of after) if (before.has(key)) unchanged.push(entry);
+	else added.push(entry);
+	for (const [key, entry] of before) {
+		if (after.has(key)) continue;
+		if (measuredByHead.has(entry.page)) fixed.push(entry);
+		else unmeasured.push(entry);
+	}
+	return {
+		base: sideOf(base),
+		head: sideOf(head),
+		added: added.sort(bySeverityThenPage),
+		fixed: fixed.sort(bySeverityThenPage),
+		unchanged: unchanged.sort(bySeverityThenPage),
+		unmeasured: unmeasured.sort(bySeverityThenPage)
+	};
+}
+/**
+* Read a JSON report from disk.
+*
+* Refuses a schema version it was not written against rather than reading it
+* optimistically: a field that changed meaning is exactly what the version
+* number exists to signal, and a diff built on a misread field would be wrong
+* quietly.
+*/
+async function readReport(file, cwd = process.cwd()) {
+	const target = path.resolve(cwd, file);
+	let raw;
+	try {
+		raw = await readFile(target, "utf8");
+	} catch {
+		throw new DiffError(`Report not found: ${file}`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (cause) {
+		throw new DiffError(`${file} is not valid JSON (${cause.message})`);
+	}
+	const result = safeParse(reportSchema, parsed);
+	if (!result.success) {
+		const first = result.error.issues[0];
+		throw new DiffError(`${file} is not an eaa-kit JSON report${first === void 0 || first.path.length === 0 ? "" : ` at ${first.path.join(".")}`}: ${first?.message ?? "unrecognised shape"}`);
+	}
+	if (result.data.schemaVersion !== 1) throw new DiffError(`${file} is schemaVersion ${result.data.schemaVersion}; this version of eaa-kit reads 1`);
+	return result.data;
+}
+//#endregion
+//#region src/cli/diff.ts
+/**
+* `eaa-kit diff <before.json> <after.json>`.
+*
+* What a change did to a site's accessibility, which is the question a review
+* actually asks and which neither report answers on its own. Running the
+* auditor on a branch prints everything wrong with the site; almost all of it
+* was already there, and the two or three findings somebody introduced are
+* somewhere in the middle of it.
+*
+* Deliberately stateless. A baseline is a file somebody commits and maintains,
+* and it answers "what have we agreed to live with". This answers "what did
+* this change do", needs no file and no decision, and can be run over any two
+* reports after the fact.
+*/
+const DIFF_FORMATS = ["console", "json"];
+/** Longest element markup shown before it is truncated. */
+const MAX_SNIPPET = 100;
+async function runDiffCommand(base, head, options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	let diff;
+	try {
+		diff = diffReports(await readReport(base, cwd), await readReport(head, cwd));
+	} catch (cause) {
+		if (cause instanceof DiffError) {
+			fail(cause.message);
+			return { exitCode: 2 };
+		}
+		throw cause;
+	}
+	const failOn = options.failOn ?? "serious";
+	const failing = diff.added.filter((entry) => meetsThreshold(entry.impact, failOn));
+	const body = (options.format ?? "console") === "json" ? `${JSON.stringify(toJson(diff, failOn, failing.length), null, 2)}\n` : `${formatDiff(diff, failOn, options.output === void 0)}\n`;
+	await emitDocument(body, options.output, cwd);
+	if (options.output !== void 0) note(`Diff written to ${options.output}`);
+	if (diff.unmeasured.length > 0) warn(`${count(diff.unmeasured.length, "violation")} could not be compared: the later run did not audit ${diff.unmeasured.length === 1 ? "its page" : "their pages"}`);
+	return {
+		diff,
+		exitCode: failing.length > 0 ? 1 : 0
+	};
+}
+/**
+* The machine-readable form.
+*
+* `unchanged` is counted and not listed: it is the whole of the pre-existing
+* report, it is already available in the report itself, and repeating it here
+* would make the common case — a diff with three entries — a document nobody
+* can read.
+*/
+function toJson(diff, failOn, failing) {
+	return {
+		base: diff.base,
+		head: diff.head,
+		summary: {
+			added: diff.added.length,
+			fixed: diff.fixed.length,
+			unchanged: diff.unchanged.length,
+			unmeasured: diff.unmeasured.length,
+			failOn,
+			failing
+		},
+		added: diff.added,
+		fixed: diff.fixed,
+		unmeasured: diff.unmeasured
+	};
+}
+function formatDiff(diff, failOn, colour = true) {
+	const c = pc.createColors(colour);
+	const lines = [""];
+	lines.push(c.bold("eaa-kit diff"));
+	lines.push(c.dim(`  before  ${describe(diff.base)}`));
+	lines.push(c.dim(`  after   ${describe(diff.head)}`));
+	lines.push("");
+	if (diff.added.length === 0 && diff.fixed.length === 0) lines.push(c.green("No change in violations."));
+	if (diff.added.length > 0) {
+		lines.push(c.red(c.bold(`New (${diff.added.length})`)));
+		lines.push(...diff.added.map((entry) => entryLine(entry, c)));
+		lines.push("");
+	}
+	if (diff.fixed.length > 0) {
+		lines.push(c.green(c.bold(`Fixed (${diff.fixed.length})`)));
+		lines.push(...diff.fixed.map((entry) => entryLine(entry, c)));
+		lines.push("");
+	}
+	if (diff.unmeasured.length > 0) {
+		lines.push(c.yellow(c.bold(`Not compared (${diff.unmeasured.length})`)));
+		lines.push(c.dim("  These failed before, and the later run did not audit the page they were on."));
+		lines.push(...diff.unmeasured.map((entry) => entryLine(entry, c)));
+		lines.push("");
+	}
+	const failing = diff.added.filter((entry) => meetsThreshold(entry.impact, failOn)).length;
+	lines.push(c.bold("Summary"));
+	lines.push(`  ${diff.added.length} new · ${diff.fixed.length} fixed · ${diff.unchanged.length} unchanged`);
+	lines.push(failing > 0 ? c.red(`  ${failing} new at or above ${failOn} (--fail-on ${failOn})`) : c.green(`  no new violations at or above ${failOn} (--fail-on ${failOn})`));
+	return lines.join("\n");
+}
+function describe(side) {
+	const source = side.source === "" ? "unknown source" : side.source;
+	const coverage = side.complete === void 0 ? "coverage not recorded" : side.complete ? "complete" : "incomplete";
+	return `${source} · ${count(side.audited, "page")} · ${coverage} · ${side.generatedAt}`;
+}
+function entryLine(entry, c) {
+	const where = entry.selector === "" ? entry.page : `${entry.page} ${c.dim(entry.selector)}`;
+	const impact = entry.impact ?? "unclassified";
+	const snippet = entry.html === "" ? "" : `\n      ${c.dim(collapse(entry.html, MAX_SNIPPET))}`;
+	return `  ${c.bold(entry.ruleId)} ${c.dim(`(${impact})`)} — ${entry.help}\n    ${where}${snippet}`;
+}
 //#endregion
 //#region src/cli/statement.ts
 /** Markdown for a content directory, HTML for dropping straight onto a site. */
 const STATEMENT_FORMATS = ["markdown", "html"];
-function isStatementFormat(value) {
-	return STATEMENT_FORMATS.includes(value);
-}
 /**
 * `eaa-kit statement`.
 *
@@ -122,19 +357,16 @@ async function runStatementCommand(options = {}) {
 			...options.country ? { country: options.country } : {},
 			...audit ? { audit } : {}
 		});
-		process.stderr.write(pc.dim(`Statement for ${config.site.url} from ${path.basename(configPath)} (${statement.template}, ${format})\n`));
+		note(`Statement for ${config.site.url} from ${path.basename(configPath)} (${statement.template}, ${format})`);
 		if (audit) {
-			process.stderr.write(pc.dim(`${audit.findings.length} ${audit.findings.length === 1 ? "barrier" : "barriers"} taken from ${path.basename(options.audit ?? "")}\n`));
-			if (audit.findings.length > 0) process.stderr.write(pc.yellow("Rewrite those descriptions in your own words before publishing.\n"));
+			const from = path.basename(options.audit ?? "");
+			note(`${count(audit.findings.length, "barrier")} taken from ${from}`);
+			if (audit.findings.length > 0) advise("Rewrite those descriptions in your own words before publishing.");
 		}
 		const document = format === "html" ? statement.html : statement.markdown;
-		if (options.output) {
-			const target = path.resolve(options.cwd ?? process.cwd(), options.output);
-			await mkdir(path.dirname(target), { recursive: true });
-			await writeFile(target, document, "utf8");
-			process.stderr.write(pc.dim(`Written to ${options.output}\n`));
-		} else process.stdout.write(document);
-		process.stderr.write(pc.yellow("Review before publishing. This is a draft, not legal advice.\n"));
+		await emitDocument(document, options.output, options.cwd ?? process.cwd());
+		if (options.output !== void 0) note(`Written to ${options.output}`);
+		advise("Review before publishing. This is a draft, not legal advice.");
 		return {
 			document,
 			format,
@@ -142,8 +374,8 @@ async function runStatementCommand(options = {}) {
 		};
 	} catch (cause) {
 		if (cause instanceof ConfigError || cause instanceof StatementError) {
-			process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
-			if (cause instanceof ConfigError) for (const issue of cause.issues) process.stderr.write(pc.dim(`  ${issue}\n`));
+			fail(cause.message);
+			if (cause instanceof ConfigError) for (const issue of cause.issues) note(`  ${issue}`);
 			return {
 				document: "",
 				format,
@@ -163,109 +395,71 @@ function formatFor(output) {
 }
 //#endregion
 //#region src/cli/index.ts
+/**
+* A parser for a fixed set of words, listing them when the answer is not one.
+*
+* `normalise` is for `--country de`, where the accepted spelling differs from
+* what somebody types.
+*/
+function oneOf(values, normalise = (value) => value) {
+	return (value) => {
+		const candidate = normalise(value);
+		if (!values.includes(candidate)) throw new InvalidArgumentError(`expected one of ${values.join(", ")}`);
+		return candidate;
+	};
+}
+/** A whole number no smaller than `min`. Depth allows 0: audit the entry page alone. */
+function wholeNumber(min) {
+	return (value) => {
+		const parsed = Number(value);
+		if (!Number.isInteger(parsed) || parsed < min) throw new InvalidArgumentError(`expected a whole number of ${min} or more`);
+		return parsed;
+	};
+}
+function parseDate(value) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || Number.isNaN(Date.parse(`${value}T00:00:00Z`))) throw new InvalidArgumentError("expected an ISO date, e.g. 2026-12-31");
+	return value;
+}
+const parseLocale = oneOf(STATEMENT_LOCALES);
+const parseCountry = oneOf(COUNTRIES, (value) => value.toUpperCase());
+const parseStatementFormat = oneOf(STATEMENT_FORMATS);
+const parseImpact = oneOf(IMPACT_LEVELS);
+const parseFormat = oneOf(OUTPUT_FORMATS);
+const parsePositive = wholeNumber(1);
+const parseDepth = wholeNumber(0);
+const parseConcurrency = wholeNumber(1);
 const program = new Command();
 program.exitOverride();
 program.name("eaa-kit").description("WCAG 2.2 AA auditor and EU accessibility statement generator for static sites.\nNot legal advice.").version(TOOL_VERSION, "-v, --version");
-program.command("audit").description("Audit built HTML against WCAG 2.2 AA").argument("[dir]", "directory holding the built site (default: found automatically)").option("--include <globs...>", "glob patterns to audit, relative to dir").option("--exclude <globs...>", "glob patterns to skip").option("--base-url <url>", "audit pages under their real site URL").option("--url <url>", "audit a running site instead of a build directory").option("--no-build", "never run the project build or start its server").option("--per-page", "also list every page and its result").option("--allow-remote", "allow --url to crawl a host that is not localhost").option("--ignore-robots", "crawl paths robots.txt disallows").option("--max-pages <n>", "stop the crawl after this many pages", parsePositive).option("--max-depth <n>", "how far from the entry URL to follow links", parseDepth).option("--fail-on <impact>", `exit 1 on violations at or above this impact (${IMPACT_LEVELS.join("|")})`, parseImpact, DEFAULT_FAIL_ON).option("--format <format>", `output format (${OUTPUT_FORMATS.join("|")})`, parseFormat, "console").option("--output <path>", "write the report to a file instead of stdout").option("--browser", "audit in real Chromium, covering the rules jsdom cannot evaluate").option("--concurrency <n>", "worker threads to audit with, or 1 for none (default: from the page and core count)", parseConcurrency).option("--baseline <path>", "accept the violations recorded in this file; fail only on new ones").action(async (dir, options) => {
+program.command("audit").description("Audit built HTML against WCAG 2.2 AA").argument("[dir]", "directory holding the built site (default: found automatically)").option("--include <globs...>", "glob patterns to audit, relative to dir").option("--exclude <globs...>", "glob patterns to skip").option("--base-url <url>", "audit pages under their real site URL").option("--url <url>", "audit a running site instead of a build directory").option("--no-build", "never run the project build or start its server").option("--per-page", "also list every page and its result").option("--manual", "what to check by hand for the rules this engine cannot evaluate").option("--coverage", "list every WCAG 2.2 A/AA criterion and what this run reached on it").option("--allow-remote", "allow --url to crawl a host that is not localhost").option("--ignore-robots", "crawl paths robots.txt disallows").option("--sitemap <path>", "where the site lists its pages, if not /sitemap.xml").option("--max-pages <n>", "stop the crawl after this many pages", parsePositive).option("--max-depth <n>", "how far from the entry URL to follow links", parseDepth).option("--fail-on <impact>", `exit 1 on violations at or above this impact (${IMPACT_LEVELS.join("|")})`, parseImpact, DEFAULT_FAIL_ON).option("--format <format>", `output format (${OUTPUT_FORMATS.join("|")})`, parseFormat, "console").option("--output <path>", "write the report to a file instead of stdout").option("--browser", "audit in real Chromium, covering the rules jsdom cannot evaluate").option("--concurrency <n>", "worker threads to audit with, or 1 for none (default: from the page and core count)", parseConcurrency).option("--baseline <path>", "accept the violations recorded in this file; fail only on new ones").action(async (dir, flags) => {
+	const { build, ...options } = flags;
 	const { exitCode } = await runAuditCommand(dir, {
-		...options["build"] === false ? { noBuild: true } : {},
-		...options["perPage"] === true ? { perPage: true } : {},
-		...Array.isArray(options["include"]) ? { include: options["include"] } : {},
-		...Array.isArray(options["exclude"]) ? { exclude: options["exclude"] } : {},
-		...typeof options["baseUrl"] === "string" ? { baseUrl: options["baseUrl"] } : {},
-		failOn: options["failOn"],
-		format: options["format"],
-		...typeof options["output"] === "string" ? { output: options["output"] } : {},
-		...options["browser"] === true ? { browser: true } : {},
-		...typeof options["concurrency"] === "number" ? { concurrency: options["concurrency"] } : {},
-		...typeof options["baseline"] === "string" ? { baseline: options["baseline"] } : {},
-		...typeof options["url"] === "string" ? { url: options["url"] } : {},
-		...options["allowRemote"] === true ? { allowRemote: true } : {},
-		...options["ignoreRobots"] === true ? { ignoreRobots: true } : {},
-		...typeof options["maxPages"] === "number" ? { maxPages: options["maxPages"] } : {},
-		...typeof options["maxDepth"] === "number" ? { maxDepth: options["maxDepth"] } : {}
+		...options,
+		...build === false ? { noBuild: true } : {}
 	});
 	process.exitCode = exitCode;
 });
-program.command("baseline").description("Record the violations a build already has, so later runs fail only on new ones").argument("[dir]", "directory holding the built site", "./dist").option("--include <globs...>", "glob patterns to audit, relative to dir").option("--exclude <globs...>", "glob patterns to skip").option("--base-url <url>", "audit pages under their real site URL").option("--url <url>", "record a baseline from a running site instead of a directory").option("--allow-remote", "allow --url to crawl a host that is not localhost").option("--ignore-robots", "crawl paths robots.txt disallows").option("--max-pages <n>", "stop the crawl after this many pages", parsePositive).option("--max-depth <n>", "how far from the entry URL to follow links", parseDepth).option("--output <path>", `where to write it (default: ${DEFAULT_BASELINE_FILE})`).option("--note <text>", "recorded on every entry, for whoever reads the file").option("--expires-on <date>", "ISO date after which the entries stop suppressing", parseDate).option("--browser", "audit in real Chromium instead of jsdom").option("--concurrency <n>", "worker threads to audit with, or 1 for none", parseConcurrency).action(async (dir, options) => {
-	const { exitCode } = await runBaselineCommand(dir, {
-		...Array.isArray(options["include"]) ? { include: options["include"] } : {},
-		...Array.isArray(options["exclude"]) ? { exclude: options["exclude"] } : {},
-		...typeof options["baseUrl"] === "string" ? { baseUrl: options["baseUrl"] } : {},
-		...typeof options["output"] === "string" ? { output: options["output"] } : {},
-		...typeof options["note"] === "string" ? { note: options["note"] } : {},
-		...typeof options["expiresOn"] === "string" ? { expiresOn: options["expiresOn"] } : {},
-		...options["browser"] === true ? { browser: true } : {},
-		...typeof options["concurrency"] === "number" ? { concurrency: options["concurrency"] } : {},
-		...typeof options["url"] === "string" ? { url: options["url"] } : {},
-		...options["allowRemote"] === true ? { allowRemote: true } : {},
-		...options["ignoreRobots"] === true ? { ignoreRobots: true } : {},
-		...typeof options["maxPages"] === "number" ? { maxPages: options["maxPages"] } : {},
-		...typeof options["maxDepth"] === "number" ? { maxDepth: options["maxDepth"] } : {}
-	});
+program.command("baseline").description("Record the violations a build already has, so later runs fail only on new ones").argument("[dir]", "directory holding the built site", "./dist").option("--include <globs...>", "glob patterns to audit, relative to dir").option("--exclude <globs...>", "glob patterns to skip").option("--base-url <url>", "audit pages under their real site URL").option("--url <url>", "record a baseline from a running site instead of a directory").option("--allow-remote", "allow --url to crawl a host that is not localhost").option("--ignore-robots", "crawl paths robots.txt disallows").option("--sitemap <path>", "where the site lists its pages, if not /sitemap.xml").option("--max-pages <n>", "stop the crawl after this many pages", parsePositive).option("--max-depth <n>", "how far from the entry URL to follow links", parseDepth).option("--output <path>", `where to write it (default: ${DEFAULT_BASELINE_FILE})`).option("--note <text>", "recorded on every entry, for whoever reads the file").option("--expires-on <date>", "ISO date after which the entries stop suppressing", parseDate).option("--browser", "audit in real Chromium instead of jsdom").option("--concurrency <n>", "worker threads to audit with, or 1 for none", parseConcurrency).action(async (dir, flags) => {
+	const { exitCode } = await runBaselineCommand(dir, flags);
 	process.exitCode = exitCode;
 });
-program.command("init").description("Write an eaa.config.json to generate statements from").option("--output <path>", "write here instead of eaa.config.json").option("--force", "overwrite a config that is already there").option("-y, --yes", "take every default without asking").action(async (options) => {
-	const { runInitCommand } = await import("../init-DRKIdpK1.js");
-	const { exitCode } = await runInitCommand({
-		...typeof options["output"] === "string" ? { output: options["output"] } : {},
-		...options["force"] === true ? { force: true } : {},
-		...options["yes"] === true ? { yes: true } : {}
-	});
+program.command("diff").description("Compare two JSON reports: what a change made worse, and what it fixed").argument("<before>", "JSON report from before the change").argument("<after>", "JSON report from after it").option("--format <format>", `output format (${DIFF_FORMATS.join("|")})`, oneOf(DIFF_FORMATS)).option("--output <path>", "write the diff here instead of stdout").option("--fail-on <impact>", `exit 1 on NEW violations at or above this impact (${IMPACT_LEVELS.join("|")})`, parseImpact, DEFAULT_FAIL_ON).action(async (before, after, flags) => {
+	const { exitCode } = await runDiffCommand(before, after, flags);
+	process.exitCode = exitCode;
+});
+program.command("init").description("Write an eaa.config.json to generate statements from").option("--output <path>", "write here instead of eaa.config.json").option("--force", "overwrite a config that is already there").option("-y, --yes", "take every default without asking").action(async (flags) => {
+	const { runInitCommand } = await import("../init-DIWDE35F.js");
+	const { exitCode } = await runInitCommand(flags);
 	process.exitCode = exitCode;
 });
-program.command("statement").description("Generate an EU accessibility statement from eaa.config").option("--config <path>", "path to the config file, otherwise it is searched for").option("--lang <locale>", `statement language (${STATEMENT_LOCALES.join("|")})`, parseLocale).option("--country <code>", `override the country template (${COUNTRIES.join("|")})`, parseCountry).option("--audit <path>", "list the barriers from an eaa-kit audit --format json report").option("--format <format>", `output format (${STATEMENT_FORMATS.join("|")}), otherwise from the --output extension`, parseStatementFormat).option("--output <path>", "write the statement to a file instead of stdout").action(async (options) => {
+program.command("statement").description("Generate an EU accessibility statement from eaa.config").option("--config <path>", "path to the config file, otherwise it is searched for").option("--lang <locale>", `statement language (${STATEMENT_LOCALES.join("|")})`, parseLocale).option("--country <code>", `override the country template (${COUNTRIES.join("|")})`, parseCountry).option("--audit <path>", "list the barriers from an eaa-kit audit --format json report").option("--format <format>", `output format (${STATEMENT_FORMATS.join("|")}), otherwise from the --output extension`, parseStatementFormat).option("--output <path>", "write the statement to a file instead of stdout").action(async (flags) => {
+	const { lang, ...options } = flags;
 	const { exitCode } = await runStatementCommand({
-		...typeof options["config"] === "string" ? { config: options["config"] } : {},
-		...options["lang"] ? { locale: options["lang"] } : {},
-		...options["country"] ? { country: options["country"] } : {},
-		...typeof options["audit"] === "string" ? { audit: options["audit"] } : {},
-		...options["format"] ? { format: options["format"] } : {},
-		...typeof options["output"] === "string" ? { output: options["output"] } : {}
+		...options,
+		...lang === void 0 ? {} : { locale: lang }
 	});
 	process.exitCode = exitCode;
 });
-function parseLocale(value) {
-	if (!STATEMENT_LOCALES.includes(value)) throw new InvalidArgumentError(`expected one of ${STATEMENT_LOCALES.join(", ")}`);
-	return value;
-}
-function parseCountry(value) {
-	const upper = value.toUpperCase();
-	if (!COUNTRIES.includes(upper)) throw new InvalidArgumentError(`expected one of ${COUNTRIES.join(", ")}`);
-	return upper;
-}
-function parseStatementFormat(value) {
-	if (!isStatementFormat(value)) throw new InvalidArgumentError(`expected one of ${STATEMENT_FORMATS.join(", ")}`);
-	return value;
-}
-function parseDate(value) {
-	if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || Number.isNaN(Date.parse(`${value}T00:00:00Z`))) throw new InvalidArgumentError("expected an ISO date, e.g. 2026-12-31");
-	return value;
-}
-function parsePositive(value) {
-	const parsed = Number(value);
-	if (!Number.isInteger(parsed) || parsed < 1) throw new InvalidArgumentError("expected a whole number of 1 or more");
-	return parsed;
-}
-/** Depth 0 is meaningful here: audit only the entry page. */
-function parseDepth(value) {
-	const parsed = Number(value);
-	if (!Number.isInteger(parsed) || parsed < 0) throw new InvalidArgumentError("expected a whole number of 0 or more");
-	return parsed;
-}
-function parseConcurrency(value) {
-	const parsed = Number(value);
-	if (!Number.isInteger(parsed) || parsed < 1) throw new InvalidArgumentError("expected a whole number of 1 or more");
-	return parsed;
-}
-function parseImpact(value) {
-	if (!isImpactLevel(value)) throw new InvalidArgumentError(`expected one of ${IMPACT_LEVELS.join(", ")}`);
-	return value;
-}
-function parseFormat(value) {
-	if (!isOutputFormat(value)) throw new InvalidArgumentError(`expected one of ${OUTPUT_FORMATS.join(", ")}`);
-	return value;
-}
 try {
 	await program.parseAsync(process.argv);
 } catch (cause) {