eaa-kit 0.5.0 → 0.6.0

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

@@ -1,8 +1,8 @@
-import { a as impactRank, n as IMPACT_LEVELS } from "./impact-DZt2oBCP.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-yAR4wzez.js";
+import { u as STATEMENT_LOCALES } from "./load-vZdV_fD1.js";
 import { n as isDirectory } from "./fs-BmPtmFke.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";
@@ -20,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
@@ -614,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-BWcYXeRs.js → result-DfUru6y_.js}

@@ -131,6 +131,29 @@ function ruleOutcomes(audit) {
 		...audit.inapplicable
 	];
 }
+/**
+* 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: {
@@ -313,4 +336,4 @@ function enClauses(tags) {
 	return [...clauses].sort();
 }
 //#endregion
-export { failedPage as a, ruleOutcomes as c, successCriteria as d, 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 };
+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-C2nKFcb-.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-DyHPmGeD.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-CtcEUhbe.d.ts → run-YiqyQA2b.d.ts}

@@ -29,6 +29,16 @@ interface IntegrationOptions {
   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;

package/dist/{sarif-B-UBcVu8.js → sarif-BKvq_AUm.js}

@@ -1,8 +1,9 @@
-import { o as isImpactLevel } from "./impact-DZt2oBCP.js";
-import { o as standardsReference } from "./text-CKKpzkYM.js";
+import { s as isImpactLevel } from "./impact-luGCnN8F.js";
+import { s as standardsReference } from "./text-BF1LHMiV.js";
 import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
 import { t as elementFingerprint } from "./fingerprint-BjYV_0F7.js";
-import { c as ruleOutcomes, o as findingElements } from "./result-BWcYXeRs.js";
+import { c as runEngine, f as uniqueRuleOutcomes, o as findingElements } from "./result-DfUru6y_.js";
+import { n as buildCoverage } from "./coverage-BD2_CYns.js";
 import path from "node:path";
 //#region src/audit/report/sarif.ts
 const SARIF_VERSION = "2.1.0";
@@ -75,7 +76,7 @@ function buildSarifReport(audits, options) {
 				toolExecutionNotifications: notifications
 			}],
 			results,
-			properties: summaryProperties(audits, options.completeness)
+			properties: summaryProperties(audits, options.completeness, options.review)
 		}]
 	};
 }
@@ -115,12 +116,7 @@ function fingerprint(ruleId, selector, html) {
 }
 /** Every rule the run knows about, so the catalogue is complete in GitHub. */
 function buildRules(audits) {
-	const rules = /* @__PURE__ */ new Map();
-	for (const audit of audits) for (const outcome of ruleOutcomes(audit)) {
-		if (rules.has(outcome.ruleId)) continue;
-		rules.set(outcome.ruleId, toSarifRule(outcome));
-	}
-	return [...rules.values()].sort((a, b) => a.id.localeCompare(b.id));
+	return uniqueRuleOutcomes(audits).map(toSarifRule);
 }
 function toSarifRule(outcome) {
 	const references = standardsReference(outcome.successCriteria, outcome.enClauses);
@@ -140,7 +136,7 @@ function toSarifRule(outcome) {
 * Coverage that has no place in `results` but should not vanish: a SARIF log
 * with no results must not be mistaken for "everything was checked".
 */
-function summaryProperties(audits, completeness) {
+function summaryProperties(audits, completeness, review) {
 	let needsReview = 0;
 	let notEvaluated = 0;
 	const notEvaluatedRules = /* @__PURE__ */ new Set();
@@ -149,11 +145,12 @@ function summaryProperties(audits, completeness) {
 		notEvaluatedRules.add(finding.ruleId);
 	} else needsReview += 1;
 	return {
-		engine: audits[0]?.engine ?? "jsdom",
+		engine: runEngine(audits),
 		pages: audits.length,
 		needsReview,
 		notEvaluated,
 		notEvaluatedRules: [...notEvaluatedRules].sort(),
+		...review ? reviewProperties(audits, review) : {},
 		...completeness ? {
 			complete: completeness.complete,
 			discovery: completeness.discovery,
@@ -165,6 +162,20 @@ function summaryProperties(audits, completeness) {
 	};
 }
 /**
+* The review as three counts, in the same shape the JSON report carries them.
+*
+* Counts only: this log's job is alerts, and the criterion-by-criterion detail
+* belongs in the JSON report, which carries it in full.
+*/
+function reviewProperties(audits, review) {
+	const coverage = buildCoverage(audits, void 0, review);
+	return {
+		reviewedCriteria: coverage.reviewed,
+		reviewedNotMet: coverage.reviewedNotMet,
+		reviewNotCounted: coverage.reviewNotCounted
+	};
+}
+/**
 * Artifact URIs are relative to the working directory and POSIX-separated, so
 * GitHub can line them up with files in the repository.
 */

package/dist/{text-CKKpzkYM.js → text-BF1LHMiV.js}

@@ -18,9 +18,21 @@ function escapeText(value) {
 function escapeAttribute(value) {
 	return escapeText(value).replace(/"/g, """).replace(/'/g, "'");
 }
+/**
+* The plurals this package's own output actually uses, where an `s` is wrong.
+*
+* Deliberately a short list rather than a pluralisation library: this is the
+* vocabulary of a handful of report lines, and every entry here was added
+* because something printed "2 entrys" or "4 criterions" at somebody.
+*/
+const IRREGULAR = {
+	entry: "entries",
+	criterion: "criteria"
+};
 /** `plural(1, 'page')` is `page`, `plural(2, 'page')` is `pages`. */
 function plural(value, noun) {
-	return value === 1 ? noun : `${noun}s`;
+	if (value === 1) return noun;
+	return IRREGULAR[noun] ?? `${noun}s`;
 }
 /** `count(2, 'page')` is `2 pages`. */
 function count(value, noun) {
@@ -39,5 +51,13 @@ function collapse(html, max) {
 function standardsReference(successCriteria, enClauses) {
 	return [...successCriteria.map((criterion) => `WCAG ${criterion}`), ...enClauses.map((clause) => `EN 301 549 ${clause}`)].join(", ");
 }
+/**
+* A date as the ISO day this package records everywhere it writes one: the day
+* a baseline entry was accepted, and the day a criterion was reviewed. Always
+* UTC, so two people on either side of a date line write the same file.
+*/
+function isoDate(date) {
+	return date.toISOString().slice(0, 10);
+}
 //#endregion
-export { plural as a, escapeText as i, count as n, standardsReference as o, escapeAttribute as r, collapse as t };
+export { isoDate as a, escapeText as i, count as n, plural as o, escapeAttribute as r, standardsReference as s, collapse as t };

package/dist/vite/index.d.ts

@@ -1,4 +1,4 @@
-import { n as IntegrationOptions, t as BuildAuditError } from "../run-CtcEUhbe.js";
+import { n as IntegrationOptions, t as BuildAuditError } from "../run-YiqyQA2b.js";
 //#region src/vite/index.d.ts
 interface EaaKitPluginOptions extends IntegrationOptions {
   /**

package/dist/vite/index.js

@@ -1,4 +1,4 @@
-import { n as auditBuild, t as BuildAuditError } from "../run-C2nKFcb-.js";
+import { n as auditBuild, t as BuildAuditError } from "../run-D7hdVXLA.js";
 import path from "node:path";
 //#region src/vite/index.ts
 function eaaKit(options = {}) {

package/dist/webpack/index.d.ts

@@ -1,4 +1,4 @@
-import { n as IntegrationOptions, t as BuildAuditError } from "../run-CtcEUhbe.js";
+import { n as IntegrationOptions, t as BuildAuditError } from "../run-YiqyQA2b.js";
 //#region src/webpack/index.d.ts
 /** The part of a webpack compilation this reads. */
 interface CompilationLike {

package/dist/webpack/index.js

@@ -1,4 +1,4 @@
-import { n as auditBuild, r as stderrLogger, t as BuildAuditError } from "../run-C2nKFcb-.js";
+import { n as auditBuild, r as stderrLogger, t as BuildAuditError } from "../run-D7hdVXLA.js";
 import path from "node:path";
 //#region src/webpack/index.ts
 var EaaKitWebpackPlugin = class {

package/dist/worksheet-eUjwYLxC.js

@@ -0,0 +1,63 @@
+import { n as DEFAULT_TAGS } from "./result-DfUru6y_.js";
+import { a as rulesByCriterion, o as manualCheckFor, s as understandingUrl, t as WCAG22_AA_CRITERIA } from "./coverage-BD2_CYns.js";
+//#region src/audit/worksheet.ts
+function buildWorksheet(options) {
+	const rules = rulesByCriterion(options.tags ?? DEFAULT_TAGS);
+	const unautomatable = WCAG22_AA_CRITERIA.filter((criterion) => (rules.get(criterion.number) ?? []).length === 0);
+	const lines = [
+		"# Manual accessibility review",
+		"",
+		`Of the ${WCAG22_AA_CRITERIA.length} WCAG 2.2 success criteria at Levels A and AA,`,
+		`**${unautomatable.length} have no automated rule at all**: no engine, this one included, can`,
+		"reach a verdict on them. They are the part of conformance a person has to do, and this is",
+		"the list of them.",
+		"",
+		`Record what you find in \`${options.recordPath}\`, which is the file \`eaa-kit audit --review\``,
+		"reads. Ticking a box below records nothing: this document is generated from the record and",
+		"never read back into it.",
+		"",
+		"For each criterion, set `result` to one of:",
+		"",
+		"- `met` — you checked it and the site meets it.",
+		"- `not-met` — you checked it and it does not. Say what is wrong in `note`.",
+		"- `not-applicable` — there is nothing on this site the criterion applies to. Not the same",
+		"  as `met`, and never counted as though it were.",
+		"- `unreviewed` — nobody has looked yet. What every entry starts as.",
+		"",
+		"Set `reviewedOn` to the day you checked it. An entry with no date cannot be shown to still",
+		"hold, and an audit run with `--review-max-age` will not count it.",
+		""
+	];
+	lines.push("## Criteria no automated rule can reach", "", "These are the review. Nothing in any eaa-kit report says anything about them.", "");
+	for (const criterion of unautomatable) lines.push(...criterionEntry(criterion, [], options.review));
+	lines.push("## Criteria an audit can reach", "", "An audit reaches these when the rules below actually match something on the site. A run", "that found nothing to check has not shown the criterion is met, so they are worth a look", "too — and where this engine could not decide a rule, the check to do by hand is named.", "");
+	for (const criterion of WCAG22_AA_CRITERIA) {
+		const forCriterion = rules.get(criterion.number) ?? [];
+		if (forCriterion.length === 0) continue;
+		lines.push(...criterionEntry(criterion, forCriterion, options.review));
+	}
+	lines.push("---", "", "A completed review is not a compliance statement, and this tool cannot check that anything", "recorded here is true. It records what somebody says they checked, which is the same", "standing as the claims in the statement it generates.", "");
+	return lines.join("\n");
+}
+function criterionEntry(criterion, rules, review) {
+	const entry = review?.criteria[criterion.number];
+	const lines = [`- [${entry !== void 0 && entry.result !== "unreviewed" ? "x" : " "}] **${criterion.number} ${criterion.title}** (Level ${criterion.level})`];
+	const url = understandingUrl(criterion.number);
+	if (url !== void 0) lines.push(`      What it requires: ${url}`);
+	if (rules.length > 0) {
+		lines.push(`      Rules that touch it: ${rules.join(", ")}`);
+		for (const rule of rules) {
+			const manual = manualCheckFor(rule);
+			if (manual !== void 0) lines.push(`      ${rule}: ${manual.check}`);
+		}
+	}
+	if (entry !== void 0 && entry.result !== "unreviewed") {
+		const on = entry.reviewedOn === void 0 ? "no date recorded" : `on ${entry.reviewedOn}`;
+		lines.push(`      Recorded: ${entry.result} (${on})`);
+		if (entry.note !== void 0) lines.push(`      Note: ${entry.note}`);
+	}
+	lines.push("");
+	return lines;
+}
+//#endregion
+export { buildWorksheet };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eaa-kit",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "WCAG 2.2 AA auditor and EU accessibility statement generator for seven countries (AT, DE, CH, ES, FR, IT, NL). Audits a static build or a running site from the command line.",
   "type": "module",
   "license": "MIT",
@@ -79,7 +79,7 @@
     "typecheck": "tsc --noEmit",
     "lint": "biome check .",
     "format": "biome check --write .",
-    "smoke": "pnpm build && node dist/cli/index.js audit tests/fixtures/site --include about/** --format json && node dist/cli/index.js audit tests/fixtures/site --include \"about/**\" \"blog/**\" \"drafts/**\" \"legacy.htm\" --concurrency 2 && node dist/cli/index.js audit tests/fixtures/site --include about/** --format html && node dist/cli/index.js audit tests/fixtures/site --baseline examples/baseline.json && node -e \"import('./dist/astro/index.js').then(m => { const i = m.default(); if (i.name !== 'eaa-kit' || typeof i.hooks['astro:build:done'] !== 'function') { throw new Error('astro entry point is not an integration') } console.log('astro entry ok') })\" && node dist/cli/index.js statement --config examples/eaa.config.json && node dist/cli/index.js statement --config examples/eaa.config.json --audit examples/report.json --format html && node dist/cli/index.js audit tests/fixtures/site --include about/** --format json --output .eaa-kit/smoke-base.json && node dist/cli/index.js audit tests/fixtures/site --include about/** --format json --output .eaa-kit/smoke-head.json && node dist/cli/index.js diff .eaa-kit/smoke-base.json .eaa-kit/smoke-head.json --format json",
+    "smoke": "pnpm build && node dist/cli/index.js audit tests/fixtures/site --include about/** --format json && node dist/cli/index.js audit tests/fixtures/site --include \"about/**\" \"blog/**\" \"drafts/**\" \"legacy.htm\" --concurrency 2 && node dist/cli/index.js audit tests/fixtures/site --include about/** --format html && node dist/cli/index.js audit tests/fixtures/site --baseline examples/baseline.json && node -e \"import('./dist/astro/index.js').then(m => { const i = m.default(); if (i.name !== 'eaa-kit' || typeof i.hooks['astro:build:done'] !== 'function') { throw new Error('astro entry point is not an integration') } console.log('astro entry ok') })\" && node dist/cli/index.js baseline tests/fixtures/site --output .eaa-kit/smoke-baseline.json && node dist/cli/index.js baseline tests/fixtures/site --output .eaa-kit/smoke-baseline.json --prune && node dist/cli/index.js checklist --record .eaa-kit/smoke-review.json --output .eaa-kit/smoke-review.md && node dist/cli/index.js audit tests/fixtures/site --include about/** --review .eaa-kit/smoke-review.json --coverage && node dist/cli/index.js statement --config examples/eaa.config.json && node dist/cli/index.js statement --config examples/eaa.config.json --audit examples/report.json --format html && node dist/cli/index.js audit tests/fixtures/site --include about/** --format json --output .eaa-kit/smoke-base.json && node dist/cli/index.js audit tests/fixtures/site --include about/** --format json --output .eaa-kit/smoke-head.json && node dist/cli/index.js diff .eaa-kit/smoke-base.json .eaa-kit/smoke-head.json --format json",
     "examples": "pnpm build && node scripts/generate-examples.mjs",
     "test:packaged": "pnpm build && node scripts/test-packaged.mjs"
   },

package/dist/audit-DyHPmGeD.js

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

package/dist/baseline-0u4df12v.js

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

package/dist/jsdom-22Bkt65v.js

@@ -1,3 +0,0 @@
-import "./result-BWcYXeRs.js";
-import { n as runJsdomAudit } from "./jsdom-B--cEH-G.js";
-export { runJsdomAudit };

package/dist/load-CFq2VQtT.js

@@ -1,2 +0,0 @@
-import { r as loadAuditConfig } from "./load-yAR4wzez.js";
-export { loadAuditConfig };