testaro 78.0.8 → 78.4.0

package/procs/xPath.ts

@@ -0,0 +1,106 @@
+/*
+  © 2024 CVS Health and/or one of its affiliates. All rights reserved.
+  © 2026 Jeff Witt.
+  © 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
+*/
+
+// IMPORTS
+
+import type {Catalog, Report} from '../types';
+
+/*
+  xPath
+  Processes element XPaths. Compiled to xPath.js by tsc (issue #73); edit this
+  file, not the emitted one.
+*/
+
+// FUNCTIONS
+
+// Normalizes an XPath.
+export const getNormalizedXPath = (xPath: string | null | undefined): string => {
+  if (xPath) {
+    if (xPath === '/') {
+      xPath = '/html';
+    }
+    xPath = xPath.replace(/^\.\/\//, '/');
+    const segments = xPath.split('/');
+    // Initialize an array of normalized segments.
+    const normalizedSegments: string[] = [];
+    // For each segment of the XPath:
+    segments.forEach(segment => {
+      // If the segment is html[1] or body[1]:
+      if (/html\[1\]|body\[1\]/.test(segment)) {
+        // Add it without its subscript to the array.
+        normalizedSegments.push(segment.replace(/\[1\]/, ''));
+      }
+      // Otherwise, if the segment is empty or html or body or ends with a subscript:
+      else if (segment === '' || ['html', 'body'].includes(segment) || segment.endsWith(']')) {
+        // Add it to the array.
+        normalizedSegments.push(segment);
+      }
+      // Otherwise, i.e. if the segment is a tag name with no subscript:
+      else {
+        // Add it with a subscript 1 to the array.
+        normalizedSegments.push(`${segment}[1]`);
+      }
+    });
+    // If the final segment contains any nonstandard character:
+    if (/[[^\]A-Za-z0-9]/.test(segments[segments.length - 1])) {
+      // Remove it.
+      normalizedSegments.pop();
+    }
+    // Return the concatenated segments as the normalized XPath.
+    return normalizedSegments.join('/');
+  }
+  else {
+    return '/html';
+  }
+};
+// Gets an XPath from a data-xpath attribute in an HTML excerpt.
+export const getAttributeXPath = (html: string | null | undefined): string => {
+  // If there is no excerpt (e.g. a Nu Html Checker message without an extract):
+  if (! html) {
+    // Return the fallback XPath, as for an excerpt without a data-xpath attribute.
+    return '/html';
+  }
+  const match = html.match(/ data-xpath="([^" ]+)"/);
+  return match ? match[1] : '/html';
+};
+// Gets a tag name from an XPath.
+const getXPathTagName = (xPath: string): string => {
+  return (xPath.split('/').pop() as string).replace(/\[.+/, '').toUpperCase();
+};
+// Gets a catalog index as a string from an XPath, within a checkpoint (the active one by
+// default). An XPath the checkpoint's catalog lacks gets a stub entry, keyed from the report's
+// monotonic counter so that entries of different checkpoints never collide.
+export const getXPathCatalogIndex = (
+  report: Report, xPath: string, checkpoint: number = report.activeCheckpoint ?? 0
+): string => {
+  // The catalog always exists by the time tests cite elements (getCatalog ran first).
+  const {catalog} = report as Report & {catalog: Catalog};
+  report.pathIDs ??= {};
+  const pathIDs = (report.pathIDs[checkpoint] ??= {});
+  // Get the index of the catalog item with the XPath.
+  const index = pathIDs[xPath];
+  // If no such item exists (an index of '0' is a match, so test for absence, not falsity):
+  if (index === undefined) {
+    // Add an item to the catalog, keyed by the counter (or, in a report without one, by the
+    // count of items already in it).
+    const newIndex = report.catalogNextIndex === undefined
+      ? `${Object.keys(catalog).length}`
+      : `${report.catalogNextIndex++}`;
+    catalog[newIndex] = {
+      pathID: xPath,
+      tagName: getXPathTagName(xPath),
+      checkpoint
+    };
+    pathIDs[xPath] = newIndex;
+    return newIndex;
+  }
+  return index;
+};

package/procs/xPathScript.d.ts

@@ -0,0 +1,6 @@
+import type {Page} from 'playwright';
+
+// The in-page script defining window.getXPath, as source text.
+export const getXPathSource: string;
+// Defines window.getXPath on a live page if it is not already defined.
+export function defineGetXPath(page: Page): Promise<void>;

package/procs/xPathScript.js

@@ -0,0 +1,70 @@
+/*
+  © 2026 Jeff Witt.
+
+  Licensed under the MIT License. See LICENSE file at the project root or
+  https://opensource.org/license/mit/ for details.
+
+  SPDX-License-Identifier: MIT
+*/
+
+/*
+  xPathScript
+  The in-page script that defines window.getXPath, shared by the launcher (which adds it as an
+  init script to every page it creates) and the checkpoint cataloguer (which defines it on a live
+  page that was launched without it).
+*/
+
+// FUNCTIONS
+
+// Defines window.getXPath in the page. Runs inside the page, so it must be closure-free.
+const installGetXPath = () => {
+  window.getXPath = element => {
+    if (! element || element.nodeType !== Node.ELEMENT_NODE) {
+      return '';
+    }
+    const segments = [];
+    // As long as the current node is an element:
+    while (element && element.nodeType === Node.ELEMENT_NODE) {
+      const tag = element.tagName.toLowerCase();
+      // If it is the html element:
+      if (element === document.documentElement) {
+        // Prepend it to the segment array
+        segments.unshift('html');
+        // Stop traversing.
+        break;
+      }
+      // Otherwise, get its parent node.
+      const parent = element.parentNode;
+      // If (abnormally) the parent node is not an element:
+      if (! parent || parent.nodeType !== Node.ELEMENT_NODE) {
+        // Prepend the element (not the parent) to the segment array.
+        segments.unshift(tag);
+        // Stop traversing, leaving the segment array partial.
+        break;
+      }
+      // Get the subscript of the element if it is not the body element.
+      const cohort = Array
+      .from(parent.childNodes)
+      .filter(
+        childNode => childNode.nodeType === Node.ELEMENT_NODE
+        && childNode.tagName === element.tagName
+      );
+      const subscript = tag === 'body' ? '' : `[${cohort.indexOf(element) + 1}]`;
+      // Prepend the element identifier to the segment array.
+      segments.unshift(`${tag}${subscript}`);
+      // Continue the traversal with the parent of the current element.
+      element = parent;
+    }
+    // Return the XPath.
+    return `/${segments.join('/')}`;
+  };
+};
+// The script as source text, for addInitScript and evaluate.
+const getXPathSource = exports.getXPathSource = `(${installGetXPath.toString()})();`;
+// Defines window.getXPath on a live page if it is not already defined.
+exports.defineGetXPath = async page => {
+  const isDefined = await page.evaluate(() => typeof window.getXPath === 'function');
+  if (! isDefined) {
+    await page.evaluate(getXPathSource);
+  }
+};

package/run.js

@@ -18,7 +18,7 @@
 
 const {doActs} = require('./procs/doActs');
 require('dotenv').config({quiet: true});
-const {isValidJob} = require('./procs/job');
+const {getIsolation, isValidJob} = require('./procs/job');
 const {getCatalog} = require('./procs/catalog');
 const {nowString} = require('./procs/dateTime');
 const {chromium} = require('playwright-extra');
@@ -131,7 +131,8 @@ exports.doJob = async (job, opts = {}) => {
       presses: 0,
       amountRead: 0,
       toolTimes: {},
-      preventions: {}
+      preventions: {},
+      isolation: getIsolation(job)
     };
     process.on('message', message => {
       if (message === 'interrupt') {

package/surea11y/README.md

@@ -0,0 +1,44 @@
+# Vendored SureA11y core bundle
+
+Upstream: [SureA11y/core](https://github.com/SureA11y/core) (`@surea11y/core` on npm,
+**MPL-2.0** — file-level copyleft: modifications to the vendored file itself must remain
+MPL-2.0; the rest of this repo is unaffected. The bundle is vendored verbatim, unmodified).
+
+## Vendoring
+
+No build step: upstream publishes a self-contained standalone browser bundle. To vendor or
+update:
+
+```sh
+npm pack @surea11y/core@<version>
+tar xzf surea11y-core-<version>.tgz
+cp package/surea11y.browser.js surea11y/surea11y.browser.js
+```
+
+The bundle defines one global, `a11ycore`, exposing `runa11yCoreInPage(pageUrl,
+contextSelector, engineOptions, runOnly)`; `tests/surea11y.js` reports the act as `prevented`
+if the file is missing or the global is absent. English-only by design (locale side files
+exist upstream; not vendored).
+
+## Result shape (verified against 1.7.0, schemaVersion 1.0.0)
+
+`runa11yCoreInPage()` returns `{engine: {tag: 'a11ycore', schemaVersion, wcagVersion},
+checksResults, rulesResults, ...}`. Each `checksResults` entry:
+`{ruleId, outcome: pass|fail|cantTell|notApplicable, severity: minor|moderate|serious|critical,
+confidence, type: automatic|manual, occurrences, title, meta: {normativeMappings:
+[{standard, version, requirement, ...}], ...}}`. Occurrences carry `{selector, html, summary,
+occurrenceOutcome?: fail|cantTell, uncertainty?}` — a `fail`-outcome rule may grade individual
+occurrences into `cantTell` tier via `occurrenceOutcome`, which the adapter honors
+per-occurrence, and the adapter forwards the occurrence's (else the check's) `uncertainty.code`
+and `uncertainty.needed` as the standard instance's `uncertainty` and `needed`. `pass` results serialize no occurrences; `notApplicable` may carry one
+scan-describing occurrence (empty selector) which the adapter must not count. Full contract:
+upstream `docs/OUTPUT_SCHEMA.md` (pinned to `schemaVersion` — the adapter reports `prevented`
+on a major schema change is NOT automatic; re-verify at each vendor bump).
+
+## Pinned version
+
+- **Vendored:** 2026-09-01
+- **Upstream:** `@surea11y/core` 1.7.0 (npm tarball, published bundle used verbatim)
+- **Bundle:** 749 KB standalone browser IIFE, global `a11ycore`
+- **Smoke-tested:** see yra-monitor `docs/plans/engine-candidacy-pipeline.md` candidate
+  register for Stage-1 results.