eaa-kit 0.3.0 → 0.4.0

package/dist/cli/index.js

@@ -1,14 +1,18 @@
 #!/usr/bin/env node
-import { l as STATEMENT_LOCALES, o as COUNTRIES, r as loadConfig, s as ConfigError } from "../load-UYXLqGV9.js";
-import { i as readAuditReport, o as StatementError, t as renderStatement } from "../render-DI_aCnAZ.js";
-import { n as IMPACT_LEVELS, t as DEFAULT_FAIL_ON } from "../impact-YdoOtFqm.js";
-import { n as count } from "../text-BFmNtMsV.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-s9F3fXTN.js";
-import { n as runAuditCommand, r as resolvePages, t as OUTPUT_FORMATS } from "../audit-DcL73mOC.js";
-import { a as runEngine, i as note, n as emitDocument, r as fail, t as advise } from "../command-Dxpa00Ha.js";
+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";
 //#region src/cli/baseline.ts
 /**
 * `eaa-kit baseline [dir]`.
@@ -80,6 +84,255 @@ async function runBaselineCommand(dir, options = {}) {
 		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. */
@@ -178,7 +431,7 @@ 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("--manual", "what to check by hand for the rules this engine cannot evaluate").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, flags) => {
+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,
@@ -186,12 +439,16 @@ program.command("audit").description("Audit built HTML against WCAG 2.2 AA").arg
 	});
 	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, flags) => {
+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("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-DiLiYvN1.js");
+	const { runInitCommand } = await import("../init-DIWDE35F.js");
 	const { exitCode } = await runInitCommand(flags);
 	process.exitCode = exitCode;
 });

package/dist/{collect-BkAQ0viT.js → collect-CFM8gEVv.js}

@@ -46,7 +46,8 @@ async function collectPages(dir, options = {}) {
 	const pages = [];
 	for (let i = 0; i < relativePaths.length; i += READ_CONCURRENCY) {
 		const batch = relativePaths.slice(i, i + READ_CONCURRENCY);
-		pages.push(...await Promise.all(batch.map((relativePath) => readPage(root, relativePath))));
+		const read = await Promise.all(batch.map((relativePath) => readPage(root, relativePath, options.onUnreadable)));
+		for (const page of read) if (page !== void 0) pages.push(page);
 	}
 	return pages;
 }
@@ -60,13 +61,19 @@ async function assertDirectory(root, original) {
 	}
 	if (!stats.isDirectory()) throw new BuildDirectoryError(`Build path is not a directory: ${original}`, root);
 }
-async function readPage(root, relativePath) {
+async function readPage(root, relativePath, onUnreadable) {
 	const absolutePath = path.join(root, relativePath);
-	return {
-		absolutePath,
-		relativePath,
-		html: stripBom(await readFile(absolutePath, "utf8"))
-	};
+	try {
+		return {
+			absolutePath,
+			relativePath,
+			html: stripBom(await readFile(absolutePath, "utf8"))
+		};
+	} catch (cause) {
+		if (onUnreadable === void 0) throw cause;
+		onUnreadable(relativePath, cause.message);
+		return;
+	}
 }
 /**
 * What to suggest when a directory holds no HTML, or is not there at all.
@@ -79,8 +86,8 @@ async function readPage(root, relativePath) {
 */
 async function emptyDirectoryHint(dir, cwd = process.cwd()) {
 	const head = await exists(dir, cwd) ? `${dir} holds no HTML files.` : `${dir} does not exist.`;
-	const { detectFramework } = await import("./frameworks-DaDqrJOw.js");
-	const { readPackageJson } = await import("./project-DW08TseF.js");
+	const { detectFramework } = await import("./frameworks-etFg_O8K.js");
+	const { readPackageJson } = await import("./project-MFrXcw1M.js");
 	const detected = await detectFramework(cwd, await readPackageJson(cwd));
 	if (detected !== void 0) return frameworkAdvice(head, detected, cwd, dir);
 	return await siblingAdvice(head, cwd, dir) ?? generic(head);
@@ -91,6 +98,10 @@ async function frameworkAdvice(head, detected, cwd, dir) {
 	const given = dir.replace(/^\.\//, "");
 	for (const output of outputs) if (output !== given && await exists(output, cwd)) return `${head} ${framework.name} writes to ${output}/, not ${dir}.\n  Try: eaa-kit audit ./${output}`;
 	const lines = [`${head} This is ${article(framework.name)} ${framework.name} project.`];
+	if (outputs.length === 0) {
+		lines.push(`  It renders every page on a server and writes no HTML to disk, so there is`, `  no build directory to audit. Start it, then audit what it serves:`, ...framework.serveCommand === void 0 ? [] : [`    ${framework.serveCommand}`], "    eaa-kit audit --url http://localhost:8000");
+		return lines.join("\n");
+	}
 	if (framework.staticOutput !== void 0) lines.push(`  Static output takes ${framework.staticOutput.needs} — ${framework.staticOutput.how},`, `  then: eaa-kit audit ./${outputs[0]}`);
 	else if (outputs.length === 1 && outputs[0] === given) lines.push(`  That is where it writes, so the build has not run yet — or it failed.`);
 	else lines.push(`  It writes to ${outputs.map((output) => `${output}/`).join(" or ")}. Run your build, then:`, `    eaa-kit audit ./${outputs[0]}`);
@@ -99,7 +110,7 @@ async function frameworkAdvice(head, detected, cwd, dir) {
 }
 /** Naming a build directory that is actually there beats listing the usual ones. */
 async function siblingAdvice(head, cwd, dir) {
-	const { FALLBACK_OUTPUTS } = await import("./frameworks-DaDqrJOw.js");
+	const { FALLBACK_OUTPUTS } = await import("./frameworks-etFg_O8K.js");
 	const given = dir.replace(/^\.\//, "");
 	const others = (await Promise.all(FALLBACK_OUTPUTS.map(async (name) => name !== given && await exists(name, cwd) ? name : void 0))).filter((name) => name !== void 0);
 	if (others.length === 0) return void 0;

package/dist/{command-Dxpa00Ha.js → command-D8l_oYbV.js}

@@ -42,13 +42,13 @@ async function runEngine(pages, options) {
 		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
 	};
 	if (!options.browser) {
-		const { runPooledAudit } = await import("./pool-BWkWZiJW.js");
+		const { runPooledAudit } = await import("./pool-BMevaLWD.js");
 		return runPooledAudit(pages, {
 			...runnerOptions,
 			...options.concurrency === void 0 ? {} : { concurrency: options.concurrency }
 		});
 	}
-	const { BrowserUnavailableError, runBrowserAudit } = await import("./playwright-DYFsGUNd.js");
+	const { BrowserUnavailableError, runBrowserAudit } = await import("./playwright-BWniOain.js");
 	try {
 		return await runBrowserAudit(options.directory, pages, runnerOptions);
 	} catch (cause) {

package/dist/{component-7kEBjv_y.js → component-C3GL1Mnu.js}

@@ -1,5 +1,5 @@
 import { i as toPosix } from "./fs-BmPtmFke.js";
-import { t as collapse } from "./text-BFmNtMsV.js";
+import { t as collapse } from "./text-CKKpzkYM.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { glob } from "tinyglobby";
@@ -96,16 +96,51 @@ function searchTermsFor(html) {
 * Returns undefined when nothing matches and when more than one does. The
 * second case is the important one: naming a file that merely happens to
 * contain the same path sends somebody to edit the wrong component.
+*
+* The position comes free. The search already has to find the literal to know
+* the file contains it, so recording where it found it costs one more scan of
+* one string — and a report that says `Header.astro:12` opens an editor where a
+* report that says `Header.astro` starts a search.
 */
 function componentFor(index, html) {
 	for (const term of searchTermsFor(html)) {
 		const matches = [];
-		for (const [file, source] of index.files) if (source.includes(term)) {
-			matches.push(file);
-			if (matches.length > 1) break;
+		for (const [file, source] of index.files) {
+			const offset = source.indexOf(term);
+			if (offset !== -1) {
+				matches.push({
+					file,
+					offset
+				});
+				if (matches.length > 1) break;
+			}
+		}
+		const only = matches.length === 1 ? matches[0] : void 0;
+		if (only !== void 0) {
+			const source = index.files.get(only.file);
+			return {
+				file: only.file,
+				...positionOf(source, only.offset)
+			};
 		}
-		if (matches.length === 1) return matches[0];
 	}
 }
+/** 1-based line and column of a byte offset in a source file. */
+function positionOf(source, offset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let i = 0; i < offset; i += 1) if (source[i] === "\n") {
+		line += 1;
+		lineStart = i + 1;
+	}
+	return {
+		line,
+		column: offset - lineStart + 1
+	};
+}
+/** `components/Header.astro:12`, as both reports name a component. */
+function componentPath(location) {
+	return `${location.file}:${location.line}`;
+}
 //#endregion
-export { buildComponentIndex, componentFor };
+export { searchTermsFor as i, componentFor as n, componentPath as r, buildComponentIndex as t };

package/dist/component-DKd3EHOg.js

@@ -0,0 +1,2 @@
+import { n as componentFor, t as buildComponentIndex } from "./component-C3GL1Mnu.js";
+export { buildComponentIndex, componentFor };