@jitsusama/agentic-harness.core 0.1.0

package/dist/web/audit/sweep.js

@@ -0,0 +1,117 @@
+/**
+ * Running a check under several conditions at once.
+ *
+ * Most layout and contrast faults are conditional. A page is
+ * fine at 1280 and unusable at 375; a colour pair passes in
+ * light and fails in dark. Checking one condition and reporting
+ * a pass is how those ship.
+ *
+ * The table comes first and the detail second, because the
+ * useful question is almost never "what is wrong" but "where
+ * does it start going wrong". A run of passes ending in two
+ * failures at the narrow end says more than either verdict does
+ * alone.
+ */
+import { renderVerdict } from "./verdict.js";
+/** The worst standing among several. */
+export function worstOf(standings) {
+    if (standings.includes("fail"))
+        return "fail";
+    return standings.includes("warn") ? "warn" : "pass";
+}
+const MARK = {
+    pass: "pass",
+    warn: "warn",
+    fail: "FAIL",
+};
+/**
+ * Say where a sweep started going wrong.
+ *
+ * Conditions are reported in the order they were run, never
+ * sorted by severity, because their order is the finding: a
+ * table that reads pass, pass, fail, fail names a breakpoint,
+ * and the same rows sorted worst-first name nothing.
+ */
+export function renderSweep(conditions, options = {}) {
+    if (conditions.length === 0) {
+        return renderVerdict({ standing: "warn", headline: "No conditions were swept." }, "");
+    }
+    if (options.only) {
+        const found = conditions.find((condition) => condition.label === options.only);
+        return found
+            ? found.detail
+            : `Nothing was run at '${options.only}'. Ran: ${conditions
+                .map((condition) => condition.label)
+                .join(", ")}.`;
+    }
+    const standing = worstOf(conditions.map((condition) => condition.standing));
+    const failing = conditions.filter((condition) => condition.standing === "fail");
+    const width = Math.max(...conditions.map((condition) => condition.label.length));
+    const rows = conditions.map((condition) => `  ${condition.label.padEnd(width)}  ${MARK[condition.standing].padEnd(4)}  ${condition.headline}`);
+    return renderVerdict({
+        standing,
+        headline: headlineFor(conditions, failing),
+        measured: `Ran the same check under ${conditions.length} conditions.`,
+    }, [...rows, "", "Name a condition to see its report in full."].join("\n"));
+}
+function headlineFor(conditions, failing) {
+    if (failing.length === 0) {
+        const warned = conditions.filter((condition) => condition.standing === "warn");
+        return warned.length === 0
+            ? `Clean under all ${conditions.length} conditions.`
+            : `Nothing failed, but ${warned.length} of ${conditions.length} ` +
+                "conditions raised something.";
+    }
+    if (failing.length === conditions.length) {
+        return `Fails under all ${conditions.length} conditions.`;
+    }
+    // Naming the boundary is the point of sweeping at all.
+    return `Fails at ${listOf(failing.map((condition) => condition.label))}, and passes elsewhere.`;
+}
+/** Join names the way a person would say them aloud. */
+function listOf(names) {
+    if (names.length <= 1)
+        return names[0] ?? "";
+    return `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`;
+}
+/** The widths a sweep uses when the caller names none. */
+export const DEFAULT_WIDTHS = [375, 768, 1280, 1920];
+/** Turn a list of widths into conditions to sweep. */
+export function widthsToSweep(widths = DEFAULT_WIDTHS) {
+    return widths.map((width) => ({
+        label: `${width}px`,
+        setting: { width },
+    }));
+}
+/**
+ * Read a verdict's standing back out of a rendered report.
+ *
+ * A report that carries no verdict head reads as "warn", never
+ * "pass". This defaulted to pass once, and because two drill-down
+ * renderers returned bare prose, a swept rule query reported PASS
+ * at every width while the named rule was failing at all of them.
+ * Approval is the one answer a parser must never invent: prefer
+ * the standing a caller passes as data, and treat this as the
+ * fallback for prose we did not produce.
+ */
+export function standingOf(report) {
+    if (report.startsWith("FAIL"))
+        return "fail";
+    if (report.startsWith("PASS"))
+        return "pass";
+    return "warn";
+}
+/** Read a verdict's headline back out of a rendered report. */
+export function headlineOf(report) {
+    const first = report.split("\n")[0] ?? "";
+    return first.replace(/^(PASS|WARN|FAIL)\s+/, "");
+}
+/** Build a condition from a rendered report. */
+export function conditionFrom(label, report) {
+    return {
+        label,
+        standing: standingOf(report),
+        headline: headlineOf(report),
+        detail: report,
+    };
+}

package/dist/web/audit/target.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Judging how big a thing you have to hit is.
+ *
+ * WCAG 2.2 added Target Size (Minimum) at 24 by 24 CSS pixels,
+ * and it is more interesting than a measurement because of its
+ * exceptions. A small target sitting in open space passes; the
+ * same target crowded against its neighbours does not. Checking
+ * the size and skipping the spacing rule would fail links in
+ * prose and pass a row of cramped icon buttons, which is
+ * precisely backwards.
+ */
+import type { Rect } from "../element/box.js";
+import type { A11yFinding } from "./axe.js";
+/**
+ * Something a person is expected to hit.
+ *
+ * Named for the criterion rather than called a Target, because
+ * a target elsewhere in this library is an element named by
+ * role and accessible name so it can be acted on. Two meanings
+ * for one word in one library is a trap worth avoiding.
+ */
+export interface HitTarget {
+    readonly id: string;
+    readonly rect: Rect;
+    /**
+     * Whether the target sits in a line of text, which the
+     * specification excepts outright. Inline is a fact about
+     * layout and must come from the browser, never from a guess
+     * about the element's tag.
+     */
+    readonly inline?: boolean;
+    /** Whether the browser, not the page, decides its size. */
+    readonly userAgentControlled?: boolean;
+    /** Whether the page offers the same action somewhere bigger. */
+    readonly hasLargerAlternative?: boolean;
+    /** Whether this exact size is essential to what it does. */
+    readonly essential?: boolean;
+}
+/** 2.5.8 Target Size (Minimum), level AA. */
+export declare const MINIMUM_TARGET_PX = 24;
+/** 2.5.5 Target Size (Enhanced), level AAA. */
+export declare const ENHANCED_TARGET_PX = 44;
+/** Which of the two target-size criteria is being applied. */
+export type TargetLevel = "AA" | "AAA";
+/** Why an undersized target is nonetheless allowed. */
+export type TargetException = "inline" | "user-agent" | "alternative" | "essential" | "spacing";
+/** What was concluded about one target. */
+export interface TargetVerdict {
+    readonly id: string;
+    readonly width: number;
+    readonly height: number;
+    readonly required: number;
+    readonly passes: boolean;
+    /** Present when it is undersized but excepted. */
+    readonly exception?: TargetException;
+    /** What it is crowded by, when spacing is what failed it. */
+    readonly crowdedBy?: readonly string[];
+}
+/**
+ * Judge one target against its neighbours.
+ *
+ * The order of the exceptions follows the specification: the
+ * outright ones are checked before the spacing rule, since a
+ * target that is excepted for being inline is never measured
+ * against its neighbours at all.
+ */
+export declare function judgeTarget(target: HitTarget, neighbours: readonly HitTarget[], level?: TargetLevel): TargetVerdict;
+/** Judge every target against every other. */
+export declare function judgeTargets(targets: readonly HitTarget[], level?: TargetLevel): readonly TargetVerdict[];
+/** Say what the target sweep found. */
+export declare function renderTargets(verdicts: readonly TargetVerdict[]): string;
+/**
+ * A captured target, as the page reports it.
+ *
+ * Carries the selector alongside the facts the judgment needs,
+ * so a finding can point at something a reader can find.
+ */
+export interface CapturedTarget extends HitTarget {
+    readonly selector: string;
+}
+/**
+ * Turn target verdicts into findings, so they merge with the
+ * rest of the accessibility report instead of living apart.
+ *
+ * Failures are violations of a real criterion. An excepted
+ * target is not reported at all: the exception is the criterion
+ * working as written, not a thing to look at.
+ */
+export declare function targetFindings(targets: readonly CapturedTarget[], level?: TargetLevel): readonly A11yFinding[];

package/dist/web/audit/target.js

@@ -0,0 +1,168 @@
+/**
+ * Judging how big a thing you have to hit is.
+ *
+ * WCAG 2.2 added Target Size (Minimum) at 24 by 24 CSS pixels,
+ * and it is more interesting than a measurement because of its
+ * exceptions. A small target sitting in open space passes; the
+ * same target crowded against its neighbours does not. Checking
+ * the size and skipping the spacing rule would fail links in
+ * prose and pass a row of cramped icon buttons, which is
+ * precisely backwards.
+ */
+/** 2.5.8 Target Size (Minimum), level AA. */
+export const MINIMUM_TARGET_PX = 24;
+/** 2.5.5 Target Size (Enhanced), level AAA. */
+export const ENHANCED_TARGET_PX = 44;
+function centre(rect) {
+    return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+}
+/** Whether a target is under the size the rule asks for. */
+function undersized(target, required) {
+    return target.rect.width < required || target.rect.height < required;
+}
+/**
+ * Whether an undersized target's circle clashes with a
+ * neighbour.
+ *
+ * The rule is two rules wearing one name. An undersized
+ * target's circle must not intersect another target, meaning
+ * that target's actual box, and must not intersect the circle
+ * of another undersized target. Treating every neighbour as a
+ * circle passes a small control sitting hard against the edge
+ * of a large one, which is exactly the crowding the criterion
+ * exists to catch.
+ */
+function clashes(target, other, required) {
+    const radius = required / 2;
+    const from = centre(target.rect);
+    if (undersized(other, required)) {
+        const to = centre(other.rect);
+        return Math.hypot(from.x - to.x, from.y - to.y) < required;
+    }
+    // Against a full-size neighbour it is the circle against that
+    // neighbour's box: the nearest point of the box to the centre.
+    const nearestX = Math.max(other.rect.x, Math.min(from.x, other.rect.x + other.rect.width));
+    const nearestY = Math.max(other.rect.y, Math.min(from.y, other.rect.y + other.rect.height));
+    return Math.hypot(from.x - nearestX, from.y - nearestY) < radius;
+}
+/**
+ * Judge one target against its neighbours.
+ *
+ * The order of the exceptions follows the specification: the
+ * outright ones are checked before the spacing rule, since a
+ * target that is excepted for being inline is never measured
+ * against its neighbours at all.
+ */
+export function judgeTarget(target, neighbours, level = "AA") {
+    const required = level === "AAA" ? ENHANCED_TARGET_PX : MINIMUM_TARGET_PX;
+    const { width, height } = target.rect;
+    const base = { id: target.id, width, height, required };
+    if (width >= required && height >= required) {
+        return { ...base, passes: true };
+    }
+    // The outright exceptions do not care about the neighbours.
+    const excepted = outrightException(target);
+    if (excepted)
+        return { ...base, passes: true, exception: excepted };
+    // Enhanced has no spacing exception; it is a plain minimum.
+    if (level === "AAA")
+        return { ...base, passes: false };
+    const crowdedBy = neighbours
+        .filter((other) => other.id !== target.id)
+        .filter((other) => clashes(target, other, required))
+        .map((other) => other.id);
+    if (crowdedBy.length === 0) {
+        return { ...base, passes: true, exception: "spacing" };
+    }
+    return { ...base, passes: false, crowdedBy };
+}
+function outrightException(target) {
+    if (target.inline)
+        return "inline";
+    if (target.userAgentControlled)
+        return "user-agent";
+    if (target.hasLargerAlternative)
+        return "alternative";
+    if (target.essential)
+        return "essential";
+    return undefined;
+}
+/** Judge every target against every other. */
+export function judgeTargets(targets, level = "AA") {
+    return targets.map((target) => judgeTarget(target, targets, level));
+}
+/** How many failures to name before summarising the rest. */
+const MAX_NAMED = 10;
+/** Say what the target sweep found. */
+export function renderTargets(verdicts) {
+    if (verdicts.length === 0)
+        return "No targets to measure.";
+    const failed = verdicts.filter((verdict) => !verdict.passes);
+    const excepted = verdicts.filter((verdict) => verdict.exception);
+    const required = verdicts[0]?.required ?? MINIMUM_TARGET_PX;
+    if (failed.length === 0) {
+        const tail = excepted.length === 0
+            ? ""
+            : ` ${excepted.length} were under ${required} pixels but excepted.`;
+        return `All ${verdicts.length} targets meet ${required} by ${required}.${tail}`;
+    }
+    const lines = [
+        `${failed.length} of ${verdicts.length} targets are smaller than ` +
+            `${required} by ${required} with nothing excepting them.`,
+        "",
+    ];
+    for (const verdict of failed.slice(0, MAX_NAMED)) {
+        const size = `${round(verdict.width)} by ${round(verdict.height)}`;
+        const crowd = verdict.crowdedBy && verdict.crowdedBy.length > 0
+            ? `, crowded by ${verdict.crowdedBy.join(", ")}`
+            : "";
+        lines.push(`  ${verdict.id}  ${size}${crowd}`);
+    }
+    if (failed.length > MAX_NAMED) {
+        lines.push(`  ... and ${failed.length - MAX_NAMED} more`);
+    }
+    return lines.join("\n");
+}
+function round(value) {
+    return Math.round(value * 10) / 10;
+}
+/**
+ * Turn target verdicts into findings, so they merge with the
+ * rest of the accessibility report instead of living apart.
+ *
+ * Failures are violations of a real criterion. An excepted
+ * target is not reported at all: the exception is the criterion
+ * working as written, not a thing to look at.
+ */
+export function targetFindings(targets, level = "AA") {
+    const byId = new Map(targets.map((target) => [target.id, target]));
+    const failed = judgeTargets(targets, level).filter((verdict) => !verdict.passes);
+    if (failed.length === 0)
+        return [];
+    const required = failed[0]?.required ?? MINIMUM_TARGET_PX;
+    return [
+        {
+            rule: "target-is-big-enough",
+            kind: "violation",
+            impact: "serious",
+            authority: "wcag",
+            criteria: [level === "AAA" ? "2.5.5" : "2.5.8"],
+            levels: [level],
+            help: `A pointer target smaller than ${required} by ${required} ` +
+                "pixels, with no larger alternative and not enough clear " +
+                "space around it to be excepted.",
+            nodes: failed.map((verdict) => ({
+                selector: byId.get(verdict.id)?.selector ?? verdict.id,
+                html: "",
+                messages: [
+                    `Measured ${Math.round(verdict.width)} by ` +
+                        `${Math.round(verdict.height)} pixels` +
+                        (verdict.crowdedBy && verdict.crowdedBy.length > 0
+                            ? `, and too close to ${verdict.crowdedBy.length} other ` +
+                                `${verdict.crowdedBy.length === 1 ? "target" : "targets"} to be excepted for spacing.`
+                            : "."),
+                ],
+            })),
+        },
+    ];
+}

package/dist/web/audit/verdict.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The one line every check answers with.
+ *
+ * Five kinds of check produce five shapes of evidence, and a
+ * reader should not have to learn five ways of asking "is this
+ * all right". Every one of them now opens with the same three
+ * words and the same headline.
+ *
+ * A clean result reports what was measured rather than saying
+ * nothing. "No violations" and "no violations across 340
+ * elements and 91 rules" are the same verdict and very different
+ * reassurances: the first is what a broken checker also says.
+ */
+/** How a check came out. */
+export type Standing = "pass" | "warn" | "fail";
+/**
+ * Say a count with the noun that agrees with it.
+ *
+ * Lives with the verdict rather than in one report, because every
+ * check writes these sentences and "1 stops are hard to follow"
+ * is the kind of thing that makes a reader trust the numbers less
+ * than they should.
+ */
+export declare function count(many: number, one: string, plural?: string): string;
+/** The verb that agrees with a count, for the same reason. */
+export declare function wasWere(many: number): string;
+/** The head of any check's answer. */
+export interface Verdict {
+    readonly standing: Standing;
+    /** One line, said plainly, with the numbers behind it. */
+    readonly headline: string;
+    /** What was looked at, so a clean pass is not a shrug. */
+    readonly measured?: string;
+}
+/** Put a verdict at the head of a report. */
+export declare function renderVerdict(verdict: Verdict, body: string): string;
+/**
+ * Whether anything found was severe enough to fail.
+ *
+ * A thing nobody could decide is a warning, never a pass. That
+ * is the whole reason it is reported separately: an automated
+ * check that turns its own uncertainty into approval is worse
+ * than no check.
+ */
+export declare function standingFor(counts: {
+    readonly failures: number;
+    readonly warnings: number;
+}): Standing;

package/dist/web/audit/verdict.js

@@ -0,0 +1,52 @@
+/**
+ * The one line every check answers with.
+ *
+ * Five kinds of check produce five shapes of evidence, and a
+ * reader should not have to learn five ways of asking "is this
+ * all right". Every one of them now opens with the same three
+ * words and the same headline.
+ *
+ * A clean result reports what was measured rather than saying
+ * nothing. "No violations" and "no violations across 340
+ * elements and 91 rules" are the same verdict and very different
+ * reassurances: the first is what a broken checker also says.
+ */
+/**
+ * Say a count with the noun that agrees with it.
+ *
+ * Lives with the verdict rather than in one report, because every
+ * check writes these sentences and "1 stops are hard to follow"
+ * is the kind of thing that makes a reader trust the numbers less
+ * than they should.
+ */
+export function count(many, one, plural = `${one}s`) {
+    return `${many} ${many === 1 ? one : plural}`;
+}
+/** The verb that agrees with a count, for the same reason. */
+export function wasWere(many) {
+    return many === 1 ? "was" : "were";
+}
+const MARK = {
+    pass: "PASS",
+    warn: "WARN",
+    fail: "FAIL",
+};
+/** Put a verdict at the head of a report. */
+export function renderVerdict(verdict, body) {
+    const head = `${MARK[verdict.standing]}  ${verdict.headline}`;
+    const measured = verdict.measured === undefined ? "" : `\n${verdict.measured}`;
+    return body === "" ? `${head}${measured}` : `${head}${measured}\n\n${body}`;
+}
+/**
+ * Whether anything found was severe enough to fail.
+ *
+ * A thing nobody could decide is a warning, never a pass. That
+ * is the whole reason it is reported separately: an automated
+ * check that turns its own uncertainty into approval is worse
+ * than no check.
+ */
+export function standingFor(counts) {
+    if (counts.failures > 0)
+        return "fail";
+    return counts.warnings > 0 ? "warn" : "pass";
+}

package/dist/web/audit/visual.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Rules about what the layout actually did.
+ *
+ * A visual linter earns its keep or loses it on false positives.
+ * Every rule here reports only where the browser's own numbers
+ * leave no room for argument, and two well-known deliberate
+ * idioms are recognised rather than reported: content parked far
+ * off to the left, and the one-pixel clipped box used to hide
+ * text from sight but not from a screen reader. Flagging those
+ * would train the reader to ignore the whole report.
+ *
+ * Where a judgment is presentational rather than measured, it
+ * says so at the rule. Whether eight pixel text is too small is
+ * an opinion; whether an image failed to load is not.
+ */
+import { HIDDEN_BOX_PX } from "../snapshot/presented.js";
+import type { A11yFinding } from "./axe.js";
+/**
+ * The viewport WCAG 1.4.10 Reflow is specified at.
+ *
+ * The criterion asks that content reflow at 320 CSS pixels, so a
+ * capture wider than this has not tested it and must not cite
+ * it. A little headroom above 320 keeps a 375px phone capture,
+ * the usual narrow case, inside the claim.
+ */
+export declare const REFLOW_WIDTH = 400;
+/** One element as the layout rules need to see it. */
+export interface VisualNode {
+    readonly id: string;
+    readonly selector: string;
+    readonly tag: string;
+    /** Position and size in the page, from the browser. */
+    readonly rect: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+    /** What the content wants, against what the box gives it. */
+    readonly scrollWidth: number;
+    readonly scrollHeight: number;
+    readonly clientWidth: number;
+    readonly clientHeight: number;
+    readonly overflowX: string;
+    readonly overflowY: string;
+    readonly fontSizePx: number;
+    readonly clipPath: string;
+    /** "ellipsis" when text is deliberately truncated with one. */
+    readonly textOverflow?: string;
+    /** A line count when the text is deliberately clamped. */
+    readonly lineClamp?: string;
+    /** How an image fills its box: cover and contain crop, they do not squash. */
+    readonly objectFit?: string;
+    /** An image's own dimensions, zero when it failed to load. */
+    readonly naturalWidth?: number;
+    readonly naturalHeight?: number;
+    /** Whether the browser finished trying to load it. */
+    readonly complete?: boolean;
+    readonly src?: string;
+    /** Text this element holds directly, trimmed. */
+    readonly text?: string;
+}
+/**
+ * The page as a whole, which some rules need.
+ *
+ * Named PageBox rather than Viewport because it carries the
+ * document's full extent as well as the visible area, and
+ * because a Viewport elsewhere in this library means only the
+ * part a person can see.
+ */
+export interface PageBox {
+    readonly width: number;
+    readonly height: number;
+    readonly documentWidth: number;
+    readonly documentHeight: number;
+    /**
+     * How far the page was scrolled when this was captured.
+     *
+     * Rects are recorded in document coordinates, and a screenshot
+     * is in viewport coordinates. Anything joining the two needs
+     * the offset between them, and without it a visual diff
+     * attributed its regions to whatever happened to sit at those
+     * coordinates at the top of the page.
+     */
+    readonly scrollX?: number;
+    readonly scrollY?: number;
+}
+/** Below this, text is hard to read for many people. */
+export declare const SMALL_TEXT_PX = 10;
+/** How far an image's shape may differ before it looks wrong. */
+export declare const ASPECT_TOLERANCE = 0.1;
+/**
+ * A box no larger than this is a hiding technique, not content.
+ *
+ * Owned by the page-side module that embeds it into the probes, so
+ * the threshold the browser is measured against and the one this
+ * analysis judges by cannot drift apart. Re-exported here because
+ * this is where consumers have always found it.
+ */
+export { HIDDEN_BOX_PX };
+/**
+ * Whether an element is using a known way of hiding text from
+ * sight while leaving it to a screen reader.
+ *
+ * This is pattern recognition, not measurement: the browser has
+ * no notion of a visually-hidden idiom. It is here because the
+ * alternative is reporting every correctly built skip link on
+ * every page, which would make the clipping rule worthless.
+ */
+export declare function isVisuallyHidden(node: VisualNode): boolean;
+/**
+ * The page scrolls sideways.
+ *
+ * Almost always a mistake, and a serious one on a narrow screen,
+ * where it makes every line of text require two-directional
+ * scrolling to read.
+ */
+export declare function horizontalOverflow(nodes: readonly VisualNode[], viewport: PageBox): readonly A11yFinding[];
+/**
+ * Content cut off by the box it sits in.
+ *
+ * Measured, not guessed: the browser reports what the content
+ * wanted and what the box gave it, and a difference with
+ * overflow hidden means the rest is gone with no way to reach
+ * it.
+ */
+export declare function clippedContent(nodes: readonly VisualNode[]): readonly A11yFinding[];
+/**
+ * Elements that escaped to the right of the document.
+ *
+ * Off to the left is the old way of hiding something, and does
+ * not extend the page. Off to the right does, so it drags the
+ * whole document wider and is nearly always an accident.
+ */
+export declare function escapedElements(nodes: readonly VisualNode[], viewport: PageBox): readonly A11yFinding[];
+/**
+ * Images that did not load.
+ *
+ * The browser is unambiguous about this: it finished trying and
+ * has no dimensions to show for it.
+ */
+export declare function brokenImages(nodes: readonly VisualNode[]): readonly A11yFinding[];
+/**
+ * Images drawn at a shape they were not.
+ *
+ * Measured against the image's own dimensions, so this is a
+ * comparison rather than an opinion; only the tolerance is
+ * chosen.
+ */
+export declare function distortedImages(nodes: readonly VisualNode[]): readonly A11yFinding[];
+/**
+ * Text below a readable size.
+ *
+ * Presentational judgment, and labelled as one. WCAG sets no
+ * minimum font size, because it requires the page to survive
+ * being zoomed instead. This is here because text this small is
+ * usually an accident rather than a decision.
+ */
+export declare function tinyText(nodes: readonly VisualNode[]): readonly A11yFinding[];
+/** Every layout rule, run against one capture. */
+export declare function analyseVisual(nodes: readonly VisualNode[], viewport: PageBox): readonly A11yFinding[];