@jitsusama/agentic-harness.core 0.1.0

package/dist/web/a11y/states.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The states an element is in, said the same way everywhere.
+ *
+ * The outline and the reading differ in layout but must not
+ * differ on facts: if one says a control is disabled, so does
+ * the other. Both ask this module.
+ */
+import type { AxNode } from "./tree.js";
+/** How the caller wants the states phrased. */
+export interface StateOptions {
+    /** Leave the heading level out, for a reader that says it with the role. */
+    readonly skipLevel?: boolean;
+}
+/**
+ * The states worth saying out loud, in a fixed order so two
+ * outlines of the same page read the same way.
+ *
+ * Only states that are in effect are reported. A field that is
+ * not required and not invalid is the ordinary case, and
+ * saying so on every line would bury the lines that matter.
+ */
+export declare function describeStates(node: AxNode, options?: StateOptions): string[];

package/dist/web/a11y/states.js

@@ -0,0 +1,53 @@
+/**
+ * The states an element is in, said the same way everywhere.
+ *
+ * The outline and the reading differ in layout but must not
+ * differ on facts: if one says a control is disabled, so does
+ * the other. Both ask this module.
+ */
+/**
+ * The states worth saying out loud, in a fixed order so two
+ * outlines of the same page read the same way.
+ *
+ * Only states that are in effect are reported. A field that is
+ * not required and not invalid is the ordinary case, and
+ * saying so on every line would bury the lines that matter.
+ */
+export function describeStates(node, options = {}) {
+    const { properties: props } = node;
+    const states = [];
+    if (props.level !== undefined && !options.skipLevel) {
+        states.push(`level ${props.level}`);
+    }
+    if (props.checked === "true")
+        states.push("checked");
+    if (props.checked === "mixed")
+        states.push("partially checked");
+    if (props.disabled === true)
+        states.push("disabled");
+    if (props.expanded === true)
+        states.push("expanded");
+    if (props.expanded === false)
+        states.push("collapsed");
+    if (props.selected === true)
+        states.push("selected");
+    if (props.required === true)
+        states.push("required");
+    if (isInvalid(props.invalid))
+        states.push("invalid");
+    if (props.readonly === true)
+        states.push("read only");
+    if (props.focused === true)
+        states.push("focused");
+    if (typeof props.live === "string" && props.live && props.live !== "off") {
+        states.push(`live ${props.live}`);
+    }
+    if (node.value !== undefined && node.value !== "") {
+        states.push(`value ${JSON.stringify(node.value)}`);
+    }
+    return states;
+}
+/** Chrome reports validity as a token, where "false" means valid. */
+function isInvalid(invalid) {
+    return invalid !== undefined && invalid !== false && invalid !== "false";
+}

package/dist/web/a11y/tree.d.ts

@@ -0,0 +1,124 @@
+/**
+ * The enriched accessibility tree.
+ *
+ * Chrome's accessibility tree is the page as assistive
+ * technology sees it. This normalizes a raw CDP capture into a
+ * tree that keeps what a screen reader would announce: not
+ * just role and name, but the states, values and levels that
+ * say what a control is doing right now.
+ *
+ * The input is plain serializable data, so a capture from
+ * anywhere (CDP, Playwright, a fixture on disk) can be
+ * analyzed by the same code.
+ */
+import { type NameSource } from "./naming.js";
+/** One way Chrome tried to name an element. */
+export interface RawAxNameSource {
+    type: string;
+    attribute?: string;
+    nativeSource?: string;
+    value?: {
+        type?: string;
+        value?: string | number;
+    };
+    /** Chrome found a name here but a higher-priority source won. */
+    superseded?: boolean;
+    /** The page pointed this source at something that is not there. */
+    invalid?: boolean;
+}
+/** A property Chrome reports against an accessibility node. */
+export interface RawAxProperty {
+    name: string;
+    value?: {
+        type?: string;
+        value?: string | number | boolean;
+    };
+}
+/** A raw CDP accessibility node (the fields we read). */
+export interface RawAxNode {
+    nodeId: string;
+    parentId?: string;
+    backendDOMNodeId?: number;
+    childIds?: string[];
+    role?: {
+        value?: string;
+    };
+    name?: {
+        value?: string;
+        sources?: RawAxNameSource[];
+    };
+    description?: {
+        value?: string;
+    };
+    value?: {
+        type?: string;
+        value?: string | number;
+    };
+    properties?: RawAxProperty[];
+    ignored?: boolean;
+}
+/** The states and relationships reported against a node. */
+export type AxProperties = Readonly<Record<string, string | number | boolean>>;
+/** A normalized accessibility node. */
+export interface AxNode {
+    readonly role: string;
+    readonly name: string;
+    /** CDP backend DOM node id, used internally to resolve an element. */
+    readonly backendDomId?: number;
+    /** The control's current value, when it has one. */
+    readonly value?: string | number;
+    /** Which mechanism produced the accessible name. */
+    readonly nameFrom?: NameSource;
+    readonly description?: string;
+    readonly properties: AxProperties;
+    readonly children: readonly AxNode[];
+}
+/**
+ * Normalize a raw CDP accessibility capture into a tree.
+ *
+ * A node the page does not expose is folded, not pruned: a real
+ * capture buries the whole document under ignored html and body
+ * wrappers, so its exposed children rise in its place.
+ *
+ * A text carrier whose name only repeats a named ancestor is
+ * folded away too: the page says "Save" once, so the tree should
+ * too. Text that no ancestor is named after is content, and
+ * survives.
+ */
+export declare function normalizeAxTree(nodes: readonly RawAxNode[]): AxNode;
+/**
+ * Whether a node says anything on its own. An unnamed wrapper
+ * does not: it is scaffolding the page needed and the reader
+ * does not. Rendering folds these away, and scoping does not
+ * count them as a level, so the two agree on what a level is.
+ */
+export declare function isMeaningful(node: AxNode): boolean;
+/** One frame's accessibility tree, and the element that holds it. */
+export interface FrameAxTree {
+    /** Backend DOM node id of the iframe element that owns the frame. */
+    readonly ownerBackendNodeId: number;
+    readonly nodes: readonly RawAxNode[];
+}
+/**
+ * Hang each frame's tree under the iframe element that owns it.
+ *
+ * Chrome answers for one frame at a time: the page's tree stops
+ * at an Iframe node with no children, and the frame's own tree
+ * arrives separately, rooted at its own RootWebArea. Left
+ * unjoined, every reading of the page ended at the boundary, and
+ * an outline, a structural audit or a keyboard walk simply did
+ * not contain what the frame held. Nothing said so, which is the
+ * worst part: an embedded checkout form read as an empty box.
+ *
+ * Every frame's nodes are renumbered on the way in. Both trees
+ * number from one, so merging them as they arrive makes the
+ * frame's root a duplicate of the page's, and a walk over the
+ * result either loses nodes or goes round forever.
+ *
+ * Frames whose owner is not present are dropped rather than
+ * attached to the root. That covers a cross-origin frame, which
+ * cannot be read at all, and a frame that went away while we were
+ * asking; inventing a parent for either would put content
+ * somewhere the page does not have it.
+ */
+export declare function spliceFrames(main: readonly RawAxNode[], frames: readonly FrameAxTree[]): RawAxNode[];

package/dist/web/a11y/tree.js

@@ -0,0 +1,269 @@
+/**
+ * The enriched accessibility tree.
+ *
+ * Chrome's accessibility tree is the page as assistive
+ * technology sees it. This normalizes a raw CDP capture into a
+ * tree that keeps what a screen reader would announce: not
+ * just role and name, but the states, values and levels that
+ * say what a control is doing right now.
+ *
+ * The input is plain serializable data, so a capture from
+ * anywhere (CDP, Playwright, a fixture on disk) can be
+ * analyzed by the same code.
+ */
+import { nameSource } from "./naming.js";
+/** An empty tree, for a capture with nothing in it. */
+const EMPTY = { role: "", name: "", properties: {}, children: [] };
+/**
+ * Roles whose node carries no meaning of its own: it exists to
+ * hold the text its parent is already named after.
+ */
+const TEXT_CARRIER_ROLES = new Set([
+    "StaticText",
+    "InlineTextBox",
+    "text",
+    "LabelText",
+]);
+/** Roles that exist to draw something, and say nothing. */
+const PRESENTATIONAL_ROLES = new Set(["ListMarker"]);
+/**
+ * Roles that are named by the text inside them.
+ *
+ * Only these can make a repeat of a text node below them, and
+ * the distinction is not pedantry. A container labelled from
+ * somewhere else, by aria-label or aria-labelledby, can be
+ * named the same as words it happens to contain: Wikipedia
+ * labels an article's body with the article's title, and the
+ * article opens with that title in bold. Folding on any named
+ * ancestor deleted the subject of the first sentence, which
+ * then read " is the design of products".
+ */
+const NAMED_FROM_CONTENT_ROLES = new Set([
+    "button",
+    "caption",
+    "cell",
+    "checkbox",
+    "columnheader",
+    "gridcell",
+    "heading",
+    "legend",
+    "link",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "radio",
+    "row",
+    "rowheader",
+    "switch",
+    "tab",
+    "tooltip",
+    "treeitem",
+]);
+/**
+ * Normalize a raw CDP accessibility capture into a tree.
+ *
+ * A node the page does not expose is folded, not pruned: a real
+ * capture buries the whole document under ignored html and body
+ * wrappers, so its exposed children rise in its place.
+ *
+ * A text carrier whose name only repeats a named ancestor is
+ * folded away too: the page says "Save" once, so the tree should
+ * too. Text that no ancestor is named after is content, and
+ * survives.
+ */
+export function normalizeAxTree(nodes) {
+    const byId = new Map(nodes.map((node) => [node.nodeId, node]));
+    const build = (id, namedAncestors) => {
+        const rawNode = byId.get(id);
+        if (!rawNode)
+            return [];
+        const role = rawNode.role?.value ?? "";
+        const name = rawNode.name?.value ?? "";
+        // An unexposed node is a wrapper as far as we are
+        // concerned: it contributes nothing itself, but what it
+        // contains may still be part of the page.
+        if (rawNode.ignored) {
+            return (rawNode.childIds ?? []).flatMap((childId) => build(childId, namedAncestors));
+        }
+        // A carrier repeating a name an ancestor already announced
+        // is a duplicate; its children repeat it too, so the whole
+        // branch goes.
+        if (TEXT_CARRIER_ROLES.has(role) && namedAncestors.includes(name)) {
+            return [];
+        }
+        // A line box is one rendered line of the text above it, so it
+        // repeats a fragment rather than the whole and never matches
+        // exactly. Containment is the test that catches it, and it is
+        // applied only to this role: a short StaticText can sit inside
+        // a longer name legitimately, whereas a line box never carries
+        // anything its parent's text does not already contain.
+        //
+        // When no ancestor announced the words, the line box is the
+        // only copy there is, which happens once its StaticText parent
+        // is ignored and its children rise. Then it stays.
+        if (role === "InlineTextBox" &&
+            namedAncestors.some((announced) => announced.includes(name))) {
+            return [];
+        }
+        if (PRESENTATIONAL_ROLES.has(role))
+            return [];
+        const value = rawNode.value?.value;
+        // The value is shown against the control itself, so text
+        // beneath it saying the same thing is a second copy.
+        // A carrier's name is its own text, so it announces too: that
+        // is what lets its line boxes fold into it.
+        const announces = name &&
+            (NAMED_FROM_CONTENT_ROLES.has(role) || TEXT_CARRIER_ROLES.has(role));
+        const spoken = announces ? [...namedAncestors, name] : namedAncestors;
+        const inherited = value === undefined ? spoken : [...spoken, String(value)];
+        const children = dropRepeatedText((rawNode.childIds ?? []).flatMap((childId) => build(childId, inherited)));
+        const backend = rawNode.backendDOMNodeId;
+        const description = rawNode.description?.value;
+        // Only say where a name came from when the capture
+        // actually reported the mechanisms it tried.
+        const from = rawNode.name?.sources ? nameSource(rawNode) : undefined;
+        return [
+            {
+                role,
+                name,
+                ...(backend !== undefined ? { backendDomId: backend } : {}),
+                ...(value !== undefined ? { value } : {}),
+                ...(from ? { nameFrom: from } : {}),
+                ...(description ? { description } : {}),
+                properties: readProperties(rawNode),
+                children,
+            },
+        ];
+    };
+    const root = nodes.find((node) => !node.parentId) ?? nodes[0];
+    if (!root)
+        return EMPTY;
+    return build(root.nodeId, [])[0] ?? EMPTY;
+}
+/**
+ * Drop text among a set of siblings that another sibling has
+ * already announced. A label sits beside the control it names,
+ * so its text reaches the caller through the control and does
+ * not need a line of its own.
+ */
+function dropRepeatedText(siblings) {
+    const spokenElsewhere = new Set(siblings
+        .filter((node) => !isTextOnly(node))
+        .map((node) => node.name)
+        .filter((name) => name.length > 0));
+    if (spokenElsewhere.size === 0)
+        return [...siblings];
+    return siblings.filter((node) => !(isTextOnly(node) && spokenElsewhere.has(carriedText(node))));
+}
+/** Whether a node is nothing but the text it carries. */
+function isTextOnly(node) {
+    if (!TEXT_CARRIER_ROLES.has(node.role))
+        return false;
+    return node.children.every(isTextOnly);
+}
+/**
+ * The text a carrier presents. A label holds its words in a
+ * child rather than its own name, so read through to them.
+ */
+function carriedText(node) {
+    if (node.name)
+        return node.name;
+    return node.children.map(carriedText).join("").trim();
+}
+/** Roles that add no meaning on their own and are folded away when unnamed. */
+const NOISE_ROLES = new Set([
+    "generic",
+    "none",
+    "presentation",
+    "document",
+    "RootWebArea",
+    "InlineTextBox",
+    "StaticText",
+    "text",
+]);
+/**
+ * Whether a node says anything on its own. An unnamed wrapper
+ * does not: it is scaffolding the page needed and the reader
+ * does not. Rendering folds these away, and scoping does not
+ * count them as a level, so the two agree on what a level is.
+ */
+export function isMeaningful(node) {
+    if (node.name.trim().length > 0)
+        return true;
+    return !NOISE_ROLES.has(node.role);
+}
+/** Collect a node's reported properties into a flat record. */
+function readProperties(node) {
+    const properties = {};
+    for (const property of node.properties ?? []) {
+        const value = property.value?.value;
+        if (value !== undefined)
+            properties[property.name] = value;
+    }
+    return properties;
+}
+/**
+ * Hang each frame's tree under the iframe element that owns it.
+ *
+ * Chrome answers for one frame at a time: the page's tree stops
+ * at an Iframe node with no children, and the frame's own tree
+ * arrives separately, rooted at its own RootWebArea. Left
+ * unjoined, every reading of the page ended at the boundary, and
+ * an outline, a structural audit or a keyboard walk simply did
+ * not contain what the frame held. Nothing said so, which is the
+ * worst part: an embedded checkout form read as an empty box.
+ *
+ * Every frame's nodes are renumbered on the way in. Both trees
+ * number from one, so merging them as they arrive makes the
+ * frame's root a duplicate of the page's, and a walk over the
+ * result either loses nodes or goes round forever.
+ *
+ * Frames whose owner is not present are dropped rather than
+ * attached to the root. That covers a cross-origin frame, which
+ * cannot be read at all, and a frame that went away while we were
+ * asking; inventing a parent for either would put content
+ * somewhere the page does not have it.
+ */
+export function spliceFrames(main, frames) {
+    if (frames.length === 0)
+        return [...main];
+    const merged = main.map((node) => ({ ...node }));
+    const byBackendId = new Map();
+    for (const node of merged) {
+        if (node.backendDOMNodeId !== undefined) {
+            byBackendId.set(node.backendDOMNodeId, node);
+        }
+    }
+    // In order, so a frame nested inside another is spliced after
+    // its parent frame has been merged and its owner is findable.
+    frames.forEach((frame, index) => {
+        const owner = byBackendId.get(frame.ownerBackendNodeId);
+        if (!owner)
+            return;
+        const prefix = `f${index}:`;
+        const rename = (id) => `${prefix}${id}`;
+        const renamed = frame.nodes.map((node) => ({
+            ...node,
+            nodeId: rename(node.nodeId),
+            ...(node.parentId === undefined
+                ? {}
+                : { parentId: rename(node.parentId) }),
+            ...(node.childIds === undefined
+                ? {}
+                : { childIds: node.childIds.map(rename) }),
+        }));
+        const root = renamed.find((node) => node.parentId === undefined);
+        if (!root)
+            return;
+        root.parentId = owner.nodeId;
+        owner.childIds = [...(owner.childIds ?? []), root.nodeId];
+        for (const node of renamed) {
+            merged.push(node);
+            if (node.backendDOMNodeId !== undefined) {
+                byBackendId.set(node.backendDOMNodeId, node);
+            }
+        }
+    });
+    return merged;
+}

package/dist/web/a11y/walk.d.ts

@@ -0,0 +1,225 @@
+/**
+ * The keyboard walk: what a person who never touches a mouse
+ * can actually reach.
+ *
+ * Every finding here comes from what the browser did when Tab
+ * was pressed, not from reading markup and predicting what it
+ * ought to do. A focus trap written by hand, a positive tabindex
+ * reordering the page, a div wearing a button's clothes: none of
+ * these are visible in the markup as bugs, and all of them are
+ * obvious the moment you try to tab through.
+ *
+ * The one judgment that is presentational, and labelled as such,
+ * is whether a focus indicator exists: that is decided by
+ * comparing what the browser computed for the element at rest
+ * against what it computed with focus on it. Whether the
+ * resulting indicator is bright enough to see is a contrast
+ * question, and belongs with the contrast audit rather than
+ * here; this module records the indicator so that audit can
+ * judge it.
+ */
+/** The style properties a focus indicator could live in. */
+export interface FocusStyle {
+    readonly outlineStyle: string;
+    readonly outlineWidth: string;
+    readonly outlineColor: string;
+    readonly boxShadow: string;
+    readonly backgroundColor: string;
+    readonly borderColor: string;
+    readonly color: string;
+}
+/** Something the browser says can hold focus. */
+export interface WalkCandidate {
+    /** Position in document order, and the identity used throughout. */
+    readonly index: number;
+    readonly tag: string;
+    readonly id?: string;
+    readonly role?: string;
+    readonly name: string;
+    readonly tabindex?: number;
+    /** Inside an open dialog that is holding focus on purpose. */
+    readonly inModal?: boolean;
+    readonly resting: FocusStyle;
+}
+/** Where focus actually landed, once. */
+export interface WalkStop {
+    /** The candidate this is, or -1 when focus left them all. */
+    readonly index: number;
+    readonly tag: string;
+    readonly id?: string;
+    readonly name: string;
+    readonly inViewport: boolean;
+    /** Inside an open dialog that is holding focus on purpose. */
+    readonly inModal?: boolean;
+    readonly focused: FocusStyle;
+    /** Where it sits, when the browser gave it a box. */
+    readonly rect?: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+}
+/** Two controls on one line that tab against the way they read. */
+export interface VisualJump {
+    readonly before: WalkStop;
+    readonly after: WalkStop;
+}
+/**
+ * Tab order that contradicts the order things are read in.
+ *
+ * Only same-line inversions, and deliberately so. The general
+ * question, whether tab order follows the visual flow of the
+ * page, cannot be answered without deciding whether a layout is
+ * meant to be read in rows or in columns, and a two-column form
+ * that tabs down one column and then the other is both extremely
+ * common and perfectly correct. A check that flagged it would be
+ * wrong far more often than right, and a false accessibility
+ * finding costs more than a missing one.
+ *
+ * Two controls side by side, tabbed in the opposite order to the
+ * one they are read in, has no such excuse. It is what
+ * row-reverse and hand-set order values do, and the keyboard
+ * order it produces contradicts the page for everybody.
+ */
+export declare function outOfVisualOrder(stops: readonly WalkStop[], direction: "ltr" | "rtl"): readonly VisualJump[];
+/** Something that behaves interactively but cannot be reached. */
+export interface Unreachable {
+    readonly tag: string;
+    readonly role?: string;
+    readonly name: string;
+    /** What made it look interactive. */
+    readonly because: string;
+}
+/** Everything the driver observed while walking. */
+export interface WalkCapture {
+    readonly candidates: readonly WalkCandidate[];
+    readonly stops: readonly WalkStop[];
+    readonly unreachable: readonly Unreachable[];
+    /** Whether pressing Escape freed focus, when it was stuck. */
+    readonly escapeFreed?: boolean;
+    /** True when the walk stopped at its cap rather than cycling. */
+    readonly cappedAt?: number;
+    /** Which way the page reads, from the document itself. */
+    readonly direction?: "ltr" | "rtl";
+}
+/** Where a focus indicator lives, if anywhere. */
+export type Indicator = "outline" | "boxShadow" | "background" | "border" | "colour" | "none";
+/** A focus ring that is there and cannot be seen. */
+export interface FaintIndicator {
+    readonly stop: WalkStop;
+    /** Against what it is drawn on, where 2.4.11 asks for 3. */
+    readonly ratio: number;
+}
+/** A group of stops focus could not get out of. */
+export interface Trap {
+    readonly members: readonly WalkStop[];
+    readonly escapeFreed: boolean;
+    /**
+     * Controls outside the cycle, which is what makes it a trap.
+     *
+     * Not the same as the walk's `missed`: these may well have been
+     * visited on the way in. What matters is that focus cannot get
+     * back to them once it is inside.
+     */
+    readonly stranded: readonly WalkCandidate[];
+}
+/** What the walk found. */
+export interface WalkFindings {
+    readonly stops: readonly WalkStop[];
+    readonly trap?: Trap;
+    /** Focusable things the walk never arrived at. */
+    readonly missed: readonly WalkCandidate[];
+    /** Stops whose appearance does not change when focused. */
+    readonly noIndicator: readonly WalkStop[];
+    /**
+     * Stops whose indicator exists but is too faint to make out.
+     *
+     * Kept apart from `noIndicator` because the repair differs: one
+     * needs a rule written, the other needs a colour changed.
+     */
+    readonly faintIndicator: readonly FaintIndicator[];
+    /**
+     * Pairs on one line that tab against the way they read.
+     *
+     * Undecided rather than failed: the geometry is certain, but
+     * whether it confuses anyone is a judgement about the page.
+     */
+    readonly outOfOrder: readonly VisualJump[];
+    /** Where the indicator lives, for those that have one. */
+    readonly indicators: ReadonlyMap<number, Indicator>;
+    /** Stops that were focused while off screen. */
+    readonly offscreen: readonly WalkStop[];
+    /** Candidates with a positive tabindex, which reorders the page. */
+    readonly positiveTabindex: readonly WalkCandidate[];
+    readonly unreachable: readonly Unreachable[];
+    /** True when the tab order does not follow document order. */
+    readonly reordered: boolean;
+    /**
+     * The stop budget, when the walk ran out of it.
+     *
+     * Set means the page was not walked to the end, so anything in
+     * `missed` is unvisited rather than unreachable and cannot be
+     * counted as a failure.
+     */
+    readonly cappedAt?: number;
+    /** True when focus stayed inside a dialog that meant to hold it. */
+    readonly modalHeldFocus: boolean;
+}
+/**
+ * Where the focus indicator lives, by comparing rest with focus.
+ *
+ * This is the honest test, and the only one that survives
+ * contact with real pages: not whether the author wrote an
+ * outline rule, but whether the browser draws anything
+ * differently when the element has focus.
+ */
+export declare function indicatorOf(resting: FocusStyle, focused: FocusStyle): Indicator;
+/** What judging a focus indicator's visibility concluded. */
+export interface IndicatorVerdict {
+    readonly standing: "pass" | "fail" | "undecided";
+    readonly ratio?: number;
+    readonly reason: string;
+}
+/**
+ * Whether a focus indicator can actually be seen.
+ *
+ * The walk decides an indicator exists by seeing the computed
+ * style change. That is a weaker claim than it sounds, and the
+ * gap between the two is where the real defect lives: a ring in
+ * a colour a shade off the background satisfies every existence
+ * check ever written and still leaves someone unable to tell
+ * where they are. WCAG 2.4.11 puts the bar at 3:1 against what
+ * the indicator is drawn against, which is the same bar 1.4.11
+ * sets for any control's own colours.
+ *
+ * Only an outline is judged. A box shadow can be any number of
+ * layers offset in any direction, a background or colour change
+ * moves the very surface the comparison would use, and in
+ * neither case does the computed value say which pixels changed.
+ * Those come back undecided, which is this package's word for a
+ * question it will not answer by guessing. A transparent surface
+ * is undecided for the same reason: the colour behind the ring
+ * belongs to some ancestor the computed style does not name, and
+ * compositing against a guess is how a page gets accused of a
+ * failure it does not have.
+ */
+export declare function judgeIndicator(input: {
+    readonly indicator: Indicator;
+    readonly resting: FocusStyle;
+    readonly focused: FocusStyle;
+}): IndicatorVerdict;
+/** Read the walk. */
+export declare function analyseWalk(capture: WalkCapture): WalkFindings;
+/**
+ * How many of anything else is worth naming before counting.
+ *
+ * The tab order has always stopped at forty and said how many
+ * more there were. The finding lists beside it printed every
+ * entry, so one article answered with two hundred and fifty
+ * unvisited control names, longer than the rest of the report
+ * together and mostly repetitions of the same word.
+ */
+export declare const MAX_LISTED_FINDINGS = 12;
+/** The walk, as a person would report it. */
+export declare function renderWalk(findings: WalkFindings): string;