eaa-kit 0.4.0 → 0.6.0

package/dist/{pool-BMevaLWD.js → pool-dkexq5xo.js}

@@ -1,5 +1,5 @@
 import { r as isFile } from "./fs-BmPtmFke.js";
-import { i as failedPage, o as pageUrl } from "./result-DoamKFsp.js";
+import { a as failedPage, s as pageUrl } from "./result-DfUru6y_.js";
 import { Worker } from "node:worker_threads";
 import { availableParallelism } from "node:os";
 //#region src/audit/runners/pool.ts
@@ -52,6 +52,16 @@ const WORK_PER_WORKER_MS = 1600;
 /** Threading at all means at least two, or there is nothing to overlap with. */
 const MIN_WORKERS = 2;
 /**
+* Grace above the runner's own per-page timeout before a worker is killed.
+*
+* The runner races axe-core against a timer, which works whenever the work
+* yields to the event loop: the page is reported with an error and the thread
+* lives on to take the next one. That is the better outcome, so it is given
+* room to happen first. This is the backstop for when it cannot — see
+* `watchdog` below.
+*/
+const HARD_TIMEOUT_GRACE_MS = 5e3;
+/**
 * Ceiling on workers regardless of core count. Past this, the run is bounded by
 * memory bandwidth and by each worker's own start-up rather than by cores, and
 * every extra thread holds another jsdom document tree.
@@ -96,10 +106,33 @@ async function runPooledAudit(pages, options = {}) {
 	return runWorkers(pages, runnerOptions, Math.min(workers, pages.length), entry);
 }
 async function auditHere(pages, options) {
-	const { runJsdomAudit } = await import("./jsdom-4IMzv0eE.js");
+	const { runJsdomAudit } = await import("./jsdom-DMvU2h-f.js");
 	return runJsdomAudit(pages, options);
 }
+/**
+* The only place a per-page ceiling can actually be enforced.
+*
+* The runner's own timeout is a `Promise.race`, and a race cannot interrupt
+* synchronous work: jsdom's parse and axe-core's walk of the tree both hold the
+* thread, so the timer that is meant to stop them never gets to run. Measured
+* on a 120,000-element document with a two-second ceiling, the audit was still
+* going more than ten minutes later — and because the pool waits on its
+* workers, the whole run went with it. A CI job hung until the platform killed
+* it, which is the failure the ceiling exists to prevent.
+*
+* `worker.terminate()` is the answer, because it stops the thread whatever it
+* is doing. So the supervisor keeps its own deadline per page and kills the
+* thread that overruns it, records that page as unaudited, and lets the rest of
+* the run carry on. The page is reported as a failure rather than as a clean
+* page, which the CLI already turns into exit 2.
+*
+* Two runs still have no hard ceiling, because both refuse the threads that
+* would carry it: `--concurrency 1`, and a machine with too few cores to spare
+* one. Both are documented rather than papered over, and the size cap in
+* `collectPages` is what keeps them bounded in practice.
+*/
 async function runWorkers(pages, options, count, entry) {
+	const deadlineMs = (options.timeoutMs ?? 3e4) + HARD_TIMEOUT_GRACE_MS;
 	const audits = Array.from({ length: pages.length });
 	let next = 0;
 	await Promise.all(Array.from({ length: count }, () => {
@@ -113,7 +146,13 @@ async function runWorkers(pages, options, count, entry) {
 			}
 			let inFlight;
 			let completed = 0;
+			let watchdog;
+			const disarm = () => {
+				if (watchdog !== void 0) clearTimeout(watchdog);
+				watchdog = void 0;
+			};
 			const finish = () => {
+				disarm();
 				worker.terminate();
 				resolve();
 			};
@@ -127,8 +166,18 @@ async function runWorkers(pages, options, count, entry) {
 				next += 1;
 				inFlight = index;
 				worker.postMessage(pages[index]);
+				watchdog = setTimeout(() => {
+					watchdog = void 0;
+					if (inFlight !== void 0) {
+						audits[inFlight] = failedPage(identity(pages[inFlight], options), `the audit worker was stopped after ${deadlineMs}ms on this page`);
+						inFlight = void 0;
+					}
+					finish();
+				}, deadlineMs);
+				watchdog.unref?.();
 			};
 			worker.on("message", (audit) => {
+				disarm();
 				if (inFlight !== void 0) {
 					audits[inFlight] = audit;
 					completed += 1;
@@ -136,6 +185,7 @@ async function runWorkers(pages, options, count, entry) {
 				feed();
 			});
 			worker.on("error", (cause) => {
+				disarm();
 				if (inFlight !== void 0 && completed > 0) audits[inFlight] = failedPage(identity(pages[inFlight], options), `audit worker failed: ${cause.message}`);
 				finish();
 			});

package/dist/{render-DrvXRCEn.js → render-CtsqR0k-.js}

@@ -1,7 +1,8 @@
-import { c as number, f as record, l as object, m as string, o as isoDateTime, p as safeParse, s as nullable, t as array, v as withDefault } from "./schema-is6CGX2D.js";
+import { n as IMPACT_LEVELS, o as impactRank } from "./impact-luGCnN8F.js";
+import { c as nullable, h as string, l as number, m as safeParse, p as record, s as isoDateTime, t as array, u as object, y as withDefault } from "./schema-DJSF4K05.js";
+import { u as STATEMENT_LOCALES } from "./load-vZdV_fD1.js";
 import { n as isDirectory } from "./fs-BmPtmFke.js";
-import { a as impactRank, n as IMPACT_LEVELS } from "./impact-DZt2oBCP.js";
-import { i as escapeText, o as standardsReference, r as escapeAttribute } from "./text-CKKpzkYM.js";
+import { a as isoDate, i as escapeText, n as count, r as escapeAttribute, s as standardsReference } from "./text-BF1LHMiV.js";
 import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
 import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";
@@ -19,6 +20,107 @@ import { fileURLToPath } from "node:url";
 var StatementError = class extends Error {
 	name = "StatementError";
 };
+//#endregion
+//#region src/statement/evidence.ts
+/**
+* How old a claim or a report may be before the document says so.
+*
+* A year, because a statement is a document about a site that changes, and one
+* dated further back than that is describing a site nobody has checked since.
+* It is a warning and never a refusal: how often a statement must be revisited
+* is a question about a legal regime and a rate of change, and this tool is in
+* no position to answer it for somebody.
+*/
+const STALE_DAYS = 365;
+function checkStatementEvidence(input) {
+	const today = input.today ?? /* @__PURE__ */ new Date();
+	return [
+		...claimAgainstAudit(input),
+		...claimAgainstReview(input),
+		...dates(input, today)
+	];
+}
+/** Whether any problem is bad enough to stop the document being written. */
+function refuses(problems) {
+	return problems.some((problem) => problem.severity === "refuses");
+}
+/**
+* A claim of full conformance, against barriers the audit found.
+*
+* Refused rather than warned about. Every other output of this tool is a report
+* somebody reads; this one is a legal document published under their name, and
+* the failure mode is not a wrong number in a terminal but a false statement on
+* a website. The fix is in the message because it is not obvious to somebody
+* filling in a config file for the first time that `partially-compliant` is the
+* ordinary answer rather than an admission of defeat.
+*/
+function claimAgainstAudit(input) {
+	const audit = input.audit;
+	if (audit === void 0 || input.config.compliance.status !== "compliant") return [];
+	if (audit.findings.length === 0) return [];
+	const pages = new Set(audit.findings.flatMap((finding) => finding.pages)).size;
+	return [{
+		severity: "refuses",
+		message: `The config claims full conformance, and the audit report lists ${count(audit.findings.length, "barrier")} on ${count(pages, "page")}.\n  A statement claiming full conformance for a site that is not conformant is worse\n  than no statement at all, so this one was not written.\n  Either fix the barriers and audit again, or set compliance.status to\n  "partially-compliant", which is the honest answer for most sites and the one that\n  carries the obligation to list what is missing.`
+	}];
+}
+/**
+* A claim of full conformance, against criteria a person recorded as not met.
+*
+* The review record is the only evidence this tool has about the 34 criteria no
+* engine can reach, and a `not-met` in it is somebody's own finding. Claiming
+* full conformance over the top of it is the same false statement as claiming
+* it over the top of a violation, so it gets the same refusal.
+*/
+function claimAgainstReview(input) {
+	const review = input.review;
+	if (review === void 0 || input.config.compliance.status !== "compliant") return [];
+	const notMet = Object.entries(review.criteria).filter(([, entry]) => entry.result === "not-met").map(([number]) => number);
+	if (notMet.length === 0) return [];
+	return [{
+		severity: "refuses",
+		message: `The config claims full conformance, and the review record has ${count(notMet.length, "criterion")} recorded as not met: ${notMet.join(", ")}.\n  Somebody checked those and wrote down that the site does not meet them, so this\n  statement was not written. Fix them and record the result, or set\n  compliance.status to "partially-compliant" and describe them in\n  compliance.knownIssues.`
+	}];
+}
+/**
+* Whether the document's dates still describe the site.
+*
+* All warnings. A date being old is not a false claim — it is a document nobody
+* has revisited, which is a different problem with a different fix, and the
+* person publishing it is the one who knows whether the site has moved.
+*/
+function dates(input, today) {
+	const problems = [];
+	const assessedOn = input.config.compliance.assessedOn;
+	const now = isoDate(today);
+	if (assessedOn > now) problems.push({
+		severity: "warns",
+		message: `compliance.assessedOn is ${assessedOn}, which is in the future. A statement dated ahead of its own assessment is a typo somebody will notice.`
+	});
+	else if (daysBetween(assessedOn, now) > STALE_DAYS) problems.push({
+		severity: "warns",
+		message: `compliance.assessedOn is ${assessedOn}, ${count(daysBetween(assessedOn, now), "day")} ago. The statement will say so, and it describes a site nobody has assessed since.`
+	});
+	const audit = input.audit;
+	if (audit === void 0) return problems;
+	const auditDay = audit.generatedAt.slice(0, 10);
+	if (auditDay > assessedOn) problems.push({
+		severity: "warns",
+		message: `The audit ran on ${auditDay}, after the ${assessedOn} this statement gives as its assessment date. Move compliance.assessedOn forward, or cite the report from that day.`
+	});
+	if (daysBetween(auditDay, now) > STALE_DAYS) problems.push({
+		severity: "warns",
+		message: `The audit report is from ${auditDay}, ${count(daysBetween(auditDay, now), "day")} ago. The barriers it lists are the ones the site had then.`
+	});
+	return problems;
+}
+/** Whole days between two ISO dates, both UTC, without a date library. */
+function daysBetween(from, to) {
+	const start = Date.parse(`${from}T00:00:00Z`);
+	const end = Date.parse(`${to}T00:00:00Z`);
+	if (Number.isNaN(start) || Number.isNaN(end)) return 0;
+	return Math.round((end - start) / 864e5);
+}
 /**
 * Only the fields the statement reads. Everything else in the report — node
 * markup, selectors, passes, inapplicable — is audit detail with no place in a
@@ -58,7 +160,7 @@ function summariseAuditReport(value, source = "audit report") {
 	const result = safeParse(reportSchema, value);
 	if (!result.success) throw new StatementError(`${source} is not an eaa-kit JSON report (${result.error.issues.map((issue) => `${issue.path.join(".") || "document"}: ${issue.message}`).slice(0, 5).join("; ")})`);
 	const report = result.data;
-	if (report.schemaVersion !== 1) throw new StatementError(`${source} has schemaVersion ${report.schemaVersion}; this version of eaa-kit reads 1`);
+	if (report.schemaVersion !== 2) throw new StatementError(`${source} has schemaVersion ${report.schemaVersion}; this version of eaa-kit reads 2`);
 	const byRule = /* @__PURE__ */ new Map();
 	const rules = new Map(Object.entries(report.rules));
 	for (const page of report.pages) for (const violation of page.violations) {
@@ -411,7 +513,7 @@ async function renderStatement(config, options = {}) {
 	const country = options.country ?? config.enforcement.country;
 	const locale = options.locale ?? defaultLocale(config);
 	const template = `${country.toLowerCase()}.${locale}`;
-	const markdown = tidy(renderTemplate(await loadTemplate(template), buildScope(config, locale, options.audit)));
+	const markdown = tidy(renderTemplate(await loadTemplate(country, locale), buildScope(config, locale, options.audit)));
 	return {
 		markdown,
 		html: toHtmlDocument(markdown, {
@@ -423,9 +525,16 @@ async function renderStatement(config, options = {}) {
 		template
 	};
 }
-/** A German-language site gets a German statement unless told otherwise. */
+/**
+* A site gets its statement in its own language where there is one for it.
+*
+* From `site.locale`, which is a BCP 47 tag: `de-AT` and `de` both mean the
+* German document. English is the fallback because every country has an English
+* template, being the language a statement is most often also published in.
+*/
 function defaultLocale(config) {
-	return config.site.locale.toLowerCase().startsWith("de") ? "de" : "en";
+	const language = config.site.locale.toLowerCase().split("-")[0];
+	return STATEMENT_LOCALES.find((candidate) => candidate === language) ?? "en";
 }
 /**
 * Values the templates interpolate.
@@ -522,6 +631,22 @@ function reasonScope(reason) {
 	};
 }
 /**
+* Where each statement language formats its dates.
+*
+* A region is named for every one, because a bare language tag leaves the
+* format to whatever ICU picks: `de` is de-DE, and this tool's German documents
+* have always been dated the Austrian way. `en-GB` for the same reason —
+* 20 August 2026, not August 20, 2026, in a European legal document.
+*/
+const DATE_LOCALES = {
+	de: "de-AT",
+	en: "en-GB",
+	es: "es-ES",
+	fr: "fr-FR",
+	it: "it-IT",
+	nl: "nl-NL"
+};
+/**
 * 2026-08-20 becomes 20. August 2026 or 20 August 2026.
 *
 * Every date reaching this has been through a schema that checks it, so the
@@ -533,7 +658,7 @@ function reasonScope(reason) {
 function formatDate(iso, locale) {
 	const date = /* @__PURE__ */ new Date(`${iso}T00:00:00Z`);
 	if (Number.isNaN(date.getTime())) return iso;
-	return new Intl.DateTimeFormat(locale === "de" ? "de-AT" : "en-GB", {
+	return new Intl.DateTimeFormat(DATE_LOCALES[locale], {
 		day: "numeric",
 		month: "long",
 		year: "numeric",
@@ -549,14 +674,28 @@ function tidy(markdown) {
 	return `${markdown.replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n").trim()}\n`;
 }
 let templateDirectory;
-async function loadTemplate(name) {
+/**
+* The document for a country in a language, if there is one.
+*
+* The matrix is deliberately sparse: a country's statement is written under its
+* own law and published in the language the law is administered in, plus
+* English. Asking for a combination nobody wrote is an error naming the
+* languages that country does have — not a fall back to another language, which
+* would hand somebody a document in a language their readers may not have and
+* do it quietly.
+*/
+async function loadTemplate(country, locale) {
 	templateDirectory ??= await findTemplateDirectory();
 	const directory = templateDirectory;
+	const name = `${country.toLowerCase()}.${locale}`;
 	const file = path.join(directory, `${name}.md`);
 	try {
 		return await readFile(file, "utf8");
 	} catch {
-		throw new StatementError(`No statement template for ${name}. Available: ${(await readdir(directory)).filter((entry) => entry.endsWith(".md")).map((entry) => entry.replace(/\.md$/, "")).sort().join(", ")}`);
+		const templates = (await readdir(directory)).filter((entry) => entry.endsWith(".md")).map((entry) => entry.replace(/\.md$/, "")).sort();
+		const prefix = `${country.toLowerCase()}.`;
+		const forCountry = templates.filter((entry) => entry.startsWith(prefix)).map((entry) => entry.slice(prefix.length));
+		throw new StatementError(forCountry.length > 0 ? `No ${country} statement in ${locale}. ${country} has: ${forCountry.join(", ")}` : `No statement template for ${name}. Available: ${templates.join(", ")}`);
 	}
 }
 /**
@@ -576,4 +715,4 @@ async function findTemplateDirectory() {
 	throw new StatementError(`Could not locate the statement templates. Looked in: ${candidates.join(", ")}`);
 }
 //#endregion
-export { summariseAuditReport as a, readAuditReport as i, toHtmlBody as n, StatementError as o, toHtmlDocument as r, renderStatement as t };
+export { summariseAuditReport as a, StatementError as c, readAuditReport as i, toHtmlBody as n, checkStatementEvidence as o, toHtmlDocument as r, refuses as s, renderStatement as t };

package/dist/{result-DoamKFsp.js → result-DfUru6y_.js}

@@ -1,6 +1,15 @@
 import { pathToFileURL } from "node:url";
 import axe from "axe-core";
 //#region src/audit/result.ts
+/**
+* Per-page ceiling for an audit, in milliseconds.
+*
+* Lives here rather than in the jsdom runner because the worker pool needs it
+* to set its own deadline, and the pool deliberately does not import jsdom —
+* loading 630 ms of dependency to supervise threads that each load their own
+* would be pure overhead. The same reason ENGINE_BLIND_RULES sits here.
+*/
+const DEFAULT_PAGE_TIMEOUT_MS = 3e4;
 /** WCAG 2.2 AA and everything it builds on. Best-practice rules stay off. */
 const DEFAULT_TAGS = [
 	"wcag2a",
@@ -122,17 +131,65 @@ function ruleOutcomes(audit) {
 		...audit.inapplicable
 	];
 }
-function runOptions(tags) {
+/**
+* Which engine produced this run, as every report format has to label it.
+*
+* Taken from the first page rather than tracked separately: a run uses one
+* engine for all of its pages, and an empty run has none to report, which is
+* the jsdom default the CLI would have used.
+*/
+function runEngine(audits) {
+	return audits[0]?.engine ?? "jsdom";
+}
+/**
+* Every rule the run mentions anywhere, once each, sorted by id.
+*
+* Both machine-readable formats need this and neither can take it from the
+* other: the JSON report keys its `rules` map by id, and SARIF needs the same
+* catalogue as a list its results index into. First mention wins because a
+* rule's help text and criteria do not vary between the pages it appears on.
+*/
+function uniqueRuleOutcomes(audits) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const audit of audits) for (const outcome of ruleOutcomes(audit)) if (!byId.has(outcome.ruleId)) byId.set(outcome.ruleId, outcome);
+	return [...byId.values()].sort((a, b) => a.ruleId.localeCompare(b.ruleId));
+}
+function runOptions(tags, options = {}) {
 	return {
 		runOnly: {
 			type: "tag",
 			values: [...tags]
 		},
 		resultTypes: ["violations", "incomplete"],
-		preload: false
+		preload: false,
+		...options.skipBlindRules ? { rules: disabledBlindRules() } : {}
 	};
 }
 /**
+* The rules this engine cannot decide, switched off rather than run.
+*
+* Normally they are run and their verdict discarded: axe-core computes colour
+* contrast against a stylesheet jsdom never fetched, and `shapeResults` throws
+* the answer away as untrustworthy. The work is wasted either way, and it is
+* not a small amount — measured at 14-19% of a page, since colour contrast is
+* the most expensive rule axe-core has.
+*
+* What is lost is the element list. A rule that runs reports *which* elements
+* it could not decide, and those are the elements a person has to check by
+* hand; a rule that never runs cannot name them. That is the whole trade, and
+* it is why this is behind a flag rather than the default.
+*
+* What does not change is the verdict. `shapeResults` already has a pass for
+* rules axe-core skipped entirely — the preload-dependent ones arrive that way
+* — and files them as unevaluated with the same reason. A criterion this run
+* could not reach still reads as unreached.
+*/
+function disabledBlindRules() {
+	const rules = {};
+	for (const ruleId of Object.keys(ENGINE_BLIND_RULES)) rules[ruleId] = { enabled: false };
+	return rules;
+}
+/**
 * Turn raw axe-core output into a PageAudit, shared by both engines so their
 * reports are directly comparable.
 *
@@ -279,4 +336,4 @@ function enClauses(tags) {
 	return [...clauses].sort();
 }
 //#endregion
-export { findingElements as a, runOptions as c, failedPage as i, shapeResults as l, ENGINE_BLIND_RULES as n, pageUrl as o, blindRulesInScope as r, ruleOutcomes as s, DEFAULT_TAGS as t, successCriteria as u };
+export { failedPage as a, runEngine as c, successCriteria as d, uniqueRuleOutcomes as f, blindRulesInScope as i, runOptions as l, DEFAULT_TAGS as n, findingElements as o, ENGINE_BLIND_RULES as r, pageUrl as s, DEFAULT_PAGE_TIMEOUT_MS as t, shapeResults as u };

package/dist/review-CdMK2GpQ.js

@@ -0,0 +1,161 @@
+import { d as optional, h as string, i as enumeration, l as number, m as safeParse, o as isoDate, p as record, u as object, y as withDefault } from "./schema-DJSF4K05.js";
+import { a as isoDate$1 } from "./text-BF1LHMiV.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. */
+const DEFAULT_REVIEW_FILE = "eaa-review.json";
+/**
+* What a person concluded about one criterion.
+*
+* `not-applicable` is kept apart from `met` for the reason `inapplicable` is
+* kept apart from `passes` everywhere else in this tool: a criterion with
+* nothing on the site to which it applies has not been met, it has been ruled
+* out, and folding the two together would let an empty site look conformant.
+*/
+const REVIEW_RESULTS = [
+	"met",
+	"not-met",
+	"not-applicable",
+	"unreviewed"
+];
+const entrySchema = object({
+	result: withDefault(enumeration(REVIEW_RESULTS), () => "unreviewed"),
+	/** ISO date the check was done. Without it the entry cannot be aged. */
+	reviewedOn: optional(isoDate()),
+	/** Who did it, when that is not the person named on the record. */
+	reviewedBy: optional(string()),
+	/** What was checked and what was found. Free text, for whoever reads it. */
+	note: optional(string())
+});
+const reviewSchema = object({
+	schemaVersion: number(),
+	/** Who carried out the review, for the record as a whole. */
+	reviewedBy: optional(string()),
+	/** Keyed by success criterion number, e.g. '1.2.1'. */
+	criteria: withDefault(record(entrySchema), () => ({}))
+});
+var ReviewError = class extends Error {
+	name = "ReviewError";
+};
+/**
+* What the record says about one criterion, and whether it counts.
+*
+* Returns undefined when there is nothing recorded, which is the ordinary case
+* for most criteria of most sites: a missing entry and an `unreviewed` one mean
+* the same thing and are reported the same way.
+*/
+function criterionReview(criterionNumber, options, engineReachedVerdict) {
+	const entry = options.record.criteria[criterionNumber];
+	if (entry === void 0 || entry.result === "unreviewed") return void 0;
+	const attributed = {
+		...entry,
+		...entry.reviewedBy === void 0 && options.record.reviewedBy !== void 0 ? { reviewedBy: options.record.reviewedBy } : {}
+	};
+	const ignored = ignoredReason(entry, options, engineReachedVerdict);
+	return ignored === void 0 ? {
+		...attributed,
+		counts: true
+	} : {
+		...attributed,
+		counts: false,
+		ignored
+	};
+}
+function ignoredReason(entry, options, engineReachedVerdict) {
+	if (engineReachedVerdict) return "engine-reached-a-verdict";
+	if (options.maxAgeDays === void 0) return void 0;
+	if (entry.reviewedOn === void 0) return "undated";
+	return olderThan(entry.reviewedOn, options.maxAgeDays, options.today ?? /* @__PURE__ */ new Date()) ? "stale" : void 0;
+}
+/** Whole days between an ISO date and today, without pulling in a date library. */
+function olderThan(reviewedOn, maxAgeDays, today) {
+	const then = Date.parse(`${reviewedOn}T00:00:00Z`);
+	if (Number.isNaN(then)) return true;
+	return (Date.parse(`${isoDate$1(today)}T00:00:00Z`) - then) / 864e5 > maxAgeDays;
+}
+/**
+* What a person recorded, as the sentence both reports print under the criterion.
+*
+* One sentence rather than one per format: the console report and the HTML one
+* were composing the same four parts in the same order, with two tables of
+* reasons that had already drifted apart in wording. A reader comparing the two
+* documents of one run should not have to work out whether they mean the same
+* thing.
+*
+* An entry that was not counted still gets a sentence, with the reason. Dropping
+* it would hide the one thing a reader has to act on: a review that has aged
+* out, or one recorded against a criterion the run decided for itself.
+*/
+function reviewSentence(review) {
+	const by = review.reviewedBy === void 0 ? "" : ` by ${review.reviewedBy}`;
+	const on = review.reviewedOn ?? "no date recorded";
+	const because = review.counts ? "" : `, not counted: ${IGNORED_REASONS[review.ignored ?? "stale"]}`;
+	return `checked by hand${by} (${on}): ${review.result}${because}`;
+}
+/** Why an entry was read and not counted, in words rather than a code. */
+const IGNORED_REASONS = {
+	"engine-reached-a-verdict": "this run reached its own verdict here",
+	stale: "older than the maximum age this run was given",
+	undated: "no date recorded, and a maximum age was set"
+};
+/** A record with an entry for every criterion, keeping any answers already given. */
+function blankReview(criteria, existing) {
+	const entries = {};
+	for (const criterion of criteria) entries[criterion.number] = existing?.criteria[criterion.number] ?? { result: "unreviewed" };
+	for (const [number, entry] of Object.entries(existing?.criteria ?? {})) entries[number] ??= entry;
+	return {
+		schemaVersion: 1,
+		...existing?.reviewedBy ? { reviewedBy: existing.reviewedBy } : {},
+		criteria: sortByCriterion(entries)
+	};
+}
+/** How many criteria the record has a usable answer for, before any run is considered. */
+function answeredCount(record) {
+	return Object.values(record.criteria).filter((entry) => entry.result !== "unreviewed").length;
+}
+/** Numerically by section, so 1.4.10 sorts after 1.4.5 rather than before it. */
+function sortByCriterion(entries) {
+	return Object.fromEntries(Object.entries(entries).sort(([a], [b]) => compareCriteria(a, b)));
+}
+function compareCriteria(a, b) {
+	const left = a.split(".").map(Number);
+	const right = b.split(".").map(Number);
+	for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+		const difference = (left[index] ?? 0) - (right[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+function serialiseReview(record) {
+	return `${JSON.stringify(record, null, 2)}\n`;
+}
+async function readReview(file, cwd = process.cwd()) {
+	const target = path.resolve(cwd, file);
+	let raw;
+	try {
+		raw = await readFile(target, "utf8");
+	} catch {
+		throw new ReviewError(`Could not read the review record at ${file}. Create one with: eaa-kit checklist`);
+	}
+	let value;
+	try {
+		value = JSON.parse(raw);
+	} catch (cause) {
+		throw new ReviewError(`${path.basename(target)} is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
+	}
+	const result = safeParse(reviewSchema, value);
+	if (!result.success) {
+		const issues = result.error.issues.map((issue) => `${issue.path.join(".") || "document"}: ${issue.message}`).slice(0, 5);
+		throw new ReviewError(`${path.basename(target)} is not an eaa-kit review record (${issues.join("; ")})`);
+	}
+	if (result.data.schemaVersion !== 1) throw new ReviewError(`${path.basename(target)} has schemaVersion ${result.data.schemaVersion}; this version of eaa-kit reads 1.`);
+	return result.data;
+}
+async function writeReview(file, record, cwd = process.cwd()) {
+	const target = path.resolve(cwd, file);
+	await mkdir(path.dirname(target), { recursive: true });
+	await writeFile(target, serialiseReview(record), "utf8");
+	return target;
+}
+//#endregion
+export { blankReview as a, readReview as c, writeReview as d, answeredCount as i, reviewSentence as l, REVIEW_RESULTS as n, compareCriteria as o, ReviewError as r, criterionReview as s, DEFAULT_REVIEW_FILE as t, serialiseReview as u };

package/dist/review-DIbOTmOM.js

@@ -0,0 +1,2 @@
+import { a as blankReview, c as readReview, d as writeReview, i as answeredCount, r as ReviewError } from "./review-CdMK2GpQ.js";
+export { ReviewError, answeredCount, blankReview, readReview, writeReview };

package/dist/{run-DB34BSOZ.js → run-D7hdVXLA.js}

@@ -35,7 +35,7 @@ async function auditBuild(directory, options, logger) {
 		logger.info("skipped (enabled: false)");
 		return;
 	}
-	const { runAuditCommand } = await import("./audit-CpXH2Mk8.js");
+	const { runAuditCommand } = await import("./audit-DK2StT1_.js");
 	const { exitCode } = await runAuditCommand(directory, auditOptions);
 	if (exitCode === 0) {
 		logger.info("no violations at or above the threshold");

package/dist/{run-BMASMmwO.d.ts → run-YiqyQA2b.d.ts}

@@ -20,8 +20,25 @@ interface IntegrationOptions {
   baseUrl?: string;
   /** Audit in real Chromium. Needs the playwright peer. */
   browser?: boolean;
+  /**
+   * Skip the rules the browserless engine cannot decide rather than running
+   * them and discarding the answer. The verdict does not move — those rules are
+   * still reported as not evaluated — so what a build gives up is the list of
+   * elements a person would check by hand. No effect under `browser`.
+   */
+  fast?: boolean;
   concurrency?: number;
   baseline?: string;
+  /**
+   * Path to a review record: what a person checked, for the criteria no engine
+   * can reach. It changes nothing about whether the build fails — a review is a
+   * claim beside the run's own findings, never a verdict on them — but it is
+   * what makes the coverage in a build log describe the whole standard rather
+   * than only the automatable fraction of it.
+   */
+  review?: string;
+  /** Days after which a recorded review stops counting. */
+  reviewMaxAge?: number;
   format?: OutputFormat;
   /** Write the report here instead of the build log. */
   output?: string;