testaro 71.0.3 → 72.1.0

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git branch *)",
+      "Bash(git add *)",
+      "Bash(git commit -m ' *)",
+      "Bash(git push *)"
+    ]
+  },
+  "outputStyle": "Explanatory"
+}

package/CLAUDE.md

@@ -0,0 +1,116 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+```bash
+# Install / update all dependencies and Playwright browsers
+npm run deps
+
+# Build the bundled accessible-name computation script
+npm run build
+
+# Lint (ESLint)
+npx eslint .
+
+# Validate a single Testaro rule (replace <ruleID> with the rule name, e.g. allSlanted)
+npm test <ruleID>
+
+# Validate all Testaro rules
+npm run tests
+
+# Run a job from JOBDIR/todo (optionally prefix-match by timestamp)
+node call run [jobIDStart]
+
+# Watch a directory for jobs
+node call dirWatch <true|false> <intervalSeconds>
+
+# Poll a network server for jobs
+node call netWatch <true|false> <intervalSeconds> [<true|false>]
+```
+
+## Architecture
+
+Testaro is an ensemble accessibility test runner. It integrates 10 external tools plus ~50 of its own rules (the "testaro" tool) and produces standardized reports from a job document.
+
+### Job → Report lifecycle
+
+1. A caller provides a **job** — a plain JS/JSON object with a `target` URL, `browserID`, optional `device`, and an `acts` array.
+2. `run.js` exports `doJob(job)`, which validates the job (`procs/job.js`), builds a DOM **catalog** (`procs/catalog.js`), then delegates to `procs/doActs.js`.
+3. `doActs.js` iterates the acts array. For `test` acts it forks a child process running `procs/doTestAct.js` (one per tool invocation) and enforces per-tool time limits. Non-test acts (browser interactions) execute in the parent.
+4. Each tool's test module lives in `tests/<toolID>.js`. It calls the tool's library and converts the native result to the **standard result** shape (`prevented`, `totals[4]`, `instances[]`).
+5. `doJob` returns the job object with `jobData` and `catalog` added at the top level and `result` added inside each `test` act. The job's `standard` property controls what `result` contains: `'no'` → `nativeResult` only; `'only'` → `standardResult` only; `'also'` → both.
+
+The 18 act types are defined and documented in `actSpecs.js` (`etc` property). The main interactive types are `button`, `checkbox`, `focus`, `link`, `press`, `presses`, `radio`, `reveal`, `search`, `select`, `text`, `url`, `wait`. The `test` type runs a tool. `launch`, `next`, `page`, `state` control flow.
+
+### Testaro rules (`testaro/` directory)
+
+Each file exports a `reporter(page, catalog, withItems)` async function. Rules are registered in `tests/testaro.js` in the `allRules` array, which controls default execution order, contamination flags, time limits, and `defaultOn`.
+
+The default order in `allRules` reflects a two-phase execution strategy: non-contaminating rules (`contaminates: false`) come first and all share a single page load; contaminating rules (`contaminates: true`) follow, each tested on a freshly loaded copy of the page.
+
+Two rules, `shoot0` and `shoot1`, are atypical: they report no violations. Instead they take screenshots at different points during a job so that the `motion` rule can compare them to detect and measure visible page change, avoiding the latency that would be required if `motion` took its own screenshots and waited between them.
+
+Two implementation patterns exist:
+
+- **`doTest`** (`procs/testaro.js`): for rules whose verdict on each element can be computed in-browser via `page.evaluate`. The caller passes a CSS selector and a serialized `getBadWhat(element)` function string. This is the preferred pattern (~48 of ~50 rules).
+- **`getBasicResult`** (`procs/testaro.js`): for rules that need Playwright APIs or cross-element state (currently only `hover` and `role`).
+
+### Validation
+
+Validation is currently broken. A reconsideration of its architecture is anticipated, but in the meantime the next paragraph describes its current inoperative design.
+
+Validation tests live in `validation/tests/jobs/` (jobs with `expect` arrays) and `validation/tests/targets/` (static HTML pages served locally as test targets). Running `npm test <ruleID>` executes `validation/executors/test.js` → `validation/validateTest.js`, which runs the job and compares `result` fields against `expect` clauses.
+
+### Tool XPath strategy
+
+The catalog maps XPaths to element metadata. Each tool uses a different approach to report the elements it flags:
+
+- `alfa`, `aslint`: report their own XPaths; Testaro normalizes them.
+- `ed11y`, `wave`: Testaro injects `window.getXPath` and calls it per element.
+- `axe`, `htmlcs`, `ibm`, `nuVal`, `nuVnu`, `qualWeb`: Testaro stamps `data-xpath` attributes on all elements before the tool runs.
+- `testaro`: each rule reports XPaths directly.
+
+### Environment (`.env`)
+
+Key variables:
+
+- `HEADED_BROWSER` — show browser windows during tests
+- `DEBUG` — mirror browser console to terminal
+- `WAITS` — ms delay inserted between Playwright operations (useful for debugging)
+- `WAVE_KEY` — API key for the WAVE subscription API
+- `JOBDIR` / `REPORTDIR` — root directories for job files and report output
+- `AGENT` — instance name used in network-watch mode
+- `NETWATCH_URL_<N>_JOB/OBSERVE/REPORT/AUTH`, `NETWATCH_URLS` — server polling configuration
+- `TIMEOUT_MULTIPLIER` — scales all per-tool time limits (default 1)
+
+## Code style
+
+ESLint (`eslintrc.json`): 2-space indent, single quotes, semicolons, Stroustrup brace style (`else`/`catch` on a new line after `}`), `no-use-before-define`. The `htmlcs/HTMLCS.js` file uses a separate, looser ESLint config and must not be reformatted.
+
+Long comments are not broken into multiple lines per paragraph.
+
+## Adding a new Testaro rule
+
+1. Add an entry to `allRules` in `tests/testaro.js`.
+2. Create `testaro/<ruleID>.js` exporting a `reporter` function using `doTest` (preferred) or `getBasicResult`.
+3. Write a validation job in `validation/tests/jobs/<ruleID>.json` with an `expect` array and corresponding HTML target(s) in `validation/tests/targets/<ruleID>/`.
+4. Run `npm test <ruleID>` until validation passes.
+
+## Key files
+
+| File | Purpose |
+| ---- | ------- |
+| `run.js` | `doJob()` — the main entry point |
+| `call.js` | CLI wrapper for `run`, `dirWatch`, `netWatch` |
+| `procs/doActs.js` | Iterates acts; forks child for each tool |
+| `procs/doTestAct.js` | Child-process entry point for tool invocations |
+| `procs/testaro.js` | `doTest` / `getBasicResult` helpers for Testaro rules |
+| `procs/launch.js` | Browser lifecycle (launch, goTo, nonce, wait) |
+| `procs/catalog.js` | Builds the element catalog from the DOM |
+| `procs/job.js` | Job validation; `tools` constant |
+| `actSpecs.js` | Canonical specs for all 18 act types |
+| `tests/testaro.js` | `allRules` registry for the testaro tool |
+| `testaro/<ruleID>.js` | One file per Testaro rule |
+| `validation/validateTest.js` | Core validation harness |

package/README.md

@@ -502,7 +502,9 @@ The `testaro` tool (like the `ibm` tool) has a `withItems` property. If you set
 
 Unlike any other tool, the `testaro` tool requires a `stopOnFail` property, which specifies whether a failure to conform to any rule (i.e. any value of `totals` other than `[0, 0, 0, 0]`) should terminate the execution of tests for the remaining rules.
 
-Tests of the `testaro` tests (i.e. _validation_) can be performed as documented in the `VALIDATION.md` file.
+Tests of the `testaro` tests (i.e. _validation_) could previously be performed as documented in the `VALIDATION.md` file. This functionality has broken and its redesign is planned.
+
+One Testaro rule, `allCaps`, is currently being tested for in part with the assistance of the Claude Haiku artificial intelligence (AI) model. To obtain that assistance, you need an Anthropic API key, and its value must be assigned to the `ANTHROPIC_API_KEY` environment variable in the `.env` file. If no valid API key is set there, the rule will be tested for, but without AI assistance.
 
 ### WAVE
 

package/UPGRADES.md

@@ -809,7 +809,7 @@ You're absolutely right about `nuVal`'s limitations. Since it requires publicly
 
 1. **`htmlcs`** - Pure JavaScript, no external dependencies, works on any HTML
 2. **`wave`** - Also API-based, so same limitations as `nuVal`
-4. **`axe`** - Self-contained, works on any page, excellent for establishing patterns
+3. **`axe`** - Self-contained, works on any page, excellent for establishing patterns
 
 **I recommend starting with `axe`** because:
 

package/memory/MEMORY.md

@@ -0,0 +1,3 @@
+# Memory Index
+
+- [Validation system paused](project_validation_pause.md) — new validation tests on hold pending redesign of broken validation architecture

package/memory/project_validation_pause.md

@@ -0,0 +1,10 @@
+---
+name: Validation system paused
+description: All new validation test work is on hold pending a redesign of the currently broken validation architecture
+type: project
+---
+
+New validation tests and updates to existing validation tests are paused. The validation system is currently broken and a redesign is anticipated. Do not create or modify files in validation/tests/ until the user indicates the redesign is underway.
+
+**Why:** The validation architecture is broken and being reconsidered.
+**How to apply:** Skip validation file creation/updates when adding or modifying Testaro rules until further notice.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testaro",
-  "version": "71.0.3",
+  "version": "72.1.0",
   "description": "Run 1000 web accessibility tests from 11 tools and get a standardized report",
   "main": "index.js",
   "scripts": {

package/procs/launch.js

@@ -82,10 +82,10 @@ const browserClose = exports.browserClose = async page => {
 };
 // Visits a URL and returns the response of the server.
 const goTo = exports.goTo = async (report, page, url, timeout, waitUntil) => {
-  // If the URL is a file path:
+  // If the URL is a file path relative to the project root:
   if (url.startsWith('file://')) {
-    // Make it absolute.
-    url = url.replace('file://', `file://${__dirname}/`);
+    // Make it the absolute path to the specified file.
+    url = url.replace('file://', `file://${__dirname}/../`);
   }
   // Visit the URL.
   const startTime = Date.now();

package/procs/testaro.js

@@ -39,7 +39,7 @@ exports.doTest = async (
       getBadWhatString
     ] = args;
     // Get all violator candidates.
-    const candidates = document.body.querySelectorAll(candidateSelector);
+    const candidates = document.querySelectorAll(candidateSelector);
     let violationCount = 0;
     // Initialize proto-instances.
     const protoInstances = [];

package/testaro/adbID.js

@@ -57,6 +57,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Elements have aria-describedby attributes with missing or invalid id values';
   return await doTest(
-    page, catalog, withItems, 'adbID', '[aria-describedby]', whats, 3, getBadWhat.toString()
+    page, catalog, withItems, 'adbID', 'body [aria-describedby]', whats, 3, getBadWhat.toString()
   );
 };

package/testaro/allCapStyle.js

@@ -0,0 +1,51 @@
+/*
+  © 2023 CVS Health and/or one of its affiliates. All rights reserved.
+  © 2025–2026 Jonathan Robert Pool.
+
+  Licensed under the MIT License. See LICENSE file at the project root or https://opensource.org/license/mit/ for details.
+
+  SPDX-License-Identifier: MIT
+*/
+
+/*
+  allCapStyle
+  Related to Tenon rule 153.
+  This test reports elements with transformed upper-case text. Blocks of upper-case text are difficult to read.
+*/
+
+// IMPORTS
+
+const {doTest} = require('../procs/testaro');
+
+// FUNCTIONS
+
+// Runs the test and returns the result.
+exports.reporter = async (page, catalog, withItems) => {
+  const getBadWhat = element => {
+    // Get the style declaration of the element.
+    const styleDec = window.getComputedStyle(element);
+    const {textTransform} = styleDec;
+    // If the style declaration transforms the element text to upper case:
+    if (textTransform === 'uppercase') {
+      const parent = element.parentElement;
+      // If the element has a parent:
+      if (parent) {
+        // Get the style declaration of the parent.
+        const parentStyleDec = window.getComputedStyle(parent);
+        const {textTransform: parentTextTransform} = parentStyleDec;
+        // If the style declaration transforms the parent text to upper case:
+        if (parentTextTransform === 'uppercase') {
+          // Do not report a violation, because the transformation may be inherited.
+          return null;
+        }
+      }
+      // If it has no parent or its transformation is autonomous, return a violation description.
+      return 'Element text is transformed into all-capitals';
+    }
+  };
+  const selector = 'body, body *:not(style, script, svg)';
+  const whats = 'Elements have an all-capital text transformation style';
+  return await doTest(
+    page, catalog, withItems, 'allCapStyle', selector, whats, 0, getBadWhat.toString()
+  );
+};

package/testaro/allCaps.js

@@ -10,47 +10,180 @@
 /*
   allCaps
   Related to Tenon rule 153.
-  This test reports elements with native or transformed upper-case text at least 8 characters long. Blocks of upper-case text are difficult to read.
+  This test reports elements whose text contains upper-case strings that are not intrinsically upper-case (i.e., not acronyms, abbreviations, or terms whose standard form is all-capitals). Claude Haiku classifies qualifying catalog entries and estimates the probability of a rule violation. If the AI call fails, the test falls back to a rule-based check for 8+ consecutive upper-case letters.
 */
 
 // IMPORTS
 
-const {doTest} = require('../procs/testaro');
+const https = require('https');
+
+// PARAMETERS
+
+const MIN_CONFIDENCE = 0.5;
+const MAX_MARGIN = 100;
+const MAX_TOTAL = 2000;
+const MAX_QUALIFYING = 100;
+
+// CONSTANTS
+
+const ruleID = 'allCaps';
+const whats = 'Elements have all-capital text';
 
 // FUNCTIONS
 
-// Runs the test and returns the result.
-exports.reporter = async (page, catalog, withItems) => {
-  const getBadWhat = element => {
-    // Get the child text nodes of the element.
-    const childTextNodes = Array.from(element.childNodes).filter(
-      node => node.nodeType === Node.TEXT_NODE
-    );
-    // Get the concatenation of their texts that contain 8 or more consecutive letters.
-    let longText = childTextNodes
-    .map(node => node.nodeValue.trim())
-    .filter(text => /[A-Z]{8,}/i.test(text))
-    .join(' ');
-    // If there is any:
-    if (longText) {
-      // Get the style declaration of the element.
-      const styleDec = window.getComputedStyle(element);
-      const {textTransform} = styleDec;
-      // If the style declaration transforms the text to upper case:
-      if (textTransform === 'uppercase') {
-        // Return a violation description.
-        return 'Element text is rendered as all-capital';
+// Returns text limited to MAX_MARGIN characters before the first and after the last uppercase match, capped at MAX_TOTAL characters.
+const getContext = text => {
+  const matches = [...text.matchAll(/\p{Lu}{2,}/gu)];
+  const first = matches[0];
+  const last = matches[matches.length - 1];
+  const start = Math.max(0, first.index - MAX_MARGIN);
+  const end = Math.min(text.length, last.index + last[0].length + MAX_MARGIN);
+  return text.slice(start, end).slice(0, MAX_TOTAL);
+};
+
+// Returns violations using the rule-based fallback (8+ consecutive uppercase letters).
+const getRuleBasedViolations = catalog =>
+  Object.entries(catalog)
+    .filter(([, entry]) => entry.text && /\p{Lu}{8,}/u.test(entry.text))
+    .map(([index]) => ({
+      catalogIndex: index,
+      what: '[No AI available] Element contains all-capital text'
+    }));
+
+// Sends qualifying entries to Claude Haiku and returns confidence scores.
+const classifyWithAI = entries => new Promise((resolve, reject) => {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    reject(new Error('ANTHROPIC_API_KEY not set'));
+    return;
+  }
+  const prompt =
+    'Classify HTML elements for an accessibility rule. All-capital text violates the rule UNLESS it is an acronym, abbreviation, or term whose standard form is all-capitals (NASA, WHO, etc.).\n\n'
+    + 'For each element, give a confidence score (0.0–1.0, rounded to one decimal place) for the probability that the element VIOLATES the rule (its all-caps text is NOT intrinsically all-caps).\n\n'
+    + 'Respond with ONLY a JSON array. Each element: {"index": <number>, "confidence": <number>}\n\n'
+    + 'Elements:\n'
+    + JSON.stringify(entries);
+  const payload = JSON.stringify({
+    model: 'claude-haiku-4-5-20251001',
+    max_tokens: 2048,
+    messages: [{role: 'user', content: prompt}]
+  });
+  const options = {
+    hostname: 'api.anthropic.com',
+    path: '/v1/messages',
+    method: 'POST',
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+      'content-type': 'application/json',
+      'content-length': Buffer.byteLength(payload)
+    }
+  };
+  const req = https.request(options, res => {
+    let body = '';
+    res.on('data', chunk => { body += chunk; });
+    res.on('end', () => {
+      try {
+        const parsed = JSON.parse(body);
+        if (parsed.error) {
+          reject(new Error(parsed.error.message));
+          return;
+        }
+        const text = parsed.content[0].text;
+        resolve(
+          [...text.matchAll(/\{"index":\s*\d+,\s*"confidence":\s*[01]\.\d{1,2}\}/g)]
+          .map(m => {
+            const {index, confidence} = JSON.parse(m[0]);
+            return {index, confidence: Math.round(confidence * 10) / 10};
+          })
+        );
       }
-      // Otherwise, if the text contains 8 or more consecutive upper-case letters:
-      if (/[A-Z]{8,}/.test(longText)) {
-        // Return a violation description.
-        return 'Element contains all-capital text';
+      catch(error) {
+        reject(new Error(`Haiku response error: ${error.message}`));
       }
+    });
+  });
+  req.on('error', reject);
+  req.setTimeout(20000, () => req.destroy(new Error('Haiku API timeout')));
+  req.write(payload);
+  req.end();
+});
+
+// Runs the test and returns the result.
+exports.reporter = async (_, catalog, withItems) => {
+  const data = {};
+  const totals = [0, 0, 0, 0];
+  const standardInstances = [];
+  // Get data on the catalog entries whose text values contain 2+ consecutive capital letters.
+  const qualifying = Object.entries(catalog)
+  .filter(([, entry]) => entry.text && /\p{Lu}{2,}/u.test(entry.text))
+  .map(([index, entry]) => ({
+    index: Number(index),
+    tagName: entry.tagName,
+    text: getContext(entry.text)
+  }));
+  // If there are none:
+  if (!qualifying.length) {
+    // Report this.
+    return {data, totals, standardInstances};
+  }
+  // Sort them, with unbiased (Fisher–Yates) randomization.
+  const sample = qualifying.slice();
+  for (let i = sample.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [sample[i], sample[j]] = [sample[j], sample[i]];
+  }
+  // If their count exceeds the limit on AI assistance:
+  if (sample.length > MAX_QUALIFYING) {
+    // Truncate them.
+    sample.length = MAX_QUALIFYING;
+  }
+  let violations;
+  try {
+    // Get AI estimates of the probabilities of their violating the rule.
+    const classifications = await classifyWithAI(sample);
+    // Treat the entries with above-minimum violation confidence levels as violations.
+    violations = classifications
+    .filter(({confidence}) => confidence >= MIN_CONFIDENCE)
+    .map(({index, confidence}) => ({
+      catalogIndex: String(index),
+      what: `Element contains unnecessarily (with confidence ${Math.round(confidence * 100)}%) all-capital text`
+    }));
+    const evaluated = classifications.length;
+    const leftOut = qualifying.length - evaluated;
+    // If any entries were truncated out and any AI confidence levels were above-minimum:
+    if (leftOut > 0 && evaluated > 0) {
+      // Add data about the estimated violation rate among those entries.
+      data.leftOut = {
+        count: leftOut,
+        estimatedViolations: Math.round((violations.length / evaluated) * leftOut)
+      };
     }
-  };
-  const selector = 'body *:not(style, script, svg)';
-  const whats = 'Elements have all-capital text';
-  return await doTest(
-    page, catalog, withItems, 'allCaps', selector, whats, 0, getBadWhat.toString()
-  );
+  }
+  catch(error) {
+    data.aiError = error.message;
+    violations = getRuleBasedViolations(catalog);
+  }
+  const estimatedLeftOut = data.leftOut?.estimatedViolations ?? 0;
+  // Add the estimated violation count to the totals.
+  totals[0] = violations.length + estimatedLeftOut;
+  // If itemization is required:
+  if (withItems) {
+    // For each entry deemed a violation:
+    for (const {catalogIndex, what} of violations) {
+      // Add an instance to the standard instances.
+      standardInstances.push({ruleID, what, ordinalSeverity: 0, count: 1, catalogIndex});
+    }
+    // If any entries were truncated:
+    if (estimatedLeftOut) {
+      // Add a summary instance for them.
+      standardInstances.push({ruleID, what: whats, ordinalSeverity: 0, count: estimatedLeftOut});
+    }
+  }
+  // Otherwise, i.e. if itemization is not required, and if any violations exist:
+  else if (totals[0]) {
+    // Add a summary instance for them.
+    standardInstances.push({ruleID, what: whats, ordinalSeverity: 0, count: totals[0]});
+  }
+  return {data, totals, standardInstances};
 };

package/testaro/allSlanted.js

@@ -26,11 +26,23 @@ exports.reporter = async (page, catalog, withItems) => {
     const {textContent} = element;
     // If the element contains 40 or more characters of slanted text:
     if (['italic', 'oblique'].includes(styleDec.fontStyle) && textContent.length > 39) {
-      // Return a violation description.
+      const parent = element.parentElement;
+      // If the element has a parent:
+      if (parent) {
+        // Get the style declaration of the parent.
+        const parentStyleDec = window.getComputedStyle(parent);
+        const {fontStyle: parentFontStyle} = parentStyleDec;
+        // If the parent also has slanted text:
+        if (['italic', 'oblique'].includes(parentFontStyle)) {
+          // Do not report a violation, because the slant may be inherited.
+          return null;
+        }
+      }
+      // If it has no parent or its slant is autonomous, return a violation description.
       return 'Element contains all-slanted text';
     }
   };
-  const selector = 'body *:not(style, script, svg)';
+  const selector = 'body, body *:not(style, script, svg)';
   const whats = 'Elements contain all-slanted text';
   return await doTest(
     page, catalog, withItems, 'allSlanted', selector, whats, 0, getBadWhat.toString()

package/testaro/altScheme.js

@@ -41,6 +41,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'img elements have alt attributes with URL or filename values';
   return await doTest(
-    page, catalog, withItems, 'altScheme', 'img[alt]', whats, 1, getBadWhat.toString()
+    page, catalog, withItems, 'altScheme', 'body img[alt]', whats, 1, getBadWhat.toString()
   );
 };

package/testaro/attVal.js

@@ -31,6 +31,6 @@ exports.reporter = async (page, catalog, withItems, attributeName, areLicit, val
   };
   const whats = `Elements have attribute ${attributeName} with illicit values`;
   return await doTest(
-    page, catalog, withItems, 'attVal', `[${attributeName}]`, whats, 2, getBadWhat.toString()
+    page, catalog, withItems, 'attVal', `body [${attributeName}]`, whats, 2, getBadWhat.toString()
   );
 };

package/testaro/autocomplete.js

@@ -76,7 +76,7 @@ exports.reporter = async (
       return `input has no autocomplete="${requiredAuto}" attribute`;
     }
   };
-  const selector = 'input[type=text], input[type=email], input:not([type])';
+  const selector = 'body input[type=text], body input[type=email], body input:not([type])';
   const whats = 'Inputs are missing required autocomplete attributes';
   const placeHolders = Object.keys(labels).map(key => `__${key}Labels__`);
   const replacers = Object.values(labels).map(value => JSON.stringify(value));

package/testaro/captionLoc.js

@@ -31,6 +31,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'caption elements are not the first children of table elements';
   return await doTest(
-    page, catalog, withItems, 'captionLoc', 'caption', whats, 3, getBadWhat.toString()
+    page, catalog, withItems, 'captionLoc', 'body caption', whats, 3, getBadWhat.toString()
   );
 };

package/testaro/datalistRef.js

@@ -46,6 +46,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'list attributes of input elements are empty or IDs of no or non-datalist elements';
   return await doTest(
-    page, catalog, withItems, 'datalistRef', 'input[list]', whats, 3, getBadWhat.toString()
+    page, catalog, withItems, 'datalistRef', 'body input[list]', whats, 3, getBadWhat.toString()
   );
 };

package/testaro/distortion.js

@@ -38,6 +38,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Elements distort their texts';
   return await doTest(
-    page, catalog, withItems, 'distortion', 'body *', whats, 0, getBadWhat.toString()
+    page, catalog, withItems, 'distortion', 'body, body *', whats, 0, getBadWhat.toString()
   );
 };

package/testaro/focAndOp.js

@@ -116,6 +116,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Elements are Tab-focusable but not operable or vice versa';
   return await doTest(
-    page, catalog, withItems, 'focAndOp', 'body *', whats, 2, getBadWhat.toString()
+    page, catalog, withItems, 'focAndOp', 'body, body *', whats, 2, getBadWhat.toString()
   );
 };

package/testaro/focInd.js

@@ -86,6 +86,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Elements fail to have standard focus indicators';
   return await doTest(
-    page, catalog, withItems, 'focInd', 'body *', whats, 1, getBadWhat.toString()
+    page, catalog, withItems, 'focInd', 'body, body *', whats, 1, getBadWhat.toString()
   );
 };

package/testaro/focVis.js

@@ -42,6 +42,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Visible links are above or to the left of the display';
   return await doTest(
-    page, catalog, withItems, 'focVis', 'a', whats, 2, getBadWhat.toString()
+    page, catalog, withItems, 'focVis', 'body a', whats, 2, getBadWhat.toString()
   );
 };

package/testaro/hovInd.js

@@ -138,7 +138,7 @@ exports.reporter = async (page, catalog, withItems) => {
       }
     }
   };
-  const selector = 'a, button, input, [onmouseenter], [onmouseover]';
+  const selector = 'body a, body button, body input, body [onmouseenter], body [onmouseover]';
   const whats = 'elements have confusing hover indicators';
   return await doTest(page, catalog, withItems, 'hovInd', selector, whats, 1, getBadWhat.toString());
 };

package/testaro/hr.js

@@ -27,6 +27,6 @@ exports.reporter = async (page, catalog, withItems) => {
   }
   const whats = 'HR elements are used for vertical segmentation';
   return await doTest(
-    page, catalog, withItems, 'hr', 'hr', whats, 0, getBadWhat.toString()
+    page, catalog, withItems, 'hr', 'body hr', whats, 0, getBadWhat.toString()
   );
 };

package/testaro/imageLink.js

@@ -33,6 +33,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Links have image files as their destinations';
   return await doTest(
-    page, catalog, withItems, 'imageLink', 'a[href]', whats, 0, getBadWhat.toString()
+    page, catalog, withItems, 'imageLink', 'body  a[href]', whats, 0, getBadWhat.toString()
   );
 };

package/testaro/labClash.js

@@ -41,7 +41,7 @@ exports.reporter = async (page, catalog, withItems) => {
       return `Element has inconsistent label types (${labelTypes.join(', ')})`;
     }
   };
-  const selector = 'button, input:not([type=hidden]), select, textarea';
+  const selector = 'body button, body input:not([type=hidden]), body select, body textarea';
   const whats = 'Elements have inconsistent label types';
   return await doTest(
     page, catalog, withItems, 'labClash', selector, whats, 2, getBadWhat.toString()

package/testaro/legendLoc.js

@@ -33,6 +33,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Legend elements are not the first children of fieldset elements';
   return await doTest(
-    page, catalog, withItems, 'legendLoc', 'legend', whats, 3, getBadWhat.toString()
+    page, catalog, withItems, 'legendLoc', 'body legend', whats, 3, getBadWhat.toString()
   );
 };

package/testaro/lineHeight.js

@@ -38,6 +38,20 @@ exports.reporter = async (page, catalog, withItems) => {
       const isBad = lineHeightNum < 1.495 * fontSizeNum;
       // If it does:
       if (isBad) {
+        const parent = element.parentElement;
+        // If the element has a parent:
+        if (parent) {
+          // Get the style properties of the parent.
+          const parentStyleDec = window.getComputedStyle(parent);
+          const {fontSize: parentFontSize, lineHeight: parentLineHeight} = parentStyleDec;
+          const parentFontSizeNum = Number.parseFloat(parentFontSize);
+          const parentLineHeightNum = Number.parseFloat(parentLineHeight);
+          // If the parent also violates the rule:
+          if (parentLineHeightNum < 1.495 * parentFontSizeNum) {
+            // Do not report a violation, because the line height may be inherited.
+            return null;
+          }
+        }
         const whatFontSize = `font size (${fontSizeNum.toFixed(1)}px)`;
         const whatLineHeight = `line height (${lineHeightNum.toFixed(1)}px)`;
         // Return a violation description.
@@ -47,6 +61,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Element line heights are less than 1.5 times their font sizes';
   return await doTest(
-    page, catalog, withItems, 'lineHeight', '*', whats, 1, getBadWhat.toString()
+    page, catalog, withItems, 'lineHeight', 'body, body *', whats, 1, getBadWhat.toString()
   );
 };

package/testaro/linkExt.js

@@ -26,6 +26,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Links have target=_blank attributes';
   return await doTest(
-    page, catalog, withItems, 'linkExt', 'a[target=_blank]', whats, 0, getBadWhat.toString()
+    page, catalog, withItems, 'linkExt', 'body a[target=_blank]', whats, 0, getBadWhat.toString()
   );
 };

package/testaro/linkOldAtt.js

@@ -36,7 +36,7 @@ exports.reporter = async (page, catalog, withItems) => {
       return `Element has deprecated attributes: ${elementBadAttNames.join(', ')}`;
     }
   };
-  const selector = 'a[charset], a[coords], a[name], a[rev], a[shape]';
+  const selector = 'body a[charset], body a[coords], body a[name], body a[rev], body a[shape]';
   const whats = 'Links have deprecated attributes';
   return await doTest(
     page, catalog, withItems, 'linkOldAtt', selector, whats, 1, getBadWhat.toString()

package/testaro/linkTo.js

@@ -33,6 +33,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Links are missing href attributes';
   return await doTest(
-    page, catalog, withItems, 'linkTo', 'a:not([href]', whats, 2, getBadWhat.toString()
+    page, catalog, withItems, 'linkTo', 'body a:not([href]', whats, 2, getBadWhat.toString()
   );
 };

package/testaro/linkUl.js

@@ -40,6 +40,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Links that are not list items are not underlined';
   return await doTest(
-    page, catalog, withItems, 'linkUl', 'a', whats, 1, getBadWhat.toString()
+    page, catalog, withItems, 'linkUl', 'body a', whats, 1, getBadWhat.toString()
   );
 };

package/testaro/miniText.js

@@ -40,6 +40,17 @@ exports.reporter = async (page, catalog, withItems) => {
         const fontSize = Number.parseFloat(fontSizeString);
         // If its font size is smaller than 11 pixels:
         if (fontSize < 11) {
+          const parent = element.parentElement;
+          // If the element has a parent:
+          if (parent) {
+            const parentStyleDec = window.getComputedStyle(parent);
+            const parentFontSize = Number.parseFloat(parentStyleDec.fontSize);
+            // If the parent also has a font size smaller than 11 pixels:
+            if (parentFontSize < 11) {
+              // Do not report a violation, because the font size may be inherited.
+              return null;
+            }
+          }
           // Return a violation description.
           return `Element is visible but its font size is ${fontSize}px, smaller than 11px`;
         }
@@ -48,6 +59,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Visible elements have font sizes smaller than 11 pixels';
   return await doTest(
-    page, catalog, withItems, 'miniText', 'body *:not(script, style)', whats, 2, getBadWhat.toString()
+    page, catalog, withItems, 'miniText', 'body, body *:not(script, style)', whats, 2, getBadWhat.toString()
   );
 };

package/testaro/nonTable.js

@@ -56,6 +56,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'table elements are misused for non-table content';
   return await doTest(
-    page, catalog, withItems, 'nonTable', 'table', whats, 2, getBadWhat.toString()
+    page, catalog, withItems, 'nonTable', 'body table', whats, 2, getBadWhat.toString()
   );
 };

package/testaro/optRoleSel.js

@@ -32,6 +32,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Elements with role=option have no aria-selected attributes';
   return await doTest(
-    page, catalog, withItems, 'optRoleSel', '[role="option"]', whats, 1, getBadWhat.toString()
+    page, catalog, withItems, 'optRoleSel', 'body [role="option"]', whats, 1, getBadWhat.toString()
   );
 };

package/testaro/phOnly.js

@@ -34,6 +34,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'input elements have placeholders but no accessible names';
   return await doTest(
-    page, catalog, withItems, 'phOnly', 'input[placeholder]', whats, 2, getBadWhat.toString()
+    page, catalog, withItems, 'phOnly', 'body input[placeholder]', whats, 2, getBadWhat.toString()
   );
 };

package/testaro/radioSet.js

@@ -69,6 +69,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Radio buttons are not validly grouped in fieldsets with legends';
   return await doTest(
-    page, catalog, withItems, 'radioSet', 'input[type=radio]', whats, 2, getBadWhat.toString()
+    page, catalog, withItems, 'radioSet', 'body input[type=radio]', whats, 2, getBadWhat.toString()
   );
 };

package/testaro/secHeading.js

@@ -41,7 +41,7 @@ exports.reporter = async (page, catalog, withItems) => {
       }
     }
   };
-  const selector = 'section, article, nav, aside, main';
+  const selector = 'body section, body article, body nav, body aside, body main';
   const whats = 'First child headings of sectioning containers are deeper than others';
   return await doTest(
     page, catalog, withItems, 'secHeading', selector, whats, 0, getBadWhat.toString()

package/testaro/textSem.js

@@ -35,7 +35,7 @@ exports.reporter = async (page, catalog, withItems) => {
       }
     }
   };
-  const selector = 'i, b, small';
+  const selector = 'body i, body b, body small';
   const whats = 'Semantically vague elements i, b, and/or small are used';
   return await doTest(
     page, catalog, withItems, 'textSem', selector, whats, 0, getBadWhat.toString()

package/testaro/titledEl.js

@@ -26,7 +26,7 @@ exports.reporter = async (page, catalog, withItems) => {
     // Return a violation description.
     return `Likely ineffective title attribute is used on the ${elementType} element`;
   }
-  const selector = '[title]:not(iframe, link, style)';
+  const selector = 'body [title]:not(iframe, link, style)';
   const whats = 'title attributes are used on elements they are likely ineffective on';
   return await doTest(
     page, catalog, withItems, 'titledEl', selector, whats, 0, getBadWhat.toString()

package/testaro/zIndex.js

@@ -33,6 +33,6 @@ exports.reporter = async (page, catalog, withItems) => {
   };
   const whats = 'Elements have non-default Z indexes';
   return await doTest(
-    page, catalog, withItems, 'zIndex', 'body *', whats, 0, getBadWhat.toString()
+    page, catalog, withItems, 'zIndex', 'body, body *', whats, 0, getBadWhat.toString()
   );
 };

package/tests/testaro.js

@@ -41,10 +41,10 @@ const allRules = [
   },
   {
     id: 'allCaps',
-    what: 'leaf elements with entirely upper-case text longer than 7 characters',
+    what: 'elements with unnecessarily all-capital text substrings',
     contaminates: false,
     needsAccessibleName: false,
-    timeOut: 5,
+    timeOut: 30,
     defaultOn: true
   },
   {

package/validation/tests/targets/allSlanted/index.html

@@ -30,7 +30,10 @@
       <p class="oblique">This text has been transformed by its style to oblique.</p>
       <p><em id="indirect">This text has no explicit style, but is in an em element, so is made italic by the user agent</em> except at the end</p>
       <p>This text is transformed to italic <span class="italic">only in small part</span>.</p>
-      <p>Qualifying text nodes: 3</p>
+      <div id="slantedParent" class="oblique">
+        <p>This text is oblique by inheritance from its parent.</p>
+      </div>
+      <p>Qualifying text nodes: 4</p>
     </main>
   </body>
 </html>

package/pw-aslint-claude.js

@@ -1,88 +0,0 @@
-/*
-  © 2025 Jonathan Robert Pool.
-  Licensed under the MIT License. See LICENSE file for details.
-*/
-
-// aslint.config.js
-const { defineConfig } = require('aslint');
-
-module.exports = defineConfig({
-  // Configure ASLint rules
-  rules: {
-    'image-alt': 'error',
-    'button-name': 'error',
-    'html-has-lang': 'error',
-    'link-name': 'error',
-    'page-title': 'error'
-  }
-});
-
-// test.spec.js
-const { test, expect } = require('@playwright/test');
-const { createASLinter } = require('aslint');
-
-test.describe('Accessibility Tests', () => {
-  let linter;
-
-  test.beforeAll(async () => {
-    linter = await createASLinter();
-  });
-
-  test('should pass accessibility checks', async ({ page }) => {
-    // Navigate to your page
-    await page.goto('https://your-website.com');
-
-    // Get the page content
-    const content = await page.content();
-
-    // Run ASLint
-    const results = await linter.lint(content);
-
-    // Assert no accessibility violations
-    expect(results.violations).toHaveLength(0);
-
-    // Optional: Log detailed results
-    if (results.violations.length > 0) {
-      console.log('Accessibility violations found:',
-        results.violations.map(v => ({
-          rule: v.rule,
-          message: v.message,
-          element: v.element
-        }))
-      );
-    }
-  });
-
-  // Test specific components
-  test('check specific component accessibility', async ({ page }) => {
-    await page.goto('https://your-website.com/component');
-
-    // Wait for specific component to be visible
-    await page.waitForSelector('.your-component');
-
-    // Get component HTML
-    const componentHTML = await page.$eval(
-      '.your-component',
-      el => el.outerHTML
-    );
-
-    const results = await linter.lint(componentHTML);
-    expect(results.violations).toHaveLength(0);
-  });
-});
-
-// playwright.config.js
-const { defineConfig } = require('@playwright/test');
-
-module.exports = defineConfig({
-  testDir: './tests',
-  /* Other Playwright configs */
-  use: {
-    // Enable automatic accessibility violations logging
-    trace: 'retain-on-failure'
-  },
-  reporter: [
-    ['html'],
-    ['list']
-  ]
-});