eaa-kit 0.5.0 → 0.7.0

package/dist/{jsdom-B--cEH-G.js → jsdom-CsW_xVcA.js}

@@ -1,19 +1,9 @@
-import { a as failedPage, i as blindRulesInScope, l as runOptions, n as DEFAULT_TAGS, s as pageUrl, t as DEFAULT_PAGE_TIMEOUT_MS, u as shapeResults } from "./result-BWcYXeRs.js";
+import { c as pageUrl, d as runOptions, f as shapeResults, i as blindRulesInScope, n as DEFAULT_TAGS, o as failedPage } from "./result-B7_zVxAX.js";
 import axe from "axe-core";
 import { Script } from "node:vm";
 import { JSDOM, VirtualConsole } from "jsdom";
 //#region src/audit/runners/jsdom.ts
 /**
-* Per-page ceiling.
-*
-* A soft one, and the limit is worth stating: this races axe-core against a
-* timer, so it only fires where the work yields to the event loop. Neither
-* jsdom's parse nor axe-core's walk of the tree does, so a document pathological
-* enough to hold the thread runs past this unimpeded. The hard ceiling is the
-* worker pool's, which terminates the thread; see the note on `runWorkers`.
-*/
-const DEFAULT_TIMEOUT_MS = DEFAULT_PAGE_TIMEOUT_MS;
-/**
 * Audit collected pages with axe-core inside jsdom.
 *
 * Pages are processed sequentially: jsdom parsing and axe-core are both
@@ -40,7 +30,7 @@ async function auditPage(page, options = {}) {
 		dom = createDom(page.html, url);
 		injectAxe(dom);
 		const { axe: pageAxe } = dom.window;
-		const results = await withTimeout(pageAxe.run(dom.window.document, runOptions(tags, { skipBlindRules: options.fast === true })), options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+		const results = await withTimeout(pageAxe.run(dom.window.document, runOptions(tags, { skipBlindRules: options.fast === true })), options.timeoutMs ?? 3e4);
 		return shapeResults(results, {
 			...identity,
 			durationMs: Date.now() - startedAt,
@@ -74,6 +64,15 @@ function injectAxe(dom) {
 	axeScript ??= new Script(axe.source, { filename: "axe-core.js" });
 	axeScript.runInContext(dom.getInternalVMContext());
 }
+/**
+* The per-page ceiling, and it is a soft one.
+*
+* This races axe-core against a timer, so it only fires where the work yields to
+* the event loop. Neither jsdom's parse nor axe-core's walk of the tree does, so
+* a document pathological enough to hold the thread runs past this unimpeded.
+* The hard ceiling is the worker pool's, which terminates the thread; see the
+* note on `runWorkers`.
+*/
 async function withTimeout(promise, ms) {
 	promise.catch(() => {});
 	let timer;

package/dist/{json-DROX33kh.js → json-Bus6YhxB.js}

@@ -1,8 +1,8 @@
-import { i as impactLabel, o as isImpactLevel, r as countAtOrAbove } from "./impact-DZt2oBCP.js";
+import { a as impactLabel, i as countAtOrAbove, s as isImpactLevel } from "./impact-luGCnN8F.js";
 import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
 import { t as elementFingerprint } from "./fingerprint-BjYV_0F7.js";
-import { c as ruleOutcomes } from "./result-BWcYXeRs.js";
-import { t as buildCoverage } from "./coverage-B_Y6l-Ra.js";
+import { m as uniqueRuleOutcomes, u as runEngine } from "./result-B7_zVxAX.js";
+import { t as buildCoverage } from "./coverage-cb5kPp48.js";
 import axe from "axe-core";
 /**
 * Build the machine-readable report.
@@ -24,7 +24,7 @@ function buildJsonReport(audits, options) {
 			axeCore: axe.version
 		},
 		generatedAt,
-		engine: audits[0]?.engine ?? "jsdom",
+		engine: runEngine(audits),
 		target: {
 			source: options.directory,
 			kind: options.sourceKind ?? "directory",
@@ -33,24 +33,19 @@ function buildJsonReport(audits, options) {
 		},
 		summary: buildSummary(audits, options.failOn),
 		completeness: options.completeness,
-		coverage: buildCoverage(audits),
+		coverage: buildCoverage(audits, void 0, options.review),
 		rules: buildRuleIndex(audits),
 		pages: audits.map(toJsonPage)
 	};
 }
 /** Every rule mentioned by any page, keyed by id and sorted for stable diffs. */
 function buildRuleIndex(audits) {
-	const index = /* @__PURE__ */ new Map();
-	for (const audit of audits) for (const outcome of ruleOutcomes(audit)) {
-		if (index.has(outcome.ruleId)) continue;
-		index.set(outcome.ruleId, {
-			help: outcome.help,
-			helpUrl: outcome.helpUrl,
-			successCriteria: outcome.successCriteria,
-			en301549: outcome.enClauses
-		});
-	}
-	return Object.fromEntries([...index].sort(([a], [b]) => a.localeCompare(b)));
+	return Object.fromEntries(uniqueRuleOutcomes(audits).map((outcome) => [outcome.ruleId, {
+		help: outcome.help,
+		helpUrl: outcome.helpUrl,
+		successCriteria: outcome.successCriteria,
+		en301549: outcome.enClauses
+	}]));
 }
 /** Serialised form written to stdout or to --output, with a trailing newline. */
 function serialiseJsonReport(report) {
@@ -109,7 +104,8 @@ function toJsonPage(audit) {
 		incomplete: [...audit.incomplete].sort(byRuleId).map(toJsonIncomplete),
 		passes: [...audit.passes].sort(byRuleId).map((outcome) => outcome.ruleId),
 		inapplicable: [...audit.inapplicable].sort(byRuleId).map((outcome) => outcome.ruleId),
-		error: audit.error ?? null
+		error: audit.error ?? null,
+		...audit.reused === void 0 ? {} : { reusedFrom: audit.reused.on }
 	};
 }
 function toJsonFinding(finding) {

package/dist/{json-D_Mnnft5.js → json-CrQmoTj6.js}

@@ -1,2 +1,2 @@
-import { r as serialiseJsonReport, t as buildJsonReport } from "./json-DROX33kh.js";
+import { r as serialiseJsonReport, t as buildJsonReport } from "./json-Bus6YhxB.js";
 export { buildJsonReport, serialiseJsonReport };

package/dist/{load-yAR4wzez.js → load-BaWMa-G_.js}

@@ -1,4 +1,4 @@
-import { n as IMPACT_LEVELS } from "./impact-DZt2oBCP.js";
+import { n as IMPACT_LEVELS } from "./impact-luGCnN8F.js";
 import { _ as union, a as integer, d as optional, f as pipe, g as transform, h as string, i as enumeration, m as safeParse, n as boolean, o as isoDate, r as email, t as array, u as object, v as url, y as withDefault } from "./schema-DJSF4K05.js";
 import { r as isFile } from "./fs-BmPtmFke.js";
 import { readFile } from "node:fs/promises";
@@ -122,12 +122,21 @@ const auditSchema = object({
 	manual: optional(boolean()),
 	/** List every WCAG 2.2 A/AA criterion and what the run reached on it. */
 	coverage: optional(boolean()),
+	/** Path to a review record: what a person checked, for the criteria no engine reaches. */
+	review: optional(string({ min: 1 })),
+	/** Days after which a recorded review stops counting. */
+	reviewMaxAge: optional(integer({ min: 0 })),
 	/**
 	* False is `--no-build`: never run the project's build or start its server to
 	* find something to audit. Written in the positive because that is the state
 	* being described, and because a config file has no flags to negate.
 	*/
-	build: optional(boolean())
+	build: optional(boolean()),
+	/**
+	* False is `--no-cache`: audit every page, reusing nothing an earlier run
+	* measured. Written in the positive for the same reason `build` is.
+	*/
+	cache: optional(boolean())
 });
 const configSchema = object({
 	site: object({

package/dist/load-n62iXDq_.js

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

package/dist/nuxt/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-BK2blxMI.js";
 //#region src/nuxt/index.d.ts
 /** The part of the Nitro instance this reads, handed over by `nitro:init`. */
 interface NitroLike {

package/dist/nuxt/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-DrS0Komf.js";
 import path from "node:path";
 //#region src/nuxt/index.ts
 function eaaKitModule(options = {}, nuxt) {

package/dist/{playwright-BojtYVUa.js → playwright-ukCr_5o3.js}

@@ -1,5 +1,5 @@
 import { r as isFile } from "./fs-BmPtmFke.js";
-import { a as failedPage, l as runOptions, n as DEFAULT_TAGS, s as pageUrl, u as shapeResults } from "./result-BWcYXeRs.js";
+import { c as pageUrl, d as runOptions, f as shapeResults, n as DEFAULT_TAGS, o as failedPage } from "./result-B7_zVxAX.js";
 import { createRequire } from "node:module";
 import { stat } from "node:fs/promises";
 import path from "node:path";
@@ -165,7 +165,8 @@ async function runBrowserAudit(directory, pages, options = {}) {
 	try {
 		const context = await browser.newContext({
 			viewport,
-			bypassCSP: true
+			bypassCSP: true,
+			...options.headers === void 0 ? {} : { extraHTTPHeaders: options.headers }
 		});
 		const audits = Array.from({ length: pages.length });
 		const lanes = Math.max(1, Math.min(options.concurrency ?? DEFAULT_CONCURRENCY, pages.length));

package/dist/{pool-BO25OIez.js → pool-B4tEUa2S.js}

@@ -1,5 +1,5 @@
 import { r as isFile } from "./fs-BmPtmFke.js";
-import { a as failedPage, s as pageUrl } from "./result-BWcYXeRs.js";
+import { c as pageUrl, o as failedPage } from "./result-B7_zVxAX.js";
 import { Worker } from "node:worker_threads";
 import { availableParallelism } from "node:os";
 //#region src/audit/runners/pool.ts
@@ -105,8 +105,12 @@ async function runPooledAudit(pages, options = {}) {
 	if (!entry) return auditHere(pages, runnerOptions);
 	return runWorkers(pages, runnerOptions, Math.min(workers, pages.length), entry);
 }
+/**
+* Audit in this process: the fallback for a run with no threads, and the sweep
+* for pages the threads never reported on.
+*/
 async function auditHere(pages, options) {
-	const { runJsdomAudit } = await import("./jsdom-22Bkt65v.js");
+	const { runJsdomAudit } = await import("./jsdom-BUYuVJJm.js");
 	return runJsdomAudit(pages, options);
 }
 /**

package/dist/{remediation-CMBIrnpN.js → remediation-C0klJblu.js}

@@ -1,6 +1,6 @@
-import { a as impactRank } from "./impact-DZt2oBCP.js";
+import { o as impactRank } from "./impact-luGCnN8F.js";
 import { t as elementFingerprint } from "./fingerprint-BjYV_0F7.js";
-import { o as findingElements } from "./result-BWcYXeRs.js";
+import { s as findingElements } from "./result-B7_zVxAX.js";
 //#region src/audit/completeness.ts
 /**
 * Fold what the collector knew together with what the engine managed.
@@ -10,14 +10,28 @@ import { o as findingElements } from "./result-BWcYXeRs.js";
 */
 function runCompleteness(audits, collection) {
 	const errored = audits.filter((audit) => audit.error).length;
+	const reused = audits.filter((audit) => audit.reused !== void 0).length;
 	return {
 		...collection,
-		audited: audits.length - errored,
+		audited: audits.length - errored - reused,
+		reused,
 		errored,
 		complete: collection.unreachable.length === 0 && !collection.truncated && errored === 0
 	};
 }
 /**
+* What a run reused, in one phrase, or nothing when it audited everything.
+*
+* Its own sentence rather than a clause in `missedParts`: nothing was missed
+* here. The pages have verdicts; they were reached on an earlier day, on markup
+* identical to today's, and a reader is entitled to know which.
+*/
+function reusedPart(completeness) {
+	if (completeness.reused === 0) return void 0;
+	const pages = completeness.reused === 1 ? "page" : "pages";
+	return `${completeness.reused} ${pages} unchanged since the last run, so the earlier result was reused`;
+}
+/**
 * What was missed, as phrases both reports print.
 *
 * Separate clauses rather than one total, for the same reason the coverage
@@ -95,6 +109,23 @@ function groupIssues(audits) {
 	return issues;
 }
 /**
+* What the grouped issues add up to: distinct elements, and the violations they
+* account for. Both reports open their issues section with these two numbers,
+* and say something different when they are equal.
+*/
+function issueTotals(issues) {
+	let elements = 0;
+	let occurrences = 0;
+	for (const issue of issues) {
+		elements += issue.elements.length;
+		occurrences += issue.occurrences;
+	}
+	return {
+		elements,
+		occurrences
+	};
+}
+/**
 * Unevaluated rules folded across the site, sorted by rule id.
 *
 * Both reports list these once at the end rather than under every page: on a
@@ -318,4 +349,4 @@ function remediationFor(ruleId, framework) {
 	};
 }
 //#endregion
-export { isShared as a, runCompleteness as c, groupIssues as i, blindRules as n, discoveryLabel as o, coverageParts as r, missedParts as s, remediationFor as t };
+export { isShared as a, missedParts as c, groupIssues as i, reusedPart as l, blindRules as n, issueTotals as o, coverageParts as r, discoveryLabel as s, remediationFor as t, runCompleteness as u };

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

@@ -1,9 +1,10 @@
-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-BaWMa-G_.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 { t as WCAG22_AA_CRITERIA } from "./criteria-CnPJKGeb.js";
 import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -20,6 +21,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
@@ -412,7 +514,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(country, locale), buildScope(config, locale, options.audit)));
+	const markdown = tidy(renderTemplate(await loadTemplate(country, locale), buildScope(config, locale, options)));
 	return {
 		markdown,
 		html: toHtmlDocument(markdown, {
@@ -442,7 +544,9 @@ function defaultLocale(config) {
 * template, which keeps the template language trivial and puts the mapping
 * somewhere that can be typechecked.
 */
-function buildScope(config, locale, audit) {
+function buildScope(config, locale, options) {
+	const audit = options.audit;
+	const review = options.review ? toReviewScope(options.review, locale) : void 0;
 	const issues = [...config.compliance.knownIssues.map((issue) => toIssueScope(issue, locale)), ...(audit?.findings ?? []).map((finding) => toFindingScope(finding, config.compliance.auditReason))];
 	return {
 		site: { ...config.site },
@@ -459,6 +563,8 @@ function buildScope(config, locale, audit) {
 		},
 		audit: audit ? toAuditScope(audit, locale) : void 0,
 		hasAudit: audit !== void 0,
+		review,
+		hasReview: review !== void 0,
 		hasKnownIssues: issues.length > 0,
 		hasNoKnownIssues: issues.length === 0
 	};
@@ -484,6 +590,39 @@ function toAuditScope(audit, locale) {
 		checkedOnFormatted: formatDate(audit.generatedAt.slice(0, 10), locale)
 	};
 }
+/**
+* What a person's review contributes to the "preparation" section.
+*
+* One fact: how many of WCAG 2.2's success criteria at A and AA somebody
+* checked by hand, and the last day one of those checks was recorded. It is
+* there because the automated sentences beside it describe a run that cannot
+* reach 34 of those 55 criteria, and a reader with no way to tell an unchecked
+* criterion from an unchecked-by-machine one is being told less than the truth.
+*
+* What it never says is what the review concluded. A recorded result is a claim
+* by a person, and the place for a claim in this document is the barrier list,
+* where a person writes it in their own words. Turning `not-met` into a
+* conformance sentence here would be this tool putting a legal position in
+* somebody's mouth.
+*
+* Returns undefined for a record nobody has answered yet — the ordinary state
+* of the file `eaa-kit checklist` has just written. Generating a worksheet is
+* not doing the review, and the audit report refuses to count it for the same
+* reason.
+*/
+function toReviewScope(record, locale) {
+	const answered = Object.values(record.criteria).filter((entry) => entry.result !== "unreviewed");
+	if (answered.length === 0) return void 0;
+	const latest = answered.map((entry) => entry.reviewedOn).filter((on) => on !== void 0).sort().at(-1);
+	return {
+		answered: answered.length,
+		total: WCAG22_AA_CRITERIA.length,
+		isSingle: answered.length === 1,
+		isPlural: answered.length > 1,
+		hasDate: latest !== void 0,
+		checkedOnFormatted: latest === void 0 ? "" : formatDate(latest, locale)
+	};
+}
 function toIssueScope(issue, locale) {
 	return {
 		...reasonScope(issue.reason),
@@ -614,4 +753,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-B7_zVxAX.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 { enClauses as a, pageUrl as c, runOptions as d, shapeResults as f, blindRulesInScope as i, ruleOutcomes as l, uniqueRuleOutcomes as m, DEFAULT_TAGS as n, failedPage as o, successCriteria as p, ENGINE_BLIND_RULES as r, findingElements as s, DEFAULT_PAGE_TIMEOUT_MS as t, runEngine as u };

package/dist/result-CRmjjoAA.js

@@ -0,0 +1,2 @@
+import { c as pageUrl } from "./result-B7_zVxAX.js";
+export { pageUrl };