testaro 78.0.8 → 78.4.0

package/procs/catalog.ts

@@ -0,0 +1,398 @@
+/*
+  © 2026 Jeff Witt.
+  © 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
+*/
+
+// IMPORTS
+
+import type {Page} from 'playwright';
+// Module to close and launch browsers.
+import {browserClose, launch} from './launch';
+import {shoot} from './shoot';
+// Function to define window.getXPath on a live page.
+import {defineGetXPath} from './xPathScript';
+import type {Catalog, CatalogEntry, Checkpoint, Report, StandardResult} from '../types';
+
+/*
+  catalog
+  Creates and returns a catalog of a target. Compiled to catalog.js by tsc
+  (issue #73); edit this file, not the emitted one.
+
+  A catalog is an object with one property per element in the target. Each property has the element index as its key and has an object as its value, with 9 properties:
+  - tagName
+  - id
+  - startTag
+  - text
+  - textLinkable
+  - boxID
+  - pathID
+  - headingIndex
+  - checkpoint: the index of the checkpoint (page state) whose snapshot the entry belongs to
+
+  The catalog of checkpoint 0 (the job target as launched) is made by getCatalog before any act. A checkpoint act adds the entries of a later page state with catalogPage, on the live page, keyed from report.catalogNextIndex so indexes never collide. report.pathIDs maps each checkpoint's XPaths to catalog indexes.
+*/
+
+// TYPES
+
+// What catalogPage returns.
+export interface CatalogSnapshot {
+  entries: Catalog;
+  pathIDs: Record<string, string>;
+  firstIndex: number;
+  nextIndex: number;
+  elementCount: number;
+}
+
+// CONSTANTS
+
+// The ARIA snapshot of a page, for checkpoints; empty if the browser cannot make one.
+export const getAriaSnapshot = async (page: Page): Promise<string> => {
+  try {
+    return await page.locator('body').ariaSnapshot();
+  }
+  catch(error) {
+    console.log(`ERROR: ARIA snapshot failed (${(error as Error).message})`);
+    return '';
+  }
+};
+
+// FUNCTIONS
+
+// Catalogs the elements of a live page and returns the snapshot. Expands closed details
+// elements first, so box measurements agree with a page image taken in the same state; with
+// restoreDetails, closes them again afterward so a live page keeps its state.
+export const catalogPage = async (
+  page: Page, report: Report, {checkpoint, restoreDetails}: {checkpoint: number; restoreDetails: boolean}
+): Promise<CatalogSnapshot> => {
+  // Ensure the page can compute XPaths (a page launched for acts lacks the script).
+  await defineGetXPath(page);
+  // Expand closed details elements before the page image and the box measurements, so
+  // both see the same fully disclosed state. Chromium lays out the content of a closed
+  // details element (content-visibility: hidden) without painting it and without
+  // shifting the content after it, so getBoundingClientRect returns coordinates that
+  // overlap unrelated visible elements, making box IDs disagree with the page image.
+  await page.evaluate(() => {
+    document.querySelectorAll('details:not([open])').forEach(details => {
+      details.setAttribute('open', '');
+      details.setAttribute('data-testaro-opened', '');
+    });
+  }).catch(error => {
+    console.log(`ERROR: Expanding details elements failed (${error.message})`);
+  });
+  const startIndex = report.catalogNextIndex ?? 0;
+  // Get a catalog of the elements in the page and a map of path IDs to catalog indexes.
+  console.log(`Creating catalog for checkpoint ${checkpoint}`);
+  const {cat: entries, pathIDs, elementCount} = await page.evaluate(({startIndex, checkpoint}) => {
+    // HTMLElement covers the innerText reads below; SVG-only members are guarded.
+    const elements = Array.from(document.querySelectorAll<HTMLElement>('*'));
+    // Initialize a catalog.
+    const cat: Record<string, CatalogEntry> = {};
+    // Initialize a map of path IDs to catalog indexes.
+    const pathIDs: Record<string, string> = {};
+    // Initialize a directory of text fragments.
+    const texts: Record<string, string[]> = {};
+    // Initialize the index of the current heading.
+    let headingIndex = '';
+    // For each element in the page:
+    // Iterate by numeric index rather than `for...in`. `for...in` over this
+    // array also enumerates any enumerable members added to Array.prototype
+    // by the TARGET page's own scripts (e.g. legacy MooTools/Prototype-style
+    // extensions); `element` then becomes that injected value and the
+    // element.closest(...) call below throws "closest is not a function",
+    // aborting the entire catalog and the job. The indexed loop sees only
+    // real elements. `index` is kept as a string so the catalog keys
+    // (cat[index], texts[...].push(index)) are unchanged.
+    for (let i = 0; i < elements.length; i++) {
+      const index = String(startIndex + i);
+      const element = elements[i];
+      // Get its ID and tag name.
+      const {id, tagName} = element;
+      // Get its start tag.
+      const startTag = element.outerHTML?.replace(/^.*?</s, '<').replace(/>.*$/s, '>') ?? '';
+      // Get whether it is eligible for text-fragment acquisition.
+      const isTextable = element.closest('body')
+      && ! element.closest('svg')
+      && ! ['SCRIPT', 'STYLE', 'svg'].includes(element.tagName);
+      const innerText = isTextable
+      ? element.innerText.trim() || (element.parentElement?.innerText?.trim() ?? '')
+      : '';
+      let text = '';
+      // If it is eligible and has an inner text:
+      if (innerText) {
+        const segments = innerText?.split('\n') ?? [];
+        const tidySegments = segments.map(segment => segment.trim().replace(/\s+/g, ' '));
+        const neededSegments = tidySegments.filter(segment => segment.length);
+        neededSegments.splice(1, neededSegments.length - 2);
+        // Get its text fragments.
+        text = neededSegments.join('\n');
+        // Add its index to the directory of text fragments.
+        texts[text] ??= [];
+        texts[text].push(index);
+      }
+      // Get its bounding box, but only if the element is painted. Chromium reports
+      // plausible nonzero boxes for laid-out but unpainted content (visibility: hidden
+      // and content-visibility: hidden subtrees), and such a box disagrees with the
+      // page image, overlapping unrelated visible elements.
+      const isVisible = typeof element.checkVisibility === 'function'
+      ? element.checkVisibility({checkVisibilityCSS: true, visibilityProperty: true})
+      : true;
+      const domRect = isVisible ? element.getBoundingClientRect() : null;
+      // Get its box ID.
+      const boxID = domRect
+      ? (['x', 'y', 'width', 'height'] as const).map(key => Math.round(domRect[key])).join(':')
+      : '';
+      // Get its path ID.
+      const pathID = window.getXPath(element) ?? '/html';
+      // If it is a heading that nullifies an existing current heading index:
+      if (
+        headingIndex
+        && ['H1', 'H2', 'H3', 'H4', 'H5', 'H6'].includes(tagName)
+        && cat[headingIndex].tagName >= tagName
+      ) {
+        // Nullify the current heading index.
+        headingIndex = '';
+      }
+      // Add an entry for it to the catalog.
+      cat[index] = {
+        tagName,
+        id: id || '',
+        startTag,
+        text,
+        textLinkable: false,
+        boxID,
+        pathID,
+        headingIndex,
+        checkpoint
+      };
+      // If the element is a heading:
+      if (['H1', 'H2', 'H3', 'H4', 'H5', 'H6'].includes(tagName)) {
+        // Assign its index to the current heading index.
+        headingIndex = index;
+      }
+      // Add the path ID to the map of path IDs.
+      pathIDs[pathID] = index;
+    }
+    // For each text in the catalog:
+    Object.keys(texts).forEach(text => {
+      const textElementIndexes = texts[text].sort((a, b) => Number(a) - Number(b));
+      // If every element that has it is in the same subtree, so the text is page-unique:
+      if (
+        textElementIndexes.slice(0, -1).every(
+          (elementIndex, index) => cat[textElementIndexes[index + 1]]
+          .pathID
+          .startsWith(cat[elementIndex].pathID)
+        )
+      ) {
+        // For each element that has it:
+        textElementIndexes.forEach(index => {
+          // If it is not in the head, a script, a style, or a noscript element:
+          if (
+            ! ['/head[1]', '/script[', '/style[', '/noscript[']
+            .some(excluder => cat[index].pathID.includes(excluder))
+          ) {
+            // Mark it as linkable in the element data in the catalog.
+            cat[index].textLinkable = true;
+          }
+        });
+      }
+    });
+    return {cat, pathIDs, elementCount: elements.length};
+  }, {startIndex, checkpoint});
+  // If the page is to keep its state, close the details elements that were opened.
+  if (restoreDetails) {
+    await page.evaluate(() => {
+      document.querySelectorAll('details[data-testaro-opened]').forEach(details => {
+        details.removeAttribute('open');
+        details.removeAttribute('data-testaro-opened');
+      });
+    }).catch(() => {});
+  }
+  return {
+    entries,
+    pathIDs,
+    firstIndex: startIndex,
+    nextIndex: startIndex + elementCount,
+    elementCount
+  };
+};
+// Creates and returns a catalog.
+export const getCatalog = async (report: Report): Promise<Catalog> => {
+  const {browserID} = report;
+  const targetURL = report.target?.url;
+  // Image scale factor (report.imageScale). When greater than 1, the catalog context
+  // runs at that deviceScaleFactor and a supplemental page image is captured at device
+  // scale, i.e. with imageScale times the pixels of the CSS layout. Box IDs are
+  // CSS-pixel regardless, because getBoundingClientRect reports CSS pixels by
+  // definition; consumers map them onto the supplemental image by multiplying by
+  // imageScale. Omitted, 1, or invalid values keep the behavior identical to before
+  // this option existed.
+  const imageScale = Number.isFinite(report.imageScale) && (report.imageScale as number) > 1
+    ? report.imageScale as number
+    : 1;
+  // If the report specifies a global browser ID and a global target URL:
+  if (browserID && targetURL) {
+    // Launch a browser and visit the target, or abort the job on failure.
+    const page = await launch({
+      report,
+      actIndex: null,
+      tempBrowserID: browserID,
+      tempURL: targetURL,
+      contextOverrides: imageScale > 1 ? {deviceScaleFactor: imageScale} : {}
+    });
+    // If the launch and navigation succeeded:
+    if (page) {
+      const startTime = Date.now();
+      // If a page image is required:
+      if ([0, 2, 4, 6].includes(report.imageColor as number)) {
+        // Expand closed details elements first, so the image and the box measurements below
+        // see the same fully disclosed state (catalogPage expands them again, idempotently).
+        await page.evaluate(() => {
+          document.querySelectorAll('details:not([open])').forEach(details => {
+            details.setAttribute('open', '');
+          });
+        }).catch(error => {
+          console.log(`ERROR: Expanding details elements failed (${error.message})`);
+        });
+        // Create one at CSS-pixel scale and add it to the report as images[0]. This
+        // scale is invariant to imageScale and to the context's deviceScaleFactor, so
+        // the testaro motion rule, which compares its own CSS-scale screenshot with
+        // images[0], is unaffected by the imageScale option.
+        console.log('Creating page image');
+        await shoot(page, report, {
+          exclusionSelector: '',
+          colorType: report.imageColor,
+          action: 'report'
+        });
+        // If a supersampled page image is also required:
+        if (imageScale > 1) {
+          // Create one at device-pixel scale and add it to the report as images[1].
+          console.log(`Creating page image at ${imageScale}x device scale`);
+          await shoot(page, report, {
+            exclusionSelector: '',
+            colorType: report.imageColor,
+            action: 'report',
+            scale: 'device'
+          });
+        }
+      }
+      // Snapshot the page as checkpoint 0.
+      const snapshot = await catalogPage(page, report, {checkpoint: 0, restoreDetails: false});
+      report.catalog = snapshot.entries;
+      report.pathIDs = {0: snapshot.pathIDs};
+      report.catalogNextIndex = snapshot.nextIndex;
+      // Record the checkpoint.
+      const imageIndexes = (report.images ?? []).map((image, index) => index);
+      const checkpoint: Checkpoint = {
+        index: 0,
+        name: 'start',
+        implicit: false,
+        actIndex: null,
+        launchActIndex: null,
+        launchURL: page.url(),
+        replay: [],
+        interaction: {modality: 'efficient'},
+        kind: 'navigation',
+        url: page.url(),
+        title: await page.title().catch(() => ''),
+        imageIndexes,
+        catalogRange: [snapshot.firstIndex, snapshot.nextIndex - 1],
+        elementCount: snapshot.elementCount,
+        ariaSnapshot: await getAriaSnapshot(page),
+        elapsedMs: Date.now() - startTime,
+        testActs: []
+      };
+      report.checkpoints = [checkpoint];
+      const catalog = report.catalog;
+      // Close the browser and its context.
+      await browserClose(page);
+      // Return the catalog.
+      return catalog;
+    }
+    // Otherwise, i.e. if the launch or navigation failed, report and return this.
+    console.log('ERROR: Launch or navigation failure prevented cataloguing and aborted job');
+    return {};
+  }
+  // Otherwise, i.e. if the report specification is incomplete, report and return this.
+  console.log('ERROR: Job omits browser ID or target URL, preventing catalog creation');
+  return {};
+};
+// Returns the catalog indexes cited by the standard instances of the test acts (all of them,
+// or those of one checkpoint), plus the heading indexes of the cited entries.
+const getCitedIndexes = (report: Report, checkpoint: number | null = null): Set<string> => {
+  const {acts, catalog} = report as Report & {catalog: Catalog};
+  const citedElementIndexes = new Set<string>();
+  // For each act in the report:
+  acts.forEach(act => {
+    // If it is a test (of the checkpoint, if one is specified) with a standard result:
+    if (
+      act.type === 'test' && act.result?.standardResult
+      && (checkpoint === null || act.checkpoint === checkpoint)
+    ) {
+      // The guard above makes the fallback unreachable and instances present; the
+      // expression is kept verbatim from the JavaScript original.
+      const {instances} = (act.result?.standardResult ?? []) as Required<StandardResult>;
+      // For each instance of the standard result:
+      instances.forEach(instance => {
+        const catalogIndex = instance?.catalogIndex;
+        // If the instance has a catalog index (an index of '0' counts, so test for presence):
+        if (catalogIndex !== undefined && catalogIndex !== '') {
+          // Ensure the index is classified as cited, as a string so it matches the
+          // catalog keys tested below (Object.keys() yields strings).
+          citedElementIndexes.add(String(catalogIndex));
+          const {headingIndex} = catalog[catalogIndex] ?? {};
+          // If the catalog item has a heading index:
+          if (headingIndex) {
+            // Ensure it, too, is classified as cited.
+            citedElementIndexes.add(String(headingIndex));
+          }
+        }
+      });
+    }
+  });
+  return citedElementIndexes;
+};
+/*
+  Prunes the entries of one checkpoint that no test act of that checkpoint cites, and drops
+  its job-time XPath map. Called when the next checkpoint is created: test acts belong to the
+  latest checkpoint, so no later act can cite the earlier one, and pruning it then bounds the
+  temporary report that every test act reads. The structure diff with the next checkpoint is
+  computed before this runs (procs/checkpoint.js).
+*/
+export const pruneCheckpoint = (report: Report, checkpoint: number): number => {
+  const {catalog} = report as Report & {catalog: Catalog};
+  const cited = getCitedIndexes(report, checkpoint);
+  let prunedCount = 0;
+  Object.keys(catalog).forEach(elementIndex => {
+    if (catalog[elementIndex].checkpoint === checkpoint && ! cited.has(elementIndex)) {
+      delete catalog[elementIndex];
+      prunedCount++;
+    }
+  });
+  if (report.pathIDs) {
+    delete report.pathIDs[checkpoint];
+  }
+  return prunedCount;
+};
+// Prunes a catalog.
+export const pruneCatalog = (report: Report): void => {
+  console.log('Pruning catalog');
+  // The catalog always exists by pruning time (getCatalog ran at job start).
+  const {catalog} = report as Report & {catalog: Catalog};
+  const citedElementIndexes = getCitedIndexes(report);
+  // Delete the temporary job-time properties of the report.
+  delete report.pathIDs;
+  delete report.catalogNextIndex;
+  delete report.activeCheckpoint;
+  // For each element in the catalog:
+  Object.keys(catalog).forEach(elementIndex => {
+    // If it is not cited by any instance or by any cited element:
+    if (! citedElementIndexes.has(elementIndex)) {
+      // Delete it in the catalog.
+      delete catalog[elementIndex];
+    }
+  });
+};

package/procs/checkpoint.js

@@ -0,0 +1,110 @@
+/*
+  © 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
+*/
+
+/*
+  checkpoint.js
+  Creates checkpoints: snapshots of page states reached by a job's acts. See
+  docs/checkpoint-scanning.md.
+*/
+
+// IMPORTS
+
+const {createHash} = require('crypto');
+const {catalogPage, getAriaSnapshot, pruneCheckpoint} = require('./catalog');
+const {getStructureDiff} = require('./scope');
+const {shoot} = require('./shoot');
+
+// FUNCTIONS
+
+// Returns a digest of the page's DOM, ignoring the attributes Testaro adds and whitespace, so
+// that a replayed page can be compared with the snapshot it re-enacts.
+const getDomDigest = exports.getDomDigest = async page => {
+  try {
+    const content = await page.content();
+    const normalized = content
+    .replace(/ data-xpath="[^"]*"/g, '')
+    .replace(/ data-testaro-opened=""/g, '')
+    .replace(/\s+/g, ' ');
+    return createHash('sha1').update(normalized).digest('hex');
+  }
+  catch(error) {
+    console.log(`ERROR: DOM digest failed (${error.message})`);
+    return '';
+  }
+};
+// Creates a checkpoint from the live page, adds it to the report, and returns it.
+exports.makeCheckpoint = async ({
+  page, report, name, actIndex, implicit, launchActIndex, launchURL, replay, interaction
+}) => {
+  const startTime = Date.now();
+  const index = report.checkpoints.length;
+  const imageIndexes = [];
+  // If page images are required:
+  if ([0, 2, 4, 6].includes(report.imageColor)) {
+    const imageScale = Number.isFinite(report.imageScale) && report.imageScale > 1
+      ? report.imageScale
+      : 1;
+    // Create one at CSS scale, and one at device scale if the job asks for it.
+    const cssIndex = await shoot(page, report, {
+      exclusionSelector: '',
+      colorType: report.imageColor,
+      action: 'report'
+    });
+    if (typeof cssIndex === 'number') {
+      imageIndexes.push(cssIndex);
+    }
+    if (imageScale > 1) {
+      const deviceIndex = await shoot(page, report, {
+        exclusionSelector: '',
+        colorType: report.imageColor,
+        action: 'report',
+        scale: 'device'
+      });
+      if (typeof deviceIndex === 'number') {
+        imageIndexes.push(deviceIndex);
+      }
+    }
+  }
+  // Catalog the page as this checkpoint, keeping the live page's state.
+  const snapshot = await catalogPage(page, report, {checkpoint: index, restoreDetails: true});
+  Object.assign(report.catalog, snapshot.entries);
+  report.pathIDs ??= {};
+  report.pathIDs[index] = snapshot.pathIDs;
+  report.catalogNextIndex = snapshot.nextIndex;
+  const checkpoint = {
+    index,
+    name,
+    implicit,
+    actIndex,
+    launchActIndex,
+    launchURL,
+    replay,
+    interaction,
+    kind: replay.length ? 'interaction' : 'navigation',
+    url: page.url(),
+    title: await page.title().catch(() => ''),
+    imageIndexes,
+    catalogRange: [snapshot.firstIndex, snapshot.nextIndex - 1],
+    elementCount: snapshot.elementCount,
+    ariaSnapshot: await getAriaSnapshot(page),
+    domDigest: await getDomDigest(page),
+    elapsedMs: Date.now() - startTime,
+    testActs: []
+  };
+  report.checkpoints.push(checkpoint);
+  // If there is a previous checkpoint, record what changed since it (job-time; report.flow
+  // takes it over at job end), then prune the previous checkpoint's uncited entries, which
+  // no later test act can cite.
+  if (index > 0) {
+    checkpoint.structure = getStructureDiff(report, index - 1, index);
+    const prunedCount = pruneCheckpoint(report, index - 1);
+    console.log(`Pruned ${prunedCount} uncited catalog entries of checkpoint ${index - 1}`);
+  }
+  return checkpoint;
+};

package/procs/config.d.ts

@@ -0,0 +1,35 @@
+/*
+  © 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
+*/
+
+/*
+  config (hand-written declarations)
+  Minimal typings for the surface of procs/config.js that converted TypeScript
+  files use. Delete this file when config.js itself is converted (issue #73).
+*/
+
+// Multiplies a base timeout by the configured timeout multiplier.
+export function applyMultiplier(baseTimeout: number): number;
+// Whether an environment variable is set to a true value, or the default if unset.
+export function envFlag(name: string, defaultValue?: boolean): boolean;
+// Load states a navigation can wait for, from strictest to loosest.
+export const waitStates: string[];
+// Navigation options of a job (its navigation property over the environment defaults).
+export function getNavigation(report: unknown): {
+  waitUntil: 'networkidle' | 'load' | 'domcontentloaded';
+  timeout: number;
+  failFast4xx: boolean;
+};
+// The scanner identity header value of a job, or '' for none.
+export function getScannerId(report: unknown): string;
+// Whether a job scrolls the full page after navigation.
+export function getScroll(report: unknown): boolean;
+// Launch retries per rule of the testaro tool.
+export const ruleLaunchRetries: number;
+// Defaults for the qualWeb tool's browser.
+export const qualWebDefaults: {stealth: boolean; adBlock: boolean};

package/procs/config.js

@@ -17,3 +17,65 @@
 const timeoutMultiplier = Number.parseFloat(process.env.TIMEOUT_MULTIPLIER) || 1;
 // Multiplies a time limit by the configured amount.
 exports.applyMultiplier = (baseTimeout) => Math.round(baseTimeout * timeoutMultiplier);
+
+// Returns whether an environment variable is set to a true value, or the default if unset.
+const envFlag = (name, defaultValue = false) => {
+  const value = process.env[name];
+  if (value === undefined || value === '') {
+    return defaultValue;
+  }
+  return ['true', '1', 'yes', 'on'].includes(value.toLowerCase());
+};
+exports.envFlag = envFlag;
+
+/*
+  Deployment options. Each is a job property when a job sets it, else an environment
+  variable, else the historical default, so an operator can set a fleet-wide policy and a job
+  can override it. See README.md (Jobs) and env.example.
+*/
+
+// Load states a navigation can wait for, from strictest to loosest.
+const waitStates = exports.waitStates = ['networkidle', 'load', 'domcontentloaded'];
+// Defaults for navigation: the load state to wait for (NAV_WAIT_UNTIL; networkidle, the
+// historical default, never arrives on pages whose network never quiets, so a deployment may
+// prefer load), the time limit in ms (NAV_TIMEOUT), and whether a 4xx response ends launch
+// retries at once (NAV_FAIL_FAST_4XX; a client error is a definitive refusal that retrying
+// and switching browsers cannot change).
+const navTimeout = Number.parseInt(process.env.NAV_TIMEOUT);
+const navigationDefaults = {
+  waitUntil: waitStates.includes(process.env.NAV_WAIT_UNTIL) ? process.env.NAV_WAIT_UNTIL : 'networkidle',
+  timeout: navTimeout > 0 ? navTimeout : 10000,
+  failFast4xx: envFlag('NAV_FAIL_FAST_4XX')
+};
+// Returns the navigation options of a job: its navigation property over the defaults.
+exports.getNavigation = report => {
+  const own = report && report.navigation && typeof report.navigation === 'object'
+    ? report.navigation
+    : {};
+  return {
+    waitUntil: waitStates.includes(own.waitUntil) ? own.waitUntil : navigationDefaults.waitUntil,
+    timeout: Number.isInteger(own.timeout) && own.timeout > 0 ? own.timeout : navigationDefaults.timeout,
+    failFast4xx: typeof own.failFast4xx === 'boolean' ? own.failFast4xx : navigationDefaults.failFast4xx
+  };
+};
+// The scanner identity sent as the X-YRA-Scanner request header, so that web application
+// firewalls can recognize the scanner by a stable value (unlike the emulated User-Agent):
+// the job's scannerId, else SCANNER_ID, else none.
+exports.getScannerId = report => (report && report.scannerId) || process.env.SCANNER_ID || '';
+// Whether to scroll the full height of a page after navigation, before cataloguing, imaging,
+// and each tool, so that lazily loaded content is present: the job's scroll property, else
+// PRESCAN_SCROLL, else false (the as-loaded page, comparable with the WebAIM Million).
+exports.getScroll = report => (
+  report && typeof report.scroll === 'boolean' ? report.scroll : envFlag('PRESCAN_SCROLL')
+);
+// Launch retries per rule of the testaro tool, which relaunches the browser per contaminating
+// rule: TESTARO_RULE_RETRIES, else 2. Non-Chromium browsers navigate flakily on relaunch, so
+// a deployment testing them may raise this.
+const ruleRetries = Number.parseInt(process.env.TESTARO_RULE_RETRIES);
+exports.ruleLaunchRetries = ruleRetries >= 0 ? ruleRetries : 2;
+// Defaults for the qualWeb tool's browser: stealth evasions (QUALWEB_STEALTH) and ad and
+// tracker blocking (QUALWEB_ADBLOCK), both on by default as the tool was designed.
+exports.qualWebDefaults = {
+  stealth: envFlag('QUALWEB_STEALTH', true),
+  adBlock: envFlag('QUALWEB_ADBLOCK', true)
+};

package/procs/dateTime.js

@@ -28,7 +28,8 @@ exports.dateOf = timeStamp => {
     const dateString = punctuate(timeStamp.slice(0, 6), '-', 2);
     const timeString = punctuate(timeStamp.slice(7, 11), ':', 2);
     return new Date(`20${dateString}T${timeString}Z`);
-  } else {
+  }
+  else {
     return null;
   }
 };