testaro 78.0.6 → 78.4.0

package/procs/scope.js

@@ -0,0 +1,196 @@
+/*
+  © 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
+*/
+
+/*
+  scope.js
+  Finds what changed between two checkpoints of a report, by comparing their catalog entries,
+  and reduces the changes to the smallest set of subtree roots that contains them. The roots
+  serve test acts with scope: 'changed' (docs/checkpoint-scanning.md, Phase 3) and the
+  structure diffs of report.flow (Phase 2).
+*/
+
+// CONSTANTS
+
+// The most roots a changed-scope test act may be given; above this, the whole page is tested.
+const maxRoots = exports.maxRoots = 50;
+
+// FUNCTIONS
+
+// Returns whether one XPath (as the catalog records them) is a strict descendant of another.
+const isDescendant = (pathID, ancestorPathID) => pathID.startsWith(`${ancestorPathID}/`);
+// Returns the XPath of the parent of an element, or '' for the root.
+const parentOf = pathID => pathID.slice(0, pathID.lastIndexOf('/')) || '';
+// Returns the catalog entries of a checkpoint, keyed by XPath.
+const getEntriesByPath = (report, checkpointIndex) => {
+  const entries = {};
+  const checkpoint = (report.checkpoints ?? [])[checkpointIndex];
+  const range = checkpoint && checkpoint.catalogRange;
+  const catalog = report.catalog ?? {};
+  // Read the checkpoint's index range if recorded, else every entry stamped with the checkpoint.
+  const keys = range
+    ? Array.from({length: range[1] - range[0] + 1}, (_, offset) => String(range[0] + offset))
+    : Object.keys(catalog).filter(key => catalog[key].checkpoint === checkpointIndex);
+  keys.forEach(key => {
+    const entry = catalog[key];
+    if (entry && entry.pathID && entry.checkpoint === checkpointIndex) {
+      entries[entry.pathID] = entry;
+    }
+  });
+  return entries;
+};
+/*
+  Converts an XPath of the form the catalog records (/html/body/main[1]/div[2]) to a CSS
+  selector (html > body > main:nth-of-type(1) > div:nth-of-type(2)). The conversion is exact
+  because window.getXPath subscripts each element among its same-tag siblings, which is what
+  nth-of-type counts. Returns '' if the XPath has an unexpected shape.
+*/
+const xPathToSelector = exports.xPathToSelector = pathID => {
+  if (typeof pathID !== 'string' || ! pathID.startsWith('/')) {
+    return '';
+  }
+  const segments = pathID.slice(1).split('/');
+  const parts = [];
+  for (const segment of segments) {
+    const match = segment.match(/^([a-z][a-z0-9-]*)(?:\[(\d+)\])?$/);
+    if (! match) {
+      return '';
+    }
+    parts.push(match[2] ? `${match[1]}:nth-of-type(${match[2]})` : match[1]);
+  }
+  return parts.join(' > ');
+};
+/*
+  Compares the catalog entries of two checkpoints and returns the difference:
+    added: XPaths present only in the later checkpoint
+    removed: XPaths present only in the earlier one
+    changed: XPaths present in both whose start tags differ
+    textChanged: XPaths present in both, with the same start tag, whose text differs
+    roots: the smallest set of XPaths, in the later checkpoint, whose subtrees contain every
+      change (the parent of a removed element stands for it; a text change counts only where
+      no descendant changed, because the catalog text of an element includes its descendants')
+    counts: the sizes of the above
+*/
+const getStructureDiff = exports.getStructureDiff = (report, fromIndex, toIndex) => {
+  const before = getEntriesByPath(report, fromIndex);
+  const after = getEntriesByPath(report, toIndex);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  const textChanged = [];
+  Object.keys(after).forEach(pathID => {
+    const entry = after[pathID];
+    const priorEntry = before[pathID];
+    if (! priorEntry) {
+      added.push(pathID);
+    }
+    else if ((priorEntry.startTag ?? '') !== (entry.startTag ?? '')) {
+      changed.push(pathID);
+    }
+    else if ((priorEntry.text ?? '') !== (entry.text ?? '')) {
+      textChanged.push(pathID);
+    }
+  });
+  Object.keys(before).forEach(pathID => {
+    if (! after[pathID]) {
+      removed.push(pathID);
+    }
+  });
+  // Elements whose own change (not their descendants') marks them as changed.
+  const structural = new Set([... added, ... changed]);
+  removed.forEach(pathID => {
+    // The nearest surviving ancestor stands for a removed element.
+    let ancestor = parentOf(pathID);
+    while (ancestor && ! after[ancestor]) {
+      ancestor = parentOf(ancestor);
+    }
+    if (ancestor) {
+      structural.add(ancestor);
+    }
+  });
+  const allChanged = new Set([... structural, ... textChanged]);
+  // A text change counts only where no descendant changed at all.
+  textChanged.forEach(pathID => {
+    const hasChangedDescendant = Array.from(allChanged).some(other => isDescendant(other, pathID));
+    if (! hasChangedDescendant) {
+      structural.add(pathID);
+    }
+  });
+  // Collapse the changed elements to their outermost members.
+  const roots = Array.from(structural)
+  .filter(pathID => ! Array.from(structural).some(other => other !== pathID && isDescendant(pathID, other)))
+  .sort();
+  return {
+    added,
+    removed,
+    changed,
+    textChanged,
+    roots,
+    counts: {
+      before: Object.keys(before).length,
+      after: Object.keys(after).length,
+      added: added.length,
+      removed: removed.length,
+      changed: changed.length,
+      textChanged: textChanged.length,
+      roots: roots.length
+    }
+  };
+};
+// Returns the XPath of the nearest common ancestor-or-self of XPaths.
+const getCommonAncestor = exports.getCommonAncestor = pathIDs => {
+  if (! pathIDs.length) {
+    return '';
+  }
+  let common = pathIDs[0].split('/');
+  pathIDs.slice(1).forEach(pathID => {
+    const segments = pathID.split('/');
+    let length = 0;
+    while (length < common.length && length < segments.length && common[length] === segments[length]) {
+      length++;
+    }
+    common = common.slice(0, length);
+  });
+  return common.join('/') || '/html';
+};
+/*
+  Returns the subtree roots a changed-scope test act at a checkpoint is to test: the CSS
+  selectors of the roots of the structure diff between the checkpoint and the previous one.
+  applied is false, with a reason, when the act cannot be scoped: no previous checkpoint, no
+  change at all, too many roots (maxRoots), or a root whose XPath cannot become a selector.
+*/
+exports.getChangedRoots = (report, checkpointIndex) => {
+  if (! Number.isInteger(checkpointIndex) || checkpointIndex < 1) {
+    return {applied: false, reason: 'no previous checkpoint to compare', roots: [], pathIDs: []};
+  }
+  // Use the diff recorded when the checkpoint was made (the previous checkpoint's uncited
+  // entries were pruned then), else compute it.
+  const checkpoint = (report.checkpoints ?? [])[checkpointIndex];
+  const diff = checkpoint && checkpoint.structure
+    ? checkpoint.structure
+    : getStructureDiff(report, checkpointIndex - 1, checkpointIndex);
+  const {roots: pathIDs} = diff;
+  if (! pathIDs.length) {
+    return {applied: false, reason: 'no change since the previous checkpoint', roots: [], pathIDs};
+  }
+  if (pathIDs.length > maxRoots) {
+    return {
+      applied: false,
+      reason: `${pathIDs.length} changed subtrees exceed the limit of ${maxRoots}`,
+      roots: [],
+      pathIDs
+    };
+  }
+  const roots = pathIDs.map(xPathToSelector);
+  if (roots.some(root => ! root)) {
+    return {applied: false, reason: 'a changed subtree has no CSS selector', roots: [], pathIDs};
+  }
+  // The nearest ancestor of all the roots, for tools that take one root only.
+  const commonPathID = getCommonAncestor(pathIDs);
+  return {applied: true, reason: '', roots, pathIDs, commonRoot: xPathToSelector(commonPathID)};
+};

package/procs/shoot.d.ts

@@ -0,0 +1,33 @@
+/*
+  © 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
+*/
+
+/*
+  shoot (hand-written declarations)
+  Minimal typings for the surface of procs/shoot.js that converted TypeScript
+  files use. Delete this file when shoot.js itself is converted (issue #73).
+*/
+
+import type {Page} from 'playwright';
+import type {Report} from '../types';
+
+export interface ShootOptions {
+  exclusionSelector?: string | null;
+  // Color fidelity: 0 (grayscale), 2 (RGB), 4 (grayscale alpha), 6 (RGBA).
+  colorType?: number;
+  // Disposition: return, report, file.
+  action?: 'return' | 'report' | 'file';
+  // Screenshot scale.
+  scale?: 'css' | 'device';
+}
+
+// Makes a screenshot of a page and returns, reports, or files it. With the return action,
+// the resolution is the base64 encoding of the screenshot, or a falsy value on failure.
+export function shoot(
+  page: Page, report: Report, options?: ShootOptions
+): Promise<string | null | undefined>;

package/procs/shoot.js

@@ -57,7 +57,9 @@ exports.shoot = async (page, report, {
   scale = 'css'
 } = {}) => {
   // Make and get a screenshot as a buffer.
-  let shot = await screenShot(page, exclusionSelector ? page.locator(exclusionSelector) : null, scale);
+  let shot = await screenShot(
+    page, exclusionSelector ? page.locator(exclusionSelector) : null, scale
+  );
   // If it succeeded:
   if (shot.length) {
     // Get the screenshot as an object representation of a PNG image.

package/procs/standard.d.ts

@@ -0,0 +1,18 @@
+import type { Outcome, StandardInstance, StandardResult, UncertaintyCode } from '../types';
+export interface InstanceSpec {
+    ruleID: string;
+    what: string;
+    ordinalSeverity: number;
+    outcome?: Outcome;
+    uncertainty?: string;
+    needed?: string;
+    count?: number;
+    catalogIndex?: string | number;
+    pathID?: string;
+}
+export declare const OUTCOMES: Outcome[];
+export declare const UNCERTAINTY_CODES: UncertaintyCode[];
+export declare const getStandardResult: () => StandardResult;
+export declare const getInstance: (spec: InstanceSpec) => StandardInstance;
+export declare const pushInstance: (standardResult: StandardResult, spec: InstanceSpec) => StandardInstance;
+export declare const addInstance: (standardResult: StandardResult, spec: InstanceSpec) => StandardInstance;

package/procs/standard.js

@@ -0,0 +1,83 @@
+"use strict";
+/*
+  © 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
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addInstance = exports.pushInstance = exports.getInstance = exports.getStandardResult = exports.UNCERTAINTY_CODES = exports.OUTCOMES = void 0;
+// ########## CONSTANTS
+// Outcomes of instances.
+exports.OUTCOMES = ['failed', 'cantTell'];
+// Reasons for cantTell outcomes.
+exports.UNCERTAINTY_CODES = [
+    'not-computable',
+    'judgement-required',
+    'runtime-dependent',
+    'spec-only',
+    'equivalence-unknown',
+    'out-of-scope'
+];
+// Maximum length of a needed description.
+const NEEDED_MAX_LENGTH = 300;
+// ########## FUNCTIONS
+// Returns an empty standard result.
+const getStandardResult = () => ({
+    prevented: false,
+    totals: [0, 0, 0, 0],
+    outcomeTotals: { failed: 0, cantTell: 0 },
+    instances: []
+});
+exports.getStandardResult = getStandardResult;
+// Returns a standard instance, validating its certainty properties.
+const getInstance = (spec) => {
+    const { ruleID, what, ordinalSeverity, outcome = 'failed', uncertainty, needed, count = 1, catalogIndex, pathID } = spec;
+    if (!exports.OUTCOMES.includes(outcome)) {
+        throw new Error(`Invalid outcome ${outcome} for rule ${ruleID}`);
+    }
+    const instance = {
+        ruleID,
+        what,
+        ordinalSeverity: Number(ordinalSeverity),
+        outcome
+    };
+    // If the outcome is cantTell, add any reason and reviewer guidance.
+    if (outcome === 'cantTell') {
+        if (uncertainty) {
+            if (!exports.UNCERTAINTY_CODES.includes(uncertainty)) {
+                throw new Error(`Invalid uncertainty ${uncertainty} for rule ${ruleID}`);
+            }
+            instance.uncertainty = uncertainty;
+        }
+        if (needed) {
+            instance.needed = String(needed).replace(/\s+/g, ' ').trim().slice(0, NEEDED_MAX_LENGTH);
+        }
+    }
+    instance.count = count;
+    if (catalogIndex !== undefined) {
+        instance.catalogIndex = catalogIndex;
+    }
+    else if (pathID) {
+        instance.pathID = pathID;
+    }
+    return instance;
+};
+exports.getInstance = getInstance;
+// Adds an instance to a standard result and increments its outcome total.
+const pushInstance = (standardResult, spec) => {
+    const instance = (0, exports.getInstance)(spec);
+    standardResult.outcomeTotals ??= { failed: 0, cantTell: 0 };
+    standardResult.outcomeTotals[instance.outcome] += instance.count;
+    standardResult.instances.push(instance);
+    return instance;
+};
+exports.pushInstance = pushInstance;
+// Adds an instance to a standard result and increments its severity and outcome totals.
+const addInstance = (standardResult, spec) => {
+    const instance = (0, exports.pushInstance)(standardResult, spec);
+    standardResult.totals[instance.ordinalSeverity] += instance.count;
+    return instance;
+};
+exports.addInstance = addInstance;

package/procs/standard.ts

@@ -0,0 +1,126 @@
+/*
+  © 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
+*/
+
+// ########## IMPORTS
+
+import type {Outcome, StandardInstance, StandardResult, UncertaintyCode} from '../types';
+
+/*
+  standard
+  Utilities for building standard results. Compiled to standard.js by tsc (issue #73); edit
+  this file, not the emitted one.
+
+  A standard result has these properties:
+    prevented: whether the rule engine was prevented from performing the act
+    totals: array of 4 integers, counting instances at ordinal severities 0 through 3
+    outcomeTotals: object counting instances by outcome ({failed, cantTell})
+    instances: array of standard instances
+
+  A standard instance has these properties:
+    ruleID: ID of the violated rule
+    what: description of the rule or of the violation
+    ordinalSeverity: severity of the violation (0 to 3)
+    outcome: 'failed' if the rule engine asserted a violation, or 'cantTell' if it reported that it could not determine whether the rule was violated (ACT Rules Format vocabulary)
+    uncertainty?: reason for a cantTell outcome, if the rule engine gave one (one of UNCERTAINTY_CODES)
+    needed?: what a reviewer must determine to resolve a cantTell outcome, if the rule engine said
+    count: how many violations of the rule the instance reports
+    catalogIndex?: key of the violating element in the catalog
+    pathID?: normalized XPath of the violating element, if it has no catalog index
+
+  The outcome is the authoritative certainty signal. Until ordinalSeverity is redefined as impact only, each tool's ordinalSeverity conventions are unchanged, so consumers must not infer certainty from ordinalSeverity.
+*/
+
+// ########## TYPES
+
+// The properties from which a standard instance is built.
+export interface InstanceSpec {
+  ruleID: string;
+  what: string;
+  ordinalSeverity: number;
+  outcome?: Outcome;
+  uncertainty?: string;
+  needed?: string;
+  count?: number;
+  catalogIndex?: string | number;
+  pathID?: string;
+}
+
+// ########## CONSTANTS
+
+// Outcomes of instances.
+export const OUTCOMES: Outcome[] = ['failed', 'cantTell'];
+// Reasons for cantTell outcomes.
+export const UNCERTAINTY_CODES: UncertaintyCode[] = [
+  'not-computable',
+  'judgement-required',
+  'runtime-dependent',
+  'spec-only',
+  'equivalence-unknown',
+  'out-of-scope'
+];
+// Maximum length of a needed description.
+const NEEDED_MAX_LENGTH = 300;
+
+// ########## FUNCTIONS
+
+// Returns an empty standard result.
+export const getStandardResult = (): StandardResult => ({
+  prevented: false,
+  totals: [0, 0, 0, 0],
+  outcomeTotals: {failed: 0, cantTell: 0},
+  instances: []
+});
+// Returns a standard instance, validating its certainty properties.
+export const getInstance = (spec: InstanceSpec): StandardInstance => {
+  const {
+    ruleID, what, ordinalSeverity, outcome = 'failed', uncertainty, needed, count = 1, catalogIndex, pathID
+  } = spec;
+  if (! OUTCOMES.includes(outcome)) {
+    throw new Error(`Invalid outcome ${outcome} for rule ${ruleID}`);
+  }
+  const instance: StandardInstance = {
+    ruleID,
+    what,
+    ordinalSeverity: Number(ordinalSeverity) as StandardInstance['ordinalSeverity'],
+    outcome
+  };
+  // If the outcome is cantTell, add any reason and reviewer guidance.
+  if (outcome === 'cantTell') {
+    if (uncertainty) {
+      if (! (UNCERTAINTY_CODES as string[]).includes(uncertainty)) {
+        throw new Error(`Invalid uncertainty ${uncertainty} for rule ${ruleID}`);
+      }
+      instance.uncertainty = uncertainty as UncertaintyCode;
+    }
+    if (needed) {
+      instance.needed = String(needed).replace(/\s+/g, ' ').trim().slice(0, NEEDED_MAX_LENGTH);
+    }
+  }
+  instance.count = count;
+  if (catalogIndex !== undefined) {
+    instance.catalogIndex = catalogIndex;
+  }
+  else if (pathID) {
+    instance.pathID = pathID;
+  }
+  return instance;
+};
+// Adds an instance to a standard result and increments its outcome total.
+export const pushInstance = (standardResult: StandardResult, spec: InstanceSpec): StandardInstance => {
+  const instance = getInstance(spec);
+  standardResult.outcomeTotals ??= {failed: 0, cantTell: 0};
+  standardResult.outcomeTotals[instance.outcome!] += instance.count!;
+  standardResult.instances!.push(instance);
+  return instance;
+};
+// Adds an instance to a standard result and increments its severity and outcome totals.
+export const addInstance = (standardResult: StandardResult, spec: InstanceSpec): StandardInstance => {
+  const instance = pushInstance(standardResult, spec);
+  standardResult.totals![instance.ordinalSeverity] += instance.count!;
+  return instance;
+};

package/procs/testAct.js

@@ -0,0 +1,145 @@
+/*
+  © 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
+*/
+
+/*
+  testAct.js
+  Performs a test act: launches (or prepares) a page for the tool, runs the tool's reporter,
+  and records the act's data and result in the report. Used by the child process of process
+  isolation (doTestAct.js) and directly by the acts loop under browser and page isolation.
+*/
+
+// IMPORTS
+
+const {browserClose, launch, preparePage} = require('./launch');
+
+// CONSTANTS
+
+/*
+  Tool XPath requirements.
+    none: Needs no script or extra load time.
+    own: Needs extra load time for its own XPath computations.
+    script: Needs the window.getXPath script.
+    attribute: Needs data-xpath attributes made with window.getXPath.
+*/
+const xPathNeeds = exports.xPathNeeds = {
+  alfa: 'own',
+  aslint: 'own',
+  axe: 'attribute',
+  ed11y: 'script',
+  htmlcs: 'attribute',
+  ibm: 'attribute',
+  nuVal: 'attribute',
+  nuVnu: 'attribute',
+  pour: 'script',
+  qualWeb: 'attribute',
+  surea11y: 'script',
+  wave: 'script'
+};
+const accessibleNameNeeders = ['testaro'];
+
+// FUNCTIONS
+
+/*
+  Performs the test act at an index of a report and revises the report. Under page isolation,
+  livePage is the live page of the current checkpoint, which tools that take a page use as it
+  is (after preparation); otherwise each tool gets a page launched for it. The testaro tool
+  launches its own pages per rule (starting from livePage if given).
+*/
+exports.performTestAct = async ({report, actIndex, livePage = null}) => {
+  const act = report.acts[actIndex];
+  const {which} = act;
+  const useLivePage = Boolean(livePage) && report.jobData?.isolation === 'page';
+  let page;
+  // If the tool is not Testaro:
+  if (which !== 'testaro') {
+    // If the tool is to use the live page, prepare it for the tool.
+    if (useLivePage) {
+      page = livePage;
+      await preparePage(page, {
+        xPathNeed: xPathNeeds[which] ?? 'none',
+        needsAccessibleName: accessibleNameNeeders.includes(which)
+      });
+    }
+    // Otherwise, launch a browser and navigate to the URL (replaying the checkpoint's acts).
+    else {
+      const browserID = act.launch && act.launch.browserID || report.browserID;
+      const targetURL = act.launch && act.launch.target && act.launch.target.url || report.target.url;
+      page = await launch({
+        report,
+        actIndex,
+        tempBrowserID: browserID,
+        tempURL: targetURL,
+        xPathNeed: xPathNeeds[which] ?? 'none',
+        needsAccessibleName: accessibleNameNeeders.includes(which)
+      });
+      // If the launch aborted the job, stop.
+      if (report.jobData?.aborted) {
+        await browserClose(page);
+        return;
+      }
+    }
+  }
+  // If the page exists after the launch, or if the tool is Testaro:
+  if (page || which === 'testaro') {
+    try {
+      // Make the act reporter perform the specified tests of the tool.
+      const actReport = await require(`../tests/${which}`)
+      .reporter(useLivePage && which === 'testaro' ? livePage : page, report, actIndex, 65);
+      // Add the data and result to the act, keeping any checkpoint replay record the launch
+      // added to the act's data and any scope record the acts loop added (which the tool may
+      // have extended).
+      const {replay, scope} = act.data ?? {};
+      const toolScope = actReport.data && actReport.data.scope;
+      act.data = actReport.data ?? {};
+      if (replay) {
+        act.data.replay = replay;
+      }
+      if (scope) {
+        act.data.scope = {... scope, ... (toolScope ?? {})};
+      }
+      act.result = actReport.result;
+      // If the tool reported that the page prevented testing:
+      if (act.data && act.data.prevented) {
+        const {standardResult} = act.result;
+        // Add this to any standard result.
+        if (standardResult) {
+          standardResult.prevented = true;
+        }
+        // Add prevention data to the job data.
+        report.jobData.preventions[which] = act.data.error;
+      }
+    }
+    // If the tool invocation failed:
+    catch(error) {
+      const message = error.message.slice(0, 400);
+      console.log(`ERROR: Test act ${act.which} failed (${message})`);
+      act.data ??= {};
+      act.data.prevented = true;
+      act.data.error = `ERROR performing the act (${message})`;
+      report.jobData.preventions[which] = act.data.error;
+      throw error;
+    }
+    finally {
+      // Close the page and its context, unless it is the live page.
+      if (page && page !== livePage) {
+        await browserClose(page);
+      }
+    }
+  }
+  // Otherwise, i.e. if the page does not exist after the launch:
+  else {
+    // Add this to the act.
+    act.data ??= {};
+    act.data.prevented = true;
+    act.data.error = report.jobData?.abortMessage || 'No page';
+    // Add the prevention to the job data.
+    report.jobData.preventions[which] = act.data.error;
+    console.log('ERROR: No page');
+  }
+};

package/procs/testaro.d.ts

@@ -0,0 +1,20 @@
+import type { Locator, Page } from 'playwright';
+import type { Outcome, Report, SeverityTotals, StandardInstance, UncertaintyCode } from '../types';
+export interface RuleResult {
+    data: Record<string, unknown>;
+    totals: SeverityTotals;
+    standardInstances: StandardInstance[];
+}
+interface BasicViolation {
+    loc: Locator;
+    what: string;
+    outcome?: Outcome;
+    uncertainty?: UncertaintyCode;
+    needed?: string;
+}
+export declare const doTest: (page: Page, report: Report, withItems: boolean, ruleID: string, candidateSelector: string, whats: string, severity: number, getBadWhatString: string) => Promise<RuleResult>;
+export declare const getBasicResult: (report: Report, withItems: boolean, ruleID: string, ordinalSeverity: StandardInstance["ordinalSeverity"], whats: string, data: {
+    prevented?: boolean;
+    [key: string]: unknown;
+}, violations: BasicViolation[]) => Promise<RuleResult>;
+export {};