testaro 41.0.0 → 41.0.2

package/run.js

@@ -25,12 +25,12 @@
   Testaro main utility module.
 */
 
-// ########## IMPORTS
+// IMPORTS
 
 // Module to keep secrets.
 require('dotenv').config();
-// Requirements for acts.
-const {actSpecs} = require('./actSpecs');
+// Module to validate jobs.
+const {isValidJob, tools} = require('./procs/job');
 // Module to standardize report formats.
 const {standardize} = require('./procs/standardize');
 // Module to identify element bounding boxes.
@@ -40,7 +40,7 @@ const {tellServer} = require('./procs/tellServer');
 // Module to get device options.
 const {getDeviceOptions, isDeviceID} = require('./procs/device');
 
-// ########## CONSTANTS
+// CONSTANTS
 
 // Set DEBUG environment variable to 'true' to add debugging features.
 const debug = process.env.DEBUG === 'true';
@@ -57,19 +57,6 @@ const moves = {
   select: 'select',
   text: 'input'
 };
-// Names and descriptions of tools.
-const tools = {
-  alfa: 'alfa',
-  aslint: 'ASLint',
-  axe: 'Axe',
-  ed11y: 'Editoria11y',
-  htmlcs: 'HTML CodeSniffer WCAG 2.1 AA ruleset',
-  ibm: 'IBM Accessibility Checker',
-  nuVal: 'Nu Html Checker',
-  qualWeb: 'QualWeb',
-  testaro: 'Testaro',
-  wave: 'WAVE',
-};
 // Strings in log messages indicating errors.
 const errorWords = [
   'but not used',
@@ -102,240 +89,7 @@ let browserContext;
 let currentPage;
 let requestedURL = '';
 
-// ########## VALIDATORS
-
-// Validates a browser type.
-const isBrowserID = type => ['chromium', 'firefox', 'webkit'].includes(type);
-// Validates a load state.
-const isState = string => ['loaded', 'idle'].includes(string);
-// Validates a URL.
-const isURL = string => /^(?:https?|file):\/\/[^\s]+$/.test(string);
-// Validates a focusable tag name.
-const isFocusable = string => ['a', 'button', 'input', 'select'].includes(string);
-// Returns whether all elements of an array are numbers.
-const areNumbers = array => array.every(element => typeof element === 'number');
-// Returns whether all elements of an array are strings.
-const areStrings = array => array.every(element => typeof element === 'string');
-// Returns whether all properties of an object have array values.
-const areArrays = object => Object.values(object).every(value => Array.isArray(value));
-// Returns whether a variable has a specified type.
-const hasType = (variable, type) => {
-  if (type === 'string') {
-    return typeof variable === 'string';
-  }
-  else if (type === 'array') {
-    return Array.isArray(variable);
-  }
-  else if (type === 'boolean') {
-    return typeof variable === 'boolean';
-  }
-  else if (type === 'number') {
-    return typeof variable === 'number';
-  }
-  else if (type === 'object') {
-    return typeof variable === 'object' && ! Array.isArray(variable);
-  }
-  else {
-    return false;
-  }
-};
-// Returns whether a variable has a specified subtype.
-const hasSubtype = (variable, subtype) => {
-  if (subtype) {
-    if (subtype === 'hasLength') {
-      return variable.length > 0;
-    }
-    else if (subtype === 'isURL') {
-      return isURL(variable);
-    }
-    else if (subtype === 'isDeviceID') {
-      return isDeviceID(variable);
-    }
-    else if (subtype === 'isBrowserID') {
-      return isBrowserID(variable);
-    }
-    else if (subtype === 'isFocusable') {
-      return isFocusable(variable);
-    }
-    else if (subtype === 'isTest') {
-      return tools[variable];
-    }
-    else if (subtype === 'isWaitable') {
-      return ['url', 'title', 'body'].includes(variable);
-    }
-    else if (subtype === 'areNumbers') {
-      return areNumbers(variable);
-    }
-    else if (subtype === 'areStrings') {
-      return areStrings(variable);
-    }
-    else if (subtype === 'areArrays') {
-      return areArrays(variable);
-    }
-    else if (subtype === 'isState') {
-      return isState(variable);
-    }
-    else {
-      console.log(`ERROR: ${subtype} not a known subtype`);
-      return false;
-    }
-  }
-  else {
-    return true;
-  }
-};
-// Validates an act by reference to actSpecs.js.
-const isValidAct = act => {
-  // Identify the type of the act.
-  const type = act.type;
-  // If the type exists and is known:
-  if (type && actSpecs.etc[type]) {
-    // Copy the validator of the type for possible expansion.
-    const validator = Object.assign({}, actSpecs.etc[type][1]);
-    // If the type is test:
-    if (type === 'test') {
-      // Identify the test.
-      const toolName = act.which;
-      // If one was specified and is known:
-      if (toolName && tools[toolName]) {
-        // If it has special properties:
-        if (actSpecs.tools[toolName]) {
-          // Expand the validator by adding them.
-          Object.assign(validator, actSpecs.tools[toolName][1]);
-        }
-      }
-      // Otherwise, i.e. if no or an unknown test was specified:
-      else {
-        // Return invalidity.
-        return false;
-      }
-    }
-    // Return whether the act is valid.
-    return Object.keys(validator).every(property => {
-      if (property === 'name') {
-        return true;
-      }
-      else {
-        const vP = validator[property];
-        const aP = act[property];
-        // If it is optional and omitted or is present and valid:
-        const optAndNone = ! vP[0] && ! aP;
-        const isValidAct = aP !== undefined && hasType(aP, vP[1]) && hasSubtype(aP, vP[2]);
-        return optAndNone || isValidAct;
-      }
-    });
-  }
-  // Otherwise, i.e. if the act has an unknown or no type:
-  else {
-    // Return invalidity.
-    return false;
-  }
-};
-// Inserts a character periodically in a string.
-const punctuate = (string, insertion, chunkSize) => {
-  const segments = [];
-  let startIndex = 0;
-  while (startIndex < string.length) {
-    segments.push(string.slice(startIndex, startIndex + chunkSize));
-    startIndex += chunkSize;
-  }
-  return segments.join(insertion);
-};
-// Converts a compact timestamp to a date.
-const dateOf = timeStamp => {
-  if (/^\d{6}T\d{4}$/.test(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 {
-    return null;
-  }
-};
-// Validates a report object.
-const isValidReport = report => {
-  if (report) {
-    // Return whether the report is valid.
-    const {
-      id,
-      strict,
-      isolate,
-      standard,
-      observe,
-      deviceID,
-      browserID,
-      lowMotion,
-      timeLimit,
-      creationTimeStamp,
-      executionTimeStamp,
-      sources,
-      acts
-    } = report;
-    if (! id || typeof id !== 'string') {
-      return 'Bad report ID';
-    }
-    if (typeof strict !== 'boolean') {
-      return 'Bad report strict';
-    }
-    if (typeof isolate !== 'boolean') {
-      return 'Bad report isolate';
-    }
-    if (! ['also', 'only', 'no'].includes(standard)) {
-      return 'Bad report standard';
-    }
-    if (typeof observe !== 'boolean') {
-      return 'Bad report observe';
-    }
-    if (! isDeviceID(deviceID)) {
-      return 'Bad report deviceID';
-    }
-    if (! ['chromium', 'firefox', 'webkit'].includes(browserID)) {
-      return 'Bad report browserID';
-    }
-    if (typeof lowMotion !== 'boolean') {
-      return 'Bad report lowMotion';
-    }
-    if (typeof timeLimit !== 'number' || timeLimit < 1) {
-      return 'Bad report timeLimit';
-    }
-    if (
-      ! (creationTimeStamp && typeof creationTimeStamp === 'string' && dateOf(creationTimeStamp))
-    ) {
-      return 'bad job creationTimeStamp';
-    }
-    if (
-      ! (executionTimeStamp && typeof executionTimeStamp === 'string') && dateOf(executionTimeStamp)
-    ) {
-      return 'bad report executionTimeStamp';
-    }
-    if (
-      ! sources
-      || typeof sources !== 'object'
-      || ! ['script', 'batch', 'target'].every(key => sources[key])
-      || ! ['what', 'url'].every(key => sources.target[key])
-    ) {
-      return 'Bad report sources';
-    }
-    if (
-      ! acts
-      || ! Array.isArray(acts)
-      || acts.length < 2
-      || ! acts.every(act => act.type && typeof act.type === 'string')
-      || acts[0].type !== 'launch'
-    ) {
-      return 'Bad report acts';
-    }
-    const invalidAct = acts.find(act => ! isValidAct(act));
-    if (invalidAct) {
-      return `Invalid act:\n${JSON.stringify(invalidAct, null, 2)}`;
-    }
-    return '';
-  }
-  else {
-    return 'no report';
-  }
-};
-
-// ########## OTHER FUNCTIONS
+// FUNCTIONS
 
 // Returns a string with any final slash removed.
 const deSlash = string => string.endsWith('/') ? string.slice(0, -1) : string;
@@ -766,7 +520,7 @@ const abortActs = async (report, actIndex) => {
   report.jobData.abortTime = nowString();
   report.jobData.abortedAct = actIndex;
   report.jobData.aborted = true;
-  // Report the job being aborted.
+  // Report that the job is aborted.
   console.log('ERROR: Job aborted');
   // Return an abortive act index.
   return -2;
@@ -804,827 +558,806 @@ const addError = async(alsoLog, alsoAbort, report, actIndex, message) => {
 };
 // Recursively performs the acts in a report.
 const doActs = async (report, actIndex, page) => {
-  // FUNCTION DEFINITION START
-  // Quits and reports the job being aborted.
-  const abortActs = async () => {
-    // Add data on the aborted act to the report.
-    report.jobData.abortTime = nowString();
-    report.jobData.abortedAct = actIndex;
-    report.jobData.aborted = true;
-    // Prevent performance of additional acts.
-    actIndex = -2;
-    // Report this.
-    console.log('ERROR: Job aborted');
-  };
-  // FUNCTION DEFINITION END
   const {acts} = report;
   // If any more acts are to be performed:
   if (actIndex > -1 && actIndex < acts.length) {
     // Identify the act to be performed.
     const act = acts[actIndex];
     const {type, which} = act;
-    // If it is valid:
-    if (isValidAct(act)) {
-      const actSuffix = type === 'test' ? ` ${which}` : '';
-      const message = `>>>> ${type}${actSuffix}`;
-      // If granular reporting has been specified:
-      if (report.observe) {
-        // Notify the observer of the act and log it.
-        const whichParam = which ? `&which=${which}` : '';
-        const messageParams = `act=${type}${whichParam}`;
-        tellServer(report, messageParams, message);
-      }
-      // Otherwise, i.e. if granular reporting has not been specified:
-      else {
-        // Log the act.
-        console.log(message);
+    const actSuffix = type === 'test' ? ` ${which}` : '';
+    const message = `>>>> ${type}${actSuffix}`;
+    // If granular reporting has been specified:
+    if (report.observe) {
+      // Notify the observer of the act and log it.
+      const whichParam = which ? `&which=${which}` : '';
+      const messageParams = `act=${type}${whichParam}`;
+      tellServer(report, messageParams, message);
+    }
+    // Otherwise, i.e. if granular reporting has not been specified:
+    else {
+      // Log the act.
+      console.log(message);
+    }
+    // Increment the count of acts performed.
+    actCount++;
+    act.startTime = Date.now();
+    // If the act is an index changer:
+    if (type === 'next') {
+      const condition = act.if;
+      const logSuffix = condition.length === 3 ? ` ${condition[1]} ${condition[2]}` : '';
+      console.log(`>> ${condition[0]}${logSuffix}`);
+      // Identify the act to be checked.
+      const ifActIndex = report.acts.map(act => act.type !== 'next').lastIndexOf(true);
+      // Determine whether its jump condition is true.
+      const truth = isTrue(report.acts[ifActIndex].result, condition);
+      // Add the result to the act.
+      act.result = {
+        property: condition[0],
+        relation: condition[1],
+        criterion: condition[2],
+        value: truth[0],
+        jumpRequired: truth[1]
+      };
+      // If the condition is true:
+      if (truth[1]) {
+        // If the performance of acts is to stop:
+        if (act.jump === 0) {
+          // Quit.
+          actIndex = -2;
+        }
+        // Otherwise, if there is a numerical jump:
+        else if (act.jump) {
+          // Set the act index accordingly.
+          actIndex += act.jump - 1;
+        }
+        // Otherwise, if there is a named next act:
+        else if (act.next) {
+          // Set the new index accordingly, or stop if it does not exist.
+          actIndex = acts.map(act => act.name).indexOf(act.next) - 1;
+        }
       }
-      // Increment the count of acts performed.
-      actCount++;
-      act.startTime = Date.now();
-      // If the act is an index changer:
-      if (type === 'next') {
-        const condition = act.if;
-        const logSuffix = condition.length === 3 ? ` ${condition[1]} ${condition[2]}` : '';
-        console.log(`>> ${condition[0]}${logSuffix}`);
-        // Identify the act to be checked.
-        const ifActIndex = report.acts.map(act => act.type !== 'next').lastIndexOf(true);
-        // Determine whether its jump condition is true.
-        const truth = isTrue(report.acts[ifActIndex].result, condition);
-        // Add the result to the act.
-        act.result = {
-          property: condition[0],
-          relation: condition[1],
-          criterion: condition[2],
-          value: truth[0],
-          jumpRequired: truth[1]
-        };
-        // If the condition is true:
-        if (truth[1]) {
-          // If the performance of acts is to stop:
-          if (act.jump === 0) {
-            // Quit.
-            actIndex = -2;
-          }
-          // Otherwise, if there is a numerical jump:
-          else if (act.jump) {
-            // Set the act index accordingly.
-            actIndex += act.jump - 1;
-          }
-          // Otherwise, if there is a named next act:
-          else if (act.next) {
-            // Set the new index accordingly, or stop if it does not exist.
-            actIndex = acts.map(act => act.name).indexOf(act.next) - 1;
-          }
+    }
+    // Otherwise, if the act is a launch:
+    else if (type === 'launch') {
+      // Launch the specified browser on the specified device and navigate to the specified URL.
+      const launchResult = await launch(
+        report,
+        act.url || report.sources.target.url,
+        debug,
+        waits,
+        act.deviceID || report.deviceID,
+        act.browserID || report.browserID,
+        act.lowMotion || report.lowMotion
+      );
+      // If the launch and navigation succeeded:
+      if (launchResult && launchResult.success) {
+        // Get the response of the target server.
+        const {response} = launchResult;
+        // Get the target page.
+        page = launchResult.page;
+        // Add the actual URL to the act.
+        act.actualURL = page.url();
+        // Add the script nonce, if any, to the act.
+        const scriptNonce = await getNonce(response);
+        if (scriptNonce) {
+          report.jobData.lastScriptNonce = scriptNonce;
         }
       }
-      // Otherwise, if the act is a launch:
-      else if (type === 'launch') {
-        // Launch the specified browser on the specified device and navigate to the specified URL.
-        const launchResult = await launch(
-          report,
-          act.url || report.sources.target.url,
-          debug,
-          waits,
-          act.deviceID || report.deviceID,
-          act.browserID || report.browserID,
-          act.lowMotion || report.lowMotion
+      // Otherwise, i.e. if the launch or navigation failed:
+      else {
+        // Add an error result to the act and abort the job.
+        actIndex = await addError(
+          true, true, report, actIndex, `ERROR: Launch failed (${launchResult.error})`
         );
-        // If the launch and navigation succeeded:
-        if (launchResult && launchResult.success) {
-          // Get the response of the target server.
-          const {response} = launchResult;
-          // Get the target page.
-          page = launchResult.page;
-          // Add the actual URL to the act.
-          act.actualURL = page.url();
+      }
+    }
+    // Otherwise, if a current page exists:
+    else if (page) {
+      // If the act is navigation to a url:
+      if (act.type === 'url') {
+        // Identify the URL.
+        const resolved = act.which.replace('__dirname', __dirname);
+        requestedURL = resolved;
+        // Visit it and wait until the DOM is loaded.
+        const navResult = await goTo(report, page, requestedURL, 15000, 'domcontentloaded');
+        // If the visit succeeded:
+        if (navResult.success) {
           // Add the script nonce, if any, to the act.
-          const scriptNonce = await getNonce(response);
+          const {response} = navResult;
+          const scriptNonce = getNonce(response);
           if (scriptNonce) {
             report.jobData.lastScriptNonce = scriptNonce;
           }
+          // Add the resulting URL to the act.
+          if (! act.result) {
+            act.result = {};
+          }
+          act.result.url = page.url();
+          // If a prohibited redirection occurred:
+          if (response.exception === 'badRedirection') {
+            // Report this and abort the job.
+            actIndex = await addError(
+              true, true, report, actIndex, 'ERROR: Navigation illicitly redirected'
+            );
+          }
         }
-        // Otherwise, i.e. if the launch or navigation failed:
+        // Otherwise, i.e. if the visit failed:
         else {
-          // Add an error result to the act and abort the job.
-          actIndex = await addError(
-            true, true, report, actIndex, `ERROR: Launch failed (${launchResult.error})`
-          );
+          // Report this and abort the job.
+          actIndex = await addError(true, true, report, actIndex, 'ERROR: Visit failed');
         }
       }
-      // Otherwise, if a current page exists:
-      else if (page) {
-        // If the act is navigation to a url:
-        if (act.type === 'url') {
-          // Identify the URL.
-          const resolved = act.which.replace('__dirname', __dirname);
-          requestedURL = resolved;
-          // Visit it and wait until the DOM is loaded.
-          const navResult = await goTo(report, page, requestedURL, 15000, 'domcontentloaded');
-          // If the visit succeeded:
-          if (navResult.success) {
-            // Add the script nonce, if any, to the act.
-            const {response} = navResult;
-            const scriptNonce = getNonce(response);
-            if (scriptNonce) {
-              report.jobData.lastScriptNonce = scriptNonce;
-            }
-            // Add the resulting URL to the act.
-            if (! act.result) {
-              act.result = {};
-            }
-            act.result.url = page.url();
-            // If a prohibited redirection occurred:
-            if (response.exception === 'badRedirection') {
-              // Report this and abort the job.
-              actIndex = await addError(
-                true, true, report, actIndex, 'ERROR: Navigation illicitly redirected'
-              );
-            }
+      // Otherwise, if the act is a wait for text:
+      else if (act.type === 'wait') {
+        const {what, which} = act;
+        console.log(`>> ${what}`);
+        const result = act.result = {};
+        // If the text is to be the URL:
+        if (what === 'url') {
+          // Wait for the URL to be the exact text.
+          try {
+            await page.waitForURL(which, {timeout: 15000});
+            result.found = true;
+            result.url = page.url();
           }
-          // Otherwise, i.e. if the visit failed:
-          else {
-            // Report this and abort the job.
-            actIndex = await addError(true, true, report, actIndex, 'ERROR: Visit failed');
+          // If the wait times out:
+          catch(error) {
+            // Quit.
+            actIndex = await abortActs(report, actIndex);
+            waitError(page, act, error, 'text in the URL');
           }
         }
-        // Otherwise, if the act is a wait for text:
-        else if (act.type === 'wait') {
-          const {what, which} = act;
-          console.log(`>> ${what}`);
-          const result = act.result = {};
-          // If the text is to be the URL:
-          if (what === 'url') {
-            // Wait for the URL to be the exact text.
-            try {
-              await page.waitForURL(which, {timeout: 15000});
-              result.found = true;
-              result.url = page.url();
-            }
-            // If the wait times out:
-            catch(error) {
-              // Quit.
-              await abortActs();
-              waitError(page, act, error, 'text in the URL');
-            }
-          }
-          // Otherwise, if the text is to be a substring of the page title:
-          else if (what === 'title') {
-            // Wait for the page title to include the text, case-insensitively.
-            try {
-              await page.waitForFunction(
-                text => document
-                && document.title
-                && document.title.toLowerCase().includes(text.toLowerCase()),
-                which,
-                {
-                  polling: 1000,
-                  timeout: 5000
-                }
-              );
-              result.found = true;
-              result.title = await page.title();
-            }
-            // If the wait times out:
-            catch(error) {
-              // Quit.
-              await abortActs();
-              waitError(page, act, error, 'text in the title');
-            }
+        // Otherwise, if the text is to be a substring of the page title:
+        else if (what === 'title') {
+          // Wait for the page title to include the text, case-insensitively.
+          try {
+            await page.waitForFunction(
+              text => document
+              && document.title
+              && document.title.toLowerCase().includes(text.toLowerCase()),
+              which,
+              {
+                polling: 1000,
+                timeout: 5000
+              }
+            );
+            result.found = true;
+            result.title = await page.title();
           }
-          // Otherwise, if the text is to be a substring of the text of the page body:
-          else if (what === 'body') {
-            // Wait for the body to include the text, case-insensitively.
-            try {
-              await page.waitForFunction(
-                text => document
-                && document.body
-                && document.body.innerText.toLowerCase().includes(text.toLowerCase()),
-                which,
-                {
-                  polling: 2000,
-                  timeout: 15000
-                }
-              );
-              result.found = true;
-            }
-            // If the wait times out:
-            catch(error) {
-              // Quit.
-              await abortActs();
-              waitError(page, act, error, 'text in the body');
-            }
+          // If the wait times out:
+          catch(error) {
+            // Quit.
+            actIndex = await abortActs(report, actIndex);
+            waitError(page, act, error, 'text in the title');
           }
         }
-        // Otherwise, if the act is a wait for a state:
-        else if (act.type === 'state') {
-          // Wait for it.
-          const stateIndex = ['loaded', 'idle'].indexOf(act.which);
-          await page.waitForLoadState(
-            ['domcontentloaded', 'networkidle'][stateIndex], {timeout: [10000, 15000][stateIndex]}
-          )
-          // If the wait times out:
-          .catch(async error => {
-            // Report this and abort the job.
-            console.log(`ERROR waiting for page to be ${act.which} (${error.message})`);
-            actIndex = await addError(
-              true, true, report, actIndex, `ERROR waiting for page to be ${act.which}`
+        // Otherwise, if the text is to be a substring of the text of the page body:
+        else if (what === 'body') {
+          // Wait for the body to include the text, case-insensitively.
+          try {
+            await page.waitForFunction(
+              text => document
+              && document.body
+              && document.body.innerText.toLowerCase().includes(text.toLowerCase()),
+              which,
+              {
+                polling: 2000,
+                timeout: 15000
+              }
             );
-          });
-          // If the wait succeeded:
-          if (actIndex > -2) {
-            // Add state data to the report.
-            act.result = {
-              success: true,
-              state: act.which
-            };
+            result.found = true;
+          }
+          // If the wait times out:
+          catch(error) {
+            // Quit.
+            actIndex = await abortActs(report, actIndex);
+            waitError(page, act, error, 'text in the body');
           }
         }
-        // Otherwise, if the act is a page switch:
-        else if (act.type === 'page') {
-          // Wait for a page to be created and identify it as current.
-          page = await browserContext.waitForEvent('page');
-          // Wait until it is idle.
-          await page.waitForLoadState('networkidle', {timeout: 15000});
-          // Add the resulting URL to the act.
-          const result = {
-            url: page.url()
+      }
+      // Otherwise, if the act is a wait for a state:
+      else if (act.type === 'state') {
+        // Wait for it.
+        const stateIndex = ['loaded', 'idle'].indexOf(act.which);
+        await page.waitForLoadState(
+          ['domcontentloaded', 'networkidle'][stateIndex], {timeout: [10000, 15000][stateIndex]}
+        )
+        // If the wait times out:
+        .catch(async error => {
+          // Report this and abort the job.
+          console.log(`ERROR waiting for page to be ${act.which} (${error.message})`);
+          actIndex = await addError(
+            true, true, report, actIndex, `ERROR waiting for page to be ${act.which}`
+          );
+        });
+        // If the wait succeeded:
+        if (actIndex > -2) {
+          // Add state data to the report.
+          act.result = {
+            success: true,
+            state: act.which
           };
-          act.result = result;
         }
-        // Otherwise, if the page has a URL:
-        else if (page.url() && page.url() !== 'about:blank') {
-          const url = page.url();
-          // Add the URL to the act.
-          act.actualURL = url;
-          // If the act is a revelation:
-          if (act.type === 'reveal') {
-            // Make all elements in the page visible.
-            await page.$$eval('body *', elements => {
-              elements.forEach(element => {
-                const styleDec = window.getComputedStyle(element);
-                if (styleDec.display === 'none') {
-                  element.style.display = 'initial';
-                }
-                if (['hidden', 'collapse'].includes(styleDec.visibility)) {
-                  element.style.visibility = 'inherit';
-                }
-              });
-              act.result = {
-                success: true
-              };
-            })
-            .catch(error => {
-              console.log(`ERROR making all elements visible (${error.message})`);
-              act.result = {
-                success: false
-              };
-            });
-          }
-          // Otherwise, if the act performs tests of a tool:
-          else if (act.type === 'test') {
-            // Add a description of the tool to the act.
-            act.what = tools[act.which];
-            // Initialize the options argument.
-            const options = {
-              report,
-              act
-            };
-            // Add any specified arguments to it.
-            Object.keys(act).forEach(key => {
-              if (! ['type', 'which'].includes(key)) {
-                options[key] = act[key];
+      }
+      // Otherwise, if the act is a page switch:
+      else if (act.type === 'page') {
+        // Wait for a page to be created and identify it as current.
+        page = await browserContext.waitForEvent('page');
+        // Wait until it is idle.
+        await page.waitForLoadState('networkidle', {timeout: 15000});
+        // Add the resulting URL to the act.
+        const result = {
+          url: page.url()
+        };
+        act.result = result;
+      }
+      // Otherwise, if the page has a URL:
+      else if (page.url() && page.url() !== 'about:blank') {
+        const url = page.url();
+        // Add the URL to the act.
+        act.actualURL = url;
+        // If the act is a revelation:
+        if (act.type === 'reveal') {
+          // Make all elements in the page visible.
+          await page.$$eval('body *', elements => {
+            elements.forEach(element => {
+              const styleDec = window.getComputedStyle(element);
+              if (styleDec.display === 'none') {
+                element.style.display = 'initial';
               }
-            });
-            // Get the start time of the act.
-            const startTime = Date.now();
-            // Perform the specified tests of the tool and get a report.
-            try {
-              const actReport = await require(`./tests/${act.which}`).reporter(page, options);
-              // Import its test results and process data into the act.
-              act.result = actReport && actReport.result || {};
-              act.data = actReport && actReport.data || {};
-              // If the page prevented the tool from operating:
-              if (act.data.prevented) {
-                // Add prevention data to the job data.
-                report.jobData.preventions[act.which] = act.data.error;
+              if (['hidden', 'collapse'].includes(styleDec.visibility)) {
+                element.style.visibility = 'inherit';
               }
+            });
+            act.result = {
+              success: true
+            };
+          })
+          .catch(error => {
+            console.log(`ERROR making all elements visible (${error.message})`);
+            act.result = {
+              success: false
+            };
+          });
+        }
+        // Otherwise, if the act performs tests of a tool:
+        else if (act.type === 'test') {
+          // Add a description of the tool to the act.
+          act.what = tools[act.which];
+          // Initialize the options argument.
+          const options = {
+            report,
+            act
+          };
+          // Add any specified arguments to it.
+          Object.keys(act).forEach(key => {
+            if (! ['type', 'which'].includes(key)) {
+              options[key] = act[key];
             }
-            // If the testing failed:
-            catch(error) {
-              // Report this.
-              const message = error.message.slice(0, 400);
-              console.log(`ERROR: Test act ${act.which} failed (${message})`);
-              act.data.error = act.data.error ? `${act.data.error}; ${message}` : message;
-            }
-            // Add the elapsed time of the tool to the report.
-            const time = Math.round((Date.now() - startTime) / 1000);
-            const {toolTimes} = report.jobData;
-            if (! toolTimes[act.which]) {
-              toolTimes[act.which] = 0;
+          });
+          // Get the start time of the act.
+          const startTime = Date.now();
+          // Perform the specified tests of the tool and get a report.
+          try {
+            const actReport = await require(`./tests/${act.which}`).reporter(page, options);
+            // Import its test results and process data into the act.
+            act.result = actReport && actReport.result || {};
+            act.data = actReport && actReport.data || {};
+            // If the page prevented the tool from operating:
+            if (act.data.prevented) {
+              // Add prevention data to the job data.
+              report.jobData.preventions[act.which] = act.data.error;
             }
-            toolTimes[act.which] += time;
-            // If a standard-format result is to be included in the report:
-            const standard = report.standard || 'only';
-            if (['also', 'only'].includes(standard)) {
-              // Initialize it.
-              act.standardResult = {
-                totals: [0, 0, 0, 0],
-                instances: []
-              };
-              // Populate it.
-              standardize(act);
-              // Add a box ID and a path ID to each of its standard instances if missing.
-              for (const instance of act.standardResult.instances) {
-                const elementID = await identify(instance, page);
-                if (! instance.boxID) {
-                  instance.boxID = elementID ? elementID.boxID : '';
-                }
-                if (! instance.pathID) {
-                  instance.pathID = elementID ? elementID.pathID : '';
-                }
-              };
-              // If the original-format result is not to be included in the report:
-              if (standard === 'only') {
-                // Remove it.
-                delete act.result;
+          }
+          // If the testing failed:
+          catch(error) {
+            // Report this.
+            const message = error.message.slice(0, 400);
+            console.log(`ERROR: Test act ${act.which} failed (${message})`);
+            act.data.error = act.data.error ? `${act.data.error}; ${message}` : message;
+          }
+          // Add the elapsed time of the tool to the report.
+          const time = Math.round((Date.now() - startTime) / 1000);
+          const {toolTimes} = report.jobData;
+          if (! toolTimes[act.which]) {
+            toolTimes[act.which] = 0;
+          }
+          toolTimes[act.which] += time;
+          // If a standard-format result is to be included in the report:
+          const standard = report.standard || 'only';
+          if (['also', 'only'].includes(standard)) {
+            // Initialize it.
+            act.standardResult = {
+              totals: [0, 0, 0, 0],
+              instances: []
+            };
+            // Populate it.
+            standardize(act);
+            // Add a box ID and a path ID to each of its standard instances if missing.
+            for (const instance of act.standardResult.instances) {
+              const elementID = await identify(instance, page);
+              if (! instance.boxID) {
+                instance.boxID = elementID ? elementID.boxID : '';
               }
+              if (! instance.pathID) {
+                instance.pathID = elementID ? elementID.pathID : '';
+              }
+            };
+            // If the original-format result is not to be included in the report:
+            if (standard === 'only') {
+              // Remove it.
+              delete act.result;
             }
-            // If the act has expectations:
-            const expectations = act.expect;
-            if (expectations) {
-              // Initialize whether they were fulfilled.
-              act.expectations = [];
-              let failureCount = 0;
-              // For each expectation:
-              expectations.forEach(spec => {
-                const truth = isTrue(act, spec);
-                act.expectations.push({
-                  property: spec[0],
-                  relation: spec[1],
-                  criterion: spec[2],
-                  actual: truth[0],
-                  passed: truth[1]
-                });
-                if (! truth[1]) {
-                  failureCount++;
-                }
+          }
+          // If the act has expectations:
+          const expectations = act.expect;
+          if (expectations) {
+            // Initialize whether they were fulfilled.
+            act.expectations = [];
+            let failureCount = 0;
+            // For each expectation:
+            expectations.forEach(spec => {
+              const truth = isTrue(act, spec);
+              act.expectations.push({
+                property: spec[0],
+                relation: spec[1],
+                criterion: spec[2],
+                actual: truth[0],
+                passed: truth[1]
               });
-              act.expectationFailures = failureCount;
-            }
+              if (! truth[1]) {
+                failureCount++;
+              }
+            });
+            act.expectationFailures = failureCount;
           }
-          // Otherwise, if the act is a move:
-          else if (moves[act.type]) {
-            const selector = typeof moves[act.type] === 'string' ? moves[act.type] : act.what;
-            // Try up to 5 times to:
-            act.result = {found: false};
-            let selection = {};
-            let tries = 0;
-            const slimText = act.which ? debloat(act.which) : '';
-            while (tries++ < 5 && ! act.result.found) {
-              if (page) {
-                // Identify the elements of the specified type.
-                const selections = await page.$$(selector);
-                // If there are any:
-                if (selections.length) {
-                  // If there are enough to make a match possible:
-                  if ((act.index || 0) < selections.length) {
-                    // For each element of the specified type:
-                    let matchCount = 0;
-                    const selectionTexts = [];
-                    for (selection of selections) {
-                      // Add its lower-case text or an empty string to the list of element texts.
-                      const selectionText = slimText ? await textOf(page, selection) : '';
-                      selectionTexts.push(selectionText);
-                      // If its text includes any specified text, case-insensitively:
-                      if (selectionText.includes(slimText)) {
-                        // If the element has the specified index among such elements:
-                        if (matchCount++ === (act.index || 0)) {
-                          // Report it as the matching element and stop checking.
-                          act.result.found = true;
-                          act.result.textSpec = slimText;
-                          act.result.textContent = selectionText;
-                          break;
-                        }
-                      }
-                    }
-                    // If no element satisfied the specifications:
-                    if (! act.result.found) {
-                      // Add the failure data to the report.
-                      act.result.success = false;
-                      act.result.error = 'exhausted';
-                      act.result.typeElementCount = selections.length;
-                      if (slimText) {
-                        act.result.textElementCount = --matchCount;
+        }
+        // Otherwise, if the act is a move:
+        else if (moves[act.type]) {
+          const selector = typeof moves[act.type] === 'string' ? moves[act.type] : act.what;
+          // Try up to 5 times to:
+          act.result = {found: false};
+          let selection = {};
+          let tries = 0;
+          const slimText = act.which ? debloat(act.which) : '';
+          while (tries++ < 5 && ! act.result.found) {
+            if (page) {
+              // Identify the elements of the specified type.
+              const selections = await page.$$(selector);
+              // If there are any:
+              if (selections.length) {
+                // If there are enough to make a match possible:
+                if ((act.index || 0) < selections.length) {
+                  // For each element of the specified type:
+                  let matchCount = 0;
+                  const selectionTexts = [];
+                  for (selection of selections) {
+                    // Add its lower-case text or an empty string to the list of element texts.
+                    const selectionText = slimText ? await textOf(page, selection) : '';
+                    selectionTexts.push(selectionText);
+                    // If its text includes any specified text, case-insensitively:
+                    if (selectionText.includes(slimText)) {
+                      // If the element has the specified index among such elements:
+                      if (matchCount++ === (act.index || 0)) {
+                        // Report it as the matching element and stop checking.
+                        act.result.found = true;
+                        act.result.textSpec = slimText;
+                        act.result.textContent = selectionText;
+                        break;
                       }
-                      act.result.message = 'Not enough specified elements exist';
-                      act.result.candidateTexts = selectionTexts;
                     }
                   }
-                  // Otherwise, i.e. if there are too few such elements to make a match possible:
-                  else {
+                  // If no element satisfied the specifications:
+                  if (! act.result.found) {
                     // Add the failure data to the report.
                     act.result.success = false;
-                    act.result.error = 'fewer';
+                    act.result.error = 'exhausted';
                     act.result.typeElementCount = selections.length;
-                    act.result.message = 'Elements of specified type too few';
+                    if (slimText) {
+                      act.result.textElementCount = --matchCount;
+                    }
+                    act.result.message = 'Not enough specified elements exist';
+                    act.result.candidateTexts = selectionTexts;
                   }
                 }
-                // Otherwise, i.e. if there are no elements of the specified type:
+                // Otherwise, i.e. if there are too few such elements to make a match possible:
                 else {
                   // Add the failure data to the report.
                   act.result.success = false;
-                  act.result.error = 'none';
-                  act.result.typeElementCount = 0;
-                  act.result.message = 'No elements of specified type found';
+                  act.result.error = 'fewer';
+                  act.result.typeElementCount = selections.length;
+                  act.result.message = 'Elements of specified type too few';
                 }
               }
-              // Otherwise, i.e. if the page no longer exists:
+              // Otherwise, i.e. if there are no elements of the specified type:
               else {
                 // Add the failure data to the report.
                 act.result.success = false;
-                act.result.error = 'gone';
-                act.result.message = 'Page gone';
-              }
-              if (! act.result.found) {
-                await wait(2000);
+                act.result.error = 'none';
+                act.result.typeElementCount = 0;
+                act.result.message = 'No elements of specified type found';
               }
             }
-            // If a match was found:
-            if (act.result.found) {
-              // FUNCTION DEFINITION START
-              // Performs a click or Enter keypress and waits for the network to be idle.
-              const doAndWait = async isClick => {
-                // Perform and report the move.
-                const move = isClick ? 'click' : 'Enter keypress';
+            // Otherwise, i.e. if the page no longer exists:
+            else {
+              // Add the failure data to the report.
+              act.result.success = false;
+              act.result.error = 'gone';
+              act.result.message = 'Page gone';
+            }
+            if (! act.result.found) {
+              await wait(2000);
+            }
+          }
+          // If a match was found:
+          if (act.result.found) {
+            // FUNCTION DEFINITION START
+            // Performs a click or Enter keypress and waits for the network to be idle.
+            const doAndWait = async isClick => {
+              // Perform and report the move.
+              const move = isClick ? 'click' : 'Enter keypress';
+              try {
+                await isClick
+                  ? selection.click({timeout: 4000})
+                  : selection.press('Enter', {timeout: 4000});
+                act.result.success = true;
+                act.result.move = move;
+              }
+              // If the move fails:
+              catch(error) {
+                // Add the error result to the act and abort the job.
+                actIndex = await addError(true, true, report, actIndex, `ERROR: ${move} failed`);
+              }
+              if (act.result.success) {
                 try {
-                  await isClick
-                    ? selection.click({timeout: 4000})
-                    : selection.press('Enter', {timeout: 4000});
-                  act.result.success = true;
-                  act.result.move = move;
+                  await page.context().waitForEvent('networkidle', {timeout: 10000});
+                  act.result.idleTimely = true;
                 }
-                // If the move fails:
                 catch(error) {
-                  // Add the error result to the act and abort the job.
-                  actIndex = await addError(true, true, report, actIndex, `ERROR: ${move} failed`);
+                  console.log(`ERROR: Network busy after ${move} (${errorStart(error)})`);
+                  act.result.idleTimely = false;
                 }
-                if (act.result.success) {
-                  try {
-                    await page.context().waitForEvent('networkidle', {timeout: 10000});
-                    act.result.idleTimely = true;
-                  }
-                  catch(error) {
-                    console.log(`ERROR: Network busy after ${move} (${errorStart(error)})`);
-                    act.result.idleTimely = false;
-                  }
-                  // If the move created a new page, make it current.
-                  page = currentPage;
-                  act.result.newURL = page.url();
-                }
-              };
-              // FUNCTION DEFINITION END
-              // If the move is a button click, perform it.
-              if (act.type === 'button') {
-                await selection.click({timeout: 3000});
-                act.result.success = true;
-                act.result.move = 'clicked';
+                // If the move created a new page, make it current.
+                page = currentPage;
+                act.result.newURL = page.url();
               }
-              // Otherwise, if it is checking a radio button or checkbox, perform it.
-              else if (['checkbox', 'radio'].includes(act.type)) {
-                await selection.waitForElementState('stable', {timeout: 2000})
-                .catch(error => {
-                  console.log(`ERROR waiting for stable ${act.type} (${error.message})`);
-                  act.result.success = false;
-                  act.result.error = `ERROR waiting for stable ${act.type}`;
-                });
-                if (! act.result.error) {
-                  const isEnabled = await selection.isEnabled();
-                  if (isEnabled) {
-                    await selection.check({
-                      force: true,
-                      timeout: 2000
-                    })
-                    .catch(error => {
-                      console.log(`ERROR checking ${act.type} (${error.message})`);
-                      act.result.success = false;
-                      act.result.error = `ERROR checking ${act.type}`;
-                    });
-                    if (! act.result.error) {
-                      act.result.success = true;
-                      act.result.move = 'checked';
-                    }
-                  }
-                  else {
-                    const report = `ERROR: could not check ${act.type} because disabled`;
-                    console.log(report);
+            };
+            // FUNCTION DEFINITION END
+            // If the move is a button click, perform it.
+            if (act.type === 'button') {
+              await selection.click({timeout: 3000});
+              act.result.success = true;
+              act.result.move = 'clicked';
+            }
+            // Otherwise, if it is checking a radio button or checkbox, perform it.
+            else if (['checkbox', 'radio'].includes(act.type)) {
+              await selection.waitForElementState('stable', {timeout: 2000})
+              .catch(error => {
+                console.log(`ERROR waiting for stable ${act.type} (${error.message})`);
+                act.result.success = false;
+                act.result.error = `ERROR waiting for stable ${act.type}`;
+              });
+              if (! act.result.error) {
+                const isEnabled = await selection.isEnabled();
+                if (isEnabled) {
+                  await selection.check({
+                    force: true,
+                    timeout: 2000
+                  })
+                  .catch(error => {
+                    console.log(`ERROR checking ${act.type} (${error.message})`);
                     act.result.success = false;
-                    act.result.error = report;
+                    act.result.error = `ERROR checking ${act.type}`;
+                  });
+                  if (! act.result.error) {
+                    act.result.success = true;
+                    act.result.move = 'checked';
                   }
                 }
+                else {
+                  const report = `ERROR: could not check ${act.type} because disabled`;
+                  console.log(report);
+                  act.result.success = false;
+                  act.result.error = report;
+                }
               }
-              // Otherwise, if it is focusing the element, perform it.
-              else if (act.type === 'focus') {
-                await selection.focus({timeout: 2000});
-                act.result.success = true;
-                act.result.move = 'focused';
+            }
+            // Otherwise, if it is focusing the element, perform it.
+            else if (act.type === 'focus') {
+              await selection.focus({timeout: 2000});
+              act.result.success = true;
+              act.result.move = 'focused';
+            }
+            // Otherwise, if it is clicking a link:
+            else if (act.type === 'link') {
+              const href = await selection.getAttribute('href');
+              const target = await selection.getAttribute('target');
+              act.result.href = href || 'NONE';
+              act.result.target = target || 'DEFAULT';
+              // If the destination is a new page:
+              if (target && target !== '_self') {
+                // Click the link and wait for the network to be idle.
+                doAndWait(true);
               }
-              // Otherwise, if it is clicking a link:
-              else if (act.type === 'link') {
-                const href = await selection.getAttribute('href');
-                const target = await selection.getAttribute('target');
-                act.result.href = href || 'NONE';
-                act.result.target = target || 'DEFAULT';
-                // If the destination is a new page:
-                if (target && target !== '_self') {
-                  // Click the link and wait for the network to be idle.
-                  doAndWait(true);
+              // Otherwise, i.e. if the destination is in the current page:
+              else {
+                // Click the link and wait for the resulting navigation.
+                try {
+                  await selection.click({timeout: 5000});
+                  // Wait for the new content to load.
+                  await page.waitForLoadState('domcontentloaded', {timeout: 6000});
+                  act.result.success = true;
+                  act.result.move = 'clicked';
+                  act.result.newURL = page.url();
                 }
-                // Otherwise, i.e. if the destination is in the current page:
-                else {
-                  // Click the link and wait for the resulting navigation.
-                  try {
-                    await selection.click({timeout: 5000});
-                    // Wait for the new content to load.
-                    await page.waitForLoadState('domcontentloaded', {timeout: 6000});
-                    act.result.success = true;
-                    act.result.move = 'clicked';
-                    act.result.newURL = page.url();
-                  }
-                  // If the click or load failed:
-                  catch(error) {
-                    // Quit and add failure data to the report.
-                    console.log(`ERROR clicking link (${errorStart(error)})`);
-                    act.result.success = false;
-                    act.result.error = 'unclickable';
-                    act.result.message = 'ERROR: click or load timed out';
-                    await abortActs();
-                  }
-                  // If the link click succeeded:
-                  if (! act.result.error) {
-                    // Add success data to the report.
-                    act.result.success = true;
-                    act.result.move = 'clicked';
-                  }
+                // If the click or load failed:
+                catch(error) {
+                  // Quit and add failure data to the report.
+                  console.log(`ERROR clicking link (${errorStart(error)})`);
+                  act.result.success = false;
+                  act.result.error = 'unclickable';
+                  act.result.message = 'ERROR: click or load timed out';
+                  actIndex = await abortActs(report, actIndex);
                 }
-              }
-              // Otherwise, if it is selecting an option in a select list, perform it.
-              else if (act.type === 'select') {
-                const options = await selection.$$('option');
-                let optionText = '';
-                if (options && Array.isArray(options) && options.length) {
-                  const optionTexts = [];
-                  for (const option of options) {
-                    const optionText = await option.textContent();
-                    optionTexts.push(optionText);
-                  }
-                  const matchTexts = optionTexts.map(
-                    (text, index) => text.includes(act.what) ? index : -1
-                  );
-                  const index = matchTexts.filter(text => text > -1)[act.index || 0];
-                  if (index !== undefined) {
-                    await selection.selectOption({index});
-                    optionText = optionTexts[index];
-                  }
+                // If the link click succeeded:
+                if (! act.result.error) {
+                  // Add success data to the report.
+                  act.result.success = true;
+                  act.result.move = 'clicked';
                 }
-                act.result.success = true;
-                act.result.move = 'selected';
-                act.result.option = optionText;
               }
-              // Otherwise, if it is entering text in an input element:
-              else if (['text', 'search'].includes(act.type)) {
-                act.result.attributes = {};
-                const {attributes} = act.result;
-                const type = await selection.getAttribute('type');
-                const label = await selection.getAttribute('aria-label');
-                const labelRefs = await selection.getAttribute('aria-labelledby');
-                attributes.type = type || '';
-                attributes.label = label || '';
-                attributes.labelRefs = labelRefs || '';
-                // If the text contains a placeholder for an environment variable:
-                let {what} = act;
-                if (/__[A-Z]+__/.test(what)) {
-                  // Replace it.
-                  const envKey = /__([A-Z]+)__/.exec(what)[1];
-                  const envValue = process.env[envKey];
-                  what = what.replace(/__[A-Z]+__/, envValue);
+            }
+            // Otherwise, if it is selecting an option in a select list, perform it.
+            else if (act.type === 'select') {
+              const options = await selection.$$('option');
+              let optionText = '';
+              if (options && Array.isArray(options) && options.length) {
+                const optionTexts = [];
+                for (const option of options) {
+                  const optionText = await option.textContent();
+                  optionTexts.push(optionText);
                 }
-                // Enter the text.
-                await selection.type(what);
-                report.jobData.presses += what.length;
-                act.result.success = true;
-                act.result.move = 'entered';
-                // If the input is a search input:
-                if (act.type === 'search') {
-                  // Press the Enter key and wait for a network to be idle.
-                  doAndWait(false);
+                const matchTexts = optionTexts.map(
+                  (text, index) => text.includes(act.what) ? index : -1
+                );
+                const index = matchTexts.filter(text => text > -1)[act.index || 0];
+                if (index !== undefined) {
+                  await selection.selectOption({index});
+                  optionText = optionTexts[index];
                 }
               }
-              // Otherwise, i.e. if the move is unknown, add the failure to the act.
-              else {
-                // Report the error.
-                const report = 'ERROR: move unknown';
-                act.result.success = false;
-                act.result.error = report;
-                console.log(report);
+              act.result.success = true;
+              act.result.move = 'selected';
+              act.result.option = optionText;
+            }
+            // Otherwise, if it is entering text in an input element:
+            else if (['text', 'search'].includes(act.type)) {
+              act.result.attributes = {};
+              const {attributes} = act.result;
+              const type = await selection.getAttribute('type');
+              const label = await selection.getAttribute('aria-label');
+              const labelRefs = await selection.getAttribute('aria-labelledby');
+              attributes.type = type || '';
+              attributes.label = label || '';
+              attributes.labelRefs = labelRefs || '';
+              // If the text contains a placeholder for an environment variable:
+              let {what} = act;
+              if (/__[A-Z]+__/.test(what)) {
+                // Replace it.
+                const envKey = /__([A-Z]+)__/.exec(what)[1];
+                const envValue = process.env[envKey];
+                what = what.replace(/__[A-Z]+__/, envValue);
+              }
+              // Enter the text.
+              await selection.type(what);
+              report.jobData.presses += what.length;
+              act.result.success = true;
+              act.result.move = 'entered';
+              // If the input is a search input:
+              if (act.type === 'search') {
+                // Press the Enter key and wait for a network to be idle.
+                doAndWait(false);
               }
             }
-            // Otherwise, i.e. if no match was found:
+            // Otherwise, i.e. if the move is unknown, add the failure to the act.
             else {
-              // Quit and add failure data to the report.
+              // Report the error.
+              const report = 'ERROR: move unknown';
               act.result.success = false;
-              act.result.error = 'absent';
-              act.result.message = 'ERROR: specified element not found';
-              console.log('ERROR: Specified element not found');
-              await abortActs();
+              act.result.error = report;
+              console.log(report);
             }
           }
-          // Otherwise, if the act is a keypress:
-          else if (act.type === 'press') {
-            // Identify the number of times to press the key.
-            let times = 1 + (act.again || 0);
-            report.jobData.presses += times;
-            const key = act.which;
-            // Press the key.
-            while (times--) {
-              await page.keyboard.press(key);
-            }
-            const qualifier = act.again ? `${1 + act.again} times` : 'once';
-            act.result = {
-              success: true,
-              message: `pressed ${qualifier}`
-            };
+          // Otherwise, i.e. if no match was found:
+          else {
+            // Quit and add failure data to the report.
+            act.result.success = false;
+            act.result.error = 'absent';
+            act.result.message = 'ERROR: specified element not found';
+            console.log('ERROR: Specified element not found');
+            actIndex = await abortActs(report, actIndex);
           }
-          // Otherwise, if it is a repetitive keyboard navigation:
-          else if (act.type === 'presses') {
-            const {navKey, what, which, withItems} = act;
-            const matchTexts = which ? which.map(text => debloat(text)) : [];
-            // Initialize the loop variables.
-            let status = 'more';
-            let presses = 0;
-            let amountRead = 0;
-            let items = [];
-            let matchedText;
-            // As long as a matching element has not been reached:
-            while (status === 'more') {
-              // Press the Escape key to dismiss any modal dialog.
-              await page.keyboard.press('Escape');
-              // Press the specified navigation key.
-              await page.keyboard.press(navKey);
-              presses++;
-              // Identify the newly current element or a failure.
-              const currentJSHandle = await page.evaluateHandle(actCount => {
-                // Initialize it as the focused element.
-                let currentElement = document.activeElement;
-                // If it exists in the page:
-                if (currentElement && currentElement.tagName !== 'BODY') {
-                  // Change it, if necessary, to its active descendant.
-                  if (currentElement.hasAttribute('aria-activedescendant')) {
-                    currentElement = document.getElementById(
-                      currentElement.getAttribute('aria-activedescendant')
-                    );
-                  }
-                  // Or change it, if necessary, to its selected option.
-                  else if (currentElement.tagName === 'SELECT') {
-                    const currentIndex = Math.max(0, currentElement.selectedIndex);
-                    const options = currentElement.querySelectorAll('option');
-                    currentElement = options[currentIndex];
-                  }
-                  // Or change it, if necessary, to its active shadow-DOM element.
-                  else if (currentElement.shadowRoot) {
-                    currentElement = currentElement.shadowRoot.activeElement;
-                  }
-                  // If there is a current element:
-                  if (currentElement) {
-                    // If it was already reached within this act:
-                    if (currentElement.dataset.pressesReached === actCount.toString(10)) {
-                      // Report the error.
-                      console.log(`ERROR: ${currentElement.tagName} element reached again`);
-                      status = 'ERROR';
-                      return 'ERROR: locallyExhausted';
-                    }
-                    // Otherwise, i.e. if it is newly reached within this act:
-                    else {
-                      // Mark and return it.
-                      currentElement.dataset.pressesReached = actCount;
-                      return currentElement;
-                    }
-                  }
-                  // Otherwise, i.e. if there is no current element:
-                  else {
+        }
+        // Otherwise, if the act is a keypress:
+        else if (act.type === 'press') {
+          // Identify the number of times to press the key.
+          let times = 1 + (act.again || 0);
+          report.jobData.presses += times;
+          const key = act.which;
+          // Press the key.
+          while (times--) {
+            await page.keyboard.press(key);
+          }
+          const qualifier = act.again ? `${1 + act.again} times` : 'once';
+          act.result = {
+            success: true,
+            message: `pressed ${qualifier}`
+          };
+        }
+        // Otherwise, if it is a repetitive keyboard navigation:
+        else if (act.type === 'presses') {
+          const {navKey, what, which, withItems} = act;
+          const matchTexts = which ? which.map(text => debloat(text)) : [];
+          // Initialize the loop variables.
+          let status = 'more';
+          let presses = 0;
+          let amountRead = 0;
+          let items = [];
+          let matchedText;
+          // As long as a matching element has not been reached:
+          while (status === 'more') {
+            // Press the Escape key to dismiss any modal dialog.
+            await page.keyboard.press('Escape');
+            // Press the specified navigation key.
+            await page.keyboard.press(navKey);
+            presses++;
+            // Identify the newly current element or a failure.
+            const currentJSHandle = await page.evaluateHandle(actCount => {
+              // Initialize it as the focused element.
+              let currentElement = document.activeElement;
+              // If it exists in the page:
+              if (currentElement && currentElement.tagName !== 'BODY') {
+                // Change it, if necessary, to its active descendant.
+                if (currentElement.hasAttribute('aria-activedescendant')) {
+                  currentElement = document.getElementById(
+                    currentElement.getAttribute('aria-activedescendant')
+                  );
+                }
+                // Or change it, if necessary, to its selected option.
+                else if (currentElement.tagName === 'SELECT') {
+                  const currentIndex = Math.max(0, currentElement.selectedIndex);
+                  const options = currentElement.querySelectorAll('option');
+                  currentElement = options[currentIndex];
+                }
+                // Or change it, if necessary, to its active shadow-DOM element.
+                else if (currentElement.shadowRoot) {
+                  currentElement = currentElement.shadowRoot.activeElement;
+                }
+                // If there is a current element:
+                if (currentElement) {
+                  // If it was already reached within this act:
+                  if (currentElement.dataset.pressesReached === actCount.toString(10)) {
                     // Report the error.
+                    console.log(`ERROR: ${currentElement.tagName} element reached again`);
                     status = 'ERROR';
-                    return 'noActiveElement';
+                    return 'ERROR: locallyExhausted';
+                  }
+                  // Otherwise, i.e. if it is newly reached within this act:
+                  else {
+                    // Mark and return it.
+                    currentElement.dataset.pressesReached = actCount;
+                    return currentElement;
                   }
                 }
-                // Otherwise, i.e. if there is no focus in the page:
+                // Otherwise, i.e. if there is no current element:
                 else {
                   // Report the error.
                   status = 'ERROR';
-                  return 'ERROR: globallyExhausted';
+                  return 'noActiveElement';
                 }
-              }, actCount);
-              // If the current element exists:
-              const currentElement = currentJSHandle.asElement();
-              if (currentElement) {
-                // Update the data.
-                const tagNameJSHandle = await currentElement.getProperty('tagName');
-                const tagName = await tagNameJSHandle.jsonValue();
-                const text = await textOf(page, currentElement);
-                // If the text of the current element was found:
-                if (text !== null) {
-                  const textLength = text.length;
-                  // If it is non-empty and there are texts to match:
-                  if (matchTexts.length && textLength) {
-                    // Identify the matching text.
-                    matchedText = matchTexts.find(matchText => text.includes(matchText));
+              }
+              // Otherwise, i.e. if there is no focus in the page:
+              else {
+                // Report the error.
+                status = 'ERROR';
+                return 'ERROR: globallyExhausted';
+              }
+            }, actCount);
+            // If the current element exists:
+            const currentElement = currentJSHandle.asElement();
+            if (currentElement) {
+              // Update the data.
+              const tagNameJSHandle = await currentElement.getProperty('tagName');
+              const tagName = await tagNameJSHandle.jsonValue();
+              const text = await textOf(page, currentElement);
+              // If the text of the current element was found:
+              if (text !== null) {
+                const textLength = text.length;
+                // If it is non-empty and there are texts to match:
+                if (matchTexts.length && textLength) {
+                  // Identify the matching text.
+                  matchedText = matchTexts.find(matchText => text.includes(matchText));
+                }
+                // Update the item data if required.
+                if (withItems) {
+                  const itemData = {
+                    tagName,
+                    text,
+                    textLength
+                  };
+                  if (matchedText) {
+                    itemData.matchedText = matchedText;
                   }
-                  // Update the item data if required.
-                  if (withItems) {
-                    const itemData = {
-                      tagName,
-                      text,
-                      textLength
-                    };
-                    if (matchedText) {
-                      itemData.matchedText = matchedText;
+                  items.push(itemData);
+                }
+                amountRead += textLength;
+                // If there is no text-match failure:
+                if (matchedText || ! matchTexts.length) {
+                  // If the element has any specified tag name:
+                  if (! what || tagName === what) {
+                    // Change the status.
+                    status = 'done';
+                    // Perform the action.
+                    const inputText = act.text;
+                    if (inputText) {
+                      await page.keyboard.type(inputText);
+                      presses += inputText.length;
                     }
-                    items.push(itemData);
-                  }
-                  amountRead += textLength;
-                  // If there is no text-match failure:
-                  if (matchedText || ! matchTexts.length) {
-                    // If the element has any specified tag name:
-                    if (! what || tagName === what) {
-                      // Change the status.
-                      status = 'done';
-                      // Perform the action.
-                      const inputText = act.text;
-                      if (inputText) {
-                        await page.keyboard.type(inputText);
-                        presses += inputText.length;
-                      }
-                      if (act.action) {
-                        presses++;
-                        await page.keyboard.press(act.action);
-                        await page.waitForLoadState();
-                      }
+                    if (act.action) {
+                      presses++;
+                      await page.keyboard.press(act.action);
+                      await page.waitForLoadState();
                     }
                   }
                 }
-                else {
-                  status = 'ERROR';
-                }
               }
-              // Otherwise, i.e. if there was a failure:
               else {
-                // Update the status.
-                status = await currentJSHandle.jsonValue();
+                status = 'ERROR';
               }
             }
-            // Add the result to the act.
-            act.result = {
-              success: true,
-              status,
-              totals: {
-                presses,
-                amountRead
-              }
-            };
-            if (status === 'done' && matchedText) {
-              act.result.matchedText = matchedText;
+            // Otherwise, i.e. if there was a failure:
+            else {
+              // Update the status.
+              status = await currentJSHandle.jsonValue();
             }
-            if (withItems) {
-              act.result.items = items;
+          }
+          // Add the result to the act.
+          act.result = {
+            success: true,
+            status,
+            totals: {
+              presses,
+              amountRead
             }
-            // Add the totals to the report.
-            report.jobData.presses += presses;
-            report.jobData.amountRead += amountRead;
+          };
+          if (status === 'done' && matchedText) {
+            act.result.matchedText = matchedText;
           }
-          // Otherwise, i.e. if the act type is unknown:
-          else {
-            // Add the error result to the act and abort the job.
-            actIndex = await addError(true, true, report, actIndex, 'ERROR: Invalid act type');
+          if (withItems) {
+            act.result.items = items;
           }
+          // Add the totals to the report.
+          report.jobData.presses += presses;
+          report.jobData.amountRead += amountRead;
         }
-        // Otherwise, a page URL is required but does not exist, so:
+        // Otherwise, i.e. if the act type is unknown:
         else {
-          // Add an error result to the act and abort the job.
-          actIndex = await addError(true, true, report, actIndex, 'ERROR: Page has no URL');
+          // Add the error result to the act and abort the job.
+          actIndex = await addError(true, true, report, actIndex, 'ERROR: Invalid act type');
         }
       }
-      // Otherwise, i.e. if no page exists:
+      // Otherwise, a page URL is required but does not exist, so:
       else {
         // Add an error result to the act and abort the job.
-        actIndex = await addError(true, true, report, actIndex, 'ERROR: No page identified');
+        actIndex = await addError(true, true, report, actIndex, 'ERROR: Page has no URL');
       }
-      act.endTime = Date.now();
     }
-    // Otherwise, i.e. if the act is invalid:
+    // Otherwise, i.e. if no page exists:
     else {
-      // Add error data to the act and abort the job.
-      addError(true, true, report, actIndex, `ERROR: Invalid act of type ${act.type}`);
+      // Add an error result to the act and abort the job.
+      actIndex = await addError(true, true, report, actIndex, 'ERROR: No page identified');
     }
+    act.endTime = Date.now();
     // Perform any remaining acts if not aborted.
     await doActs(report, actIndex + 1, page);
   }
@@ -1642,7 +1375,7 @@ exports.doJob = async report => {
   // If the report is valid:
   report.jobData = {};
   const {jobData} = report;
-  const reportInvalidity = isValidReport(report);
+  const reportInvalidity = isValidJob(report);
   if (reportInvalidity) {
     console.log(`ERROR: ${reportInvalidity}`);
     jobData.aborted = true;