testaro 47.2.1 → 48.0.0

package/run.js

@@ -29,6 +29,8 @@
 
 // IMPORTS
 
+// Module to perform file operations.
+const fs = require('fs/promises');
 // Module to keep secrets.
 require('dotenv').config();
 // Module to validate jobs.
@@ -39,6 +41,8 @@ const {standardize} = require('./procs/standardize');
 const {identify} = require('./procs/identify');
 // Module to send a notice to an observer.
 const {tellServer} = require('./procs/tellServer');
+// Module to create child processes.
+const {fork} = require('child_process');
 
 // CONSTANTS
 
@@ -194,7 +198,7 @@ const browserClose = async () => {
   }
 };
 // Launches a browser, navigates to a URL, and returns browser data.
-const launch = async (report, debug, waits, tempBrowserID, tempURL) => {
+const launch = exports.launch = async (report, debug, waits, tempBrowserID, tempURL) => {
   const act = report.acts[actIndex];
   const {device} = report;
   const deviceID = device && device.id;
@@ -306,25 +310,21 @@ const launch = async (report, debug, waits, tempBrowserID, tempURL) => {
       // Otherwise, i.e. if the launch or navigation failed:
       else {
         // Report this and abort the job.
-        actIndex = await addError(
-          true, true, report, actIndex, `ERROR: Launch failed (${navResult.error})`
-        );
+        addError(true, true, report, actIndex, `ERROR: Launch failed (${navResult.error})`);
         page = null;
       }
     }
     // If an error occurred:
     catch(error) {
       // Report this and abort the job.
-      actIndex = await addError(
-        true, true, report, actIndex, `ERROR launching or navigating ${error.message}`
-      );
+      addError(true, true, report, actIndex, `ERROR launching or navigating ${error.message}`);
       page = null;
     };
   }
   // Otherwise, i.e. if the browser or device ID is invalid:
   else {
     // Report this and abort the job.
-    actIndex = await addError(
+    addError(
       true,
       true,
       report,
@@ -332,6 +332,7 @@ const launch = async (report, debug, waits, tempBrowserID, tempURL) => {
       `ERROR: Browser ${browserID}, device ${deviceID}, or URL ${url} invalid`
     );
   }
+  exports.page = page;
 };
 // Returns a string representing the date and time.
 const nowString = () => (new Date()).toISOString().slice(2, 16);
@@ -501,18 +502,16 @@ const wait = ms => {
   });
 };
 // Reports a job being aborted and returns an abortive act index.
-const abortActs = async (report, actIndex) => {
+const abortActs = (report, actIndex) => {
   // Add data on the aborted act to the report.
   report.jobData.abortTime = nowString();
   report.jobData.abortedAct = actIndex;
   report.jobData.aborted = true;
   // Report that the job is aborted.
   console.log(`ERROR: Job aborted on act ${actIndex}`);
-  // Return an abortive act index.
-  return -2;
 };
 // Adds an error result to an act.
-const addError = async(alsoLog, alsoAbort, report, actIndex, message) => {
+const addError = (alsoLog, alsoAbort, report, actIndex, message) => {
   // If the error is to be logged:
   if (alsoLog) {
     // Log it.
@@ -524,6 +523,7 @@ const addError = async(alsoLog, alsoAbort, report, actIndex, message) => {
   act.result.success ??= false;
   act.result.error ??= message;
   if (act.type === 'test') {
+    act.data ??= {};
     act.data.success = false;
     act.data.prevented = true;
     act.data.error = message;
@@ -532,816 +532,803 @@ const addError = async(alsoLog, alsoAbort, report, actIndex, message) => {
   }
   // If the job is to be aborted:
   if (alsoAbort) {
-    // Return an abortive act index.
-    return await abortActs(report, actIndex);
-  }
-  // Otherwise, i.e. if the job is not to be aborted:
-  else {
-    // Return the current act index.
-    return actIndex;
+    // Add this to the report.
+    abortActs(report, actIndex);
   }
 };
-// Recursively performs the acts in a report.
-const doActs = async (report, actIndex) => {
+// Performs the acts in a report.
+const doActs = async (report) => {
   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;
-    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;
-        }
+  // Get the standardization specification.
+  const standard = report.standard || 'only';
+  const reportPath = 'temp/report.json';
+  // For each act in the reeport.
+  for (const actIndex in acts) {
+    // If the job has not been aborted:
+    if (report.jobData && ! report.jobData.aborted) {
+      let act = acts[actIndex];
+      const {type, which} = 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, if the act is a launch:
-    else if (type === 'launch') {
-      // Launch a browser, navigate to a page, and add the result to the act.
-      await launch(
-        report,
-        debug,
-        waits,
-        act.browserID || report.browserID || '',
-        act.target && act.target.url || report.target && report.target.url || ''
-      );
-      // If this failed:
-      if (page.prevented) {
-        // Add this to the act.
-        act.prevented = true;
-        act.error = page.error || '';
-      }
-    }
-    // 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];
-      // Get the start time of the act.
-      const startTime = Date.now();
-      try {
-        // Get the time limit in seconds for the act.
-        const timeLimit = timeLimits[act.which] || 15;
-        // If a new browser is to be launched:
-        if (act.launch) {
-          // Launch it, navigate to a URL, and replace the page.
-          await launch(
-            report,
-            debug,
-            waits,
-            act.launch.browserID || report.browserID,
-            act.launch.target && act.launch.target.url || report.target.url
-          );
-        }
-        // If the page has not prevented the tool from testing:
-        if (! page.prevented) {
-          // Perform the specified tests of the tool.
-          const actReport = await require(`./tests/${act.which}`)
-          .reporter(page, report, actIndex, timeLimit);
-          // Add the data and result to the act.
-          act.data = actReport.data;
-          act.result = actReport.result;
-          // If the tool reported that the page prevented testing:
-          if (actReport.data.prevented) {
-            // Add prevention data to the job data.
-            report.jobData.preventions[act.which] = act.data.error;
-          }
-        }
-      }
-      // If the tool invocation failed:
-      catch(error) {
-        // Report the failure.
-        const message = error.message.slice(0, 400);
-        console.log(`ERROR: Test act ${act.which} failed (${message})`);
-        act.data ??= {};
-        act.data.prevented = true;
-        act.data.error = 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;
+      // Otherwise, i.e. if granular reporting has not been specified:
+      else {
+        // Log the act.
+        console.log(message);
       }
-      toolTimes[act.which] += time;
-      const standard = report.standard || 'only';
-      // If the act was not prevented and standardization is required:
-      if (! act.data.prevented && ['also', 'only'].includes(standard)) {
-        // Initialize the standard result.
-        act.standardResult = {
-          totals: [0, 0, 0, 0],
-          instances: []
+      // 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 = acts.map(act => act.type !== 'next').lastIndexOf(true);
+        // Determine whether its jump condition is true.
+        const truth = isTrue(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]
         };
-        // 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 the condition is true:
+        if (truth[1]) {
+          // If the performance of acts is to stop:
+          if (act.jump === 0) {
+            // Quit.
+            actIndex = -2;
           }
-          if (! instance.pathID) {
-            instance.pathID = elementID ? elementID.pathID : '';
+          // Otherwise, if there is a numerical jump:
+          else if (act.jump) {
+            // Set the act index accordingly.
+            actIndex += act.jump - 1;
           }
-        };
-        // If the original-format result is not to be included in the report:
-        if (standard === 'only') {
-          // Remove it.
-          delete act.result;
+          // 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 a browser, navigate to a page, and add the result to the act.
+        await launch(
+          report,
+          debug,
+          waits,
+          act.browserID || report.browserID || '',
+          act.target && act.target.url || report.target && report.target.url || ''
+        );
+        // If this failed:
+        if (page.prevented) {
+          // Add this to the act.
+          act.prevented = true;
+          act.error = page.error || '';
         }
       }
-      const expectations = act.expect;
-      // If the act was not prevented and has expectations:
-      if (! act.data.prevented && expectations) {
-        // Initialize whether they were fulfilled.
-        act.expectations = [];
-        let failureCount = 0;
-        // For each expectation:
-        expectations.forEach(spec => {
-          // Add the its result to the act.
-          const truth = isTrue(act, spec);
-          act.expectations.push({
-            property: spec[0],
-            relation: spec[1],
-            criterion: spec[2],
-            actual: truth[0],
-            passed: truth[1]
+      // Otherwise, if the act is a test act:
+      else if (type === 'test') {
+        // Add a description of the tool to the act.
+        act.what = tools[act.which];
+        // Get the start time of the act.
+        const startTime = Date.now();
+        // Add it to the act.
+        act.startTime = startTime;
+        // Save the report.
+        let reportJSON = JSON.stringify(report);
+        await fs.writeFile(reportPath, reportJSON);
+        // Create a process and wait for it to perform the act and add the result to the saved report.
+        const actResult = await new Promise(resolve => {
+          let closed = false;
+          const child = fork(
+            'procs/doTestAct', [actIndex], {timeout: 1000 * timeLimits[act.which] || 15000}
+          );
+          child.on('message', message => {
+            if (! closed) {
+              closed = true;
+              resolve(message);
+            }
+          });
+          child.on('close', code => {
+            if (! closed) {
+              closed = true;
+              resolve(code);
+            }
           });
-          if (! truth[1]) {
-            failureCount++;
-          }
         });
-        act.expectationFailures = failureCount;
-      }
-    }
-    // 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'
-            );
-          }
+        // Get the revised report.
+        reportJSON = await fs.readFile(reportPath, 'utf8');
+        report = JSON.parse(reportJSON);
+        // Get the revised act.
+        act = report.acts[actIndex];
+        // If the result is an error code:
+        if (typeof actResult === 'number') {
+          // Add the error data to the act.
+          act.data ??= {};
+          act.data.prevented = true;
+          act.data.error = actResult;
         }
-        // Otherwise, i.e. if the visit failed:
+        // Otherwise, i.e. if it is not an error code:
         else {
-          // Report this and abort the job.
-          actIndex = await addError(true, true, report, actIndex, 'ERROR: Visit failed');
+          // Add the elapsed time of the tool to the report.
+          const time = Math.round((Date.now() - startTime) / 1000);
+          const {toolTimes} = report.jobData;
+          toolTimes[act.which] ??= 0;
+          toolTimes[act.which] += time;
+          // If the act was not prevented and standardization is required:
+          if (['also', 'only'].includes(standard) && act.data && ! act.data.prevented) {
+            // Initialize the standard result.
+            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;
+            }
+            const expectations = act.expect;
+            // If the act was not prevented and has expectations:
+            if (expectations && act.data && ! act.data.prevented) {
+              // Initialize whether they were fulfilled.
+              act.expectations = [];
+              let failureCount = 0;
+              // For each expectation:
+              expectations.forEach(spec => {
+                // Add its result to the act.
+                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++;
+                }
+              });
+              act.expectationFailures = failureCount;
+            }
+          }
         }
       }
-      // 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, 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.
+              addError(true, true, report, actIndex, 'ERROR: Navigation illicitly redirected');
+            }
           }
-          // If the wait times out:
-          catch(error) {
-            // Quit.
-            actIndex = await abortActs(report, actIndex);
-            waitError(page, act, error, 'text in the URL');
+          // Otherwise, i.e. if the visit failed:
+          else {
+            // Report this and abort the job.
+            addError(true, true, report, actIndex, 'ERROR: Visit failed');
           }
         }
-        // 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 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.
+              actIndex = await abortActs(report, actIndex);
+              waitError(page, act, error, 'text in the URL');
+            }
           }
-          // If the wait times out:
-          catch(error) {
-            // Quit.
-            actIndex = await abortActs(report, actIndex);
-            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();
+            }
+            // If the wait times out:
+            catch(error) {
+              // Quit.
+              actIndex = await abortActs(report, actIndex);
+              waitError(page, act, error, 'text in the 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;
+          // 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.
+              actIndex = await abortActs(report, actIndex);
+              waitError(page, act, error, 'text in the body');
+            }
           }
+        }
+        // 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(error) {
-            // Quit.
-            actIndex = await abortActs(report, actIndex);
-            waitError(page, act, error, 'text in the body');
+          .catch(async error => {
+            // Report this and abort the job.
+            console.log(`ERROR waiting for page to be ${act.which} (${error.message})`);
+            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
+            };
           }
         }
-      }
-      // 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
+        // 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 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';
-              }
-              if (['hidden', 'collapse'].includes(styleDec.visibility)) {
-                element.style.visibility = 'inherit';
-              }
+        // 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
+              };
             });
-            act.result = {
-              success: true
-            };
-          })
-          .catch(error => {
-            console.log(`ERROR making all elements visible (${error.message})`);
-            act.result = {
-              success: false
-            };
-          });
-        }
-        // 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;
+          }
+          // 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;
                       }
+                      act.result.message = 'Not enough specified elements exist';
+                      act.result.candidateTexts = selectionTexts;
                     }
                   }
-                  // If no element satisfied the specifications:
-                  if (! act.result.found) {
+                  // 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 = 'exhausted';
+                    act.result.error = 'fewer';
                     act.result.typeElementCount = selections.length;
-                    if (slimText) {
-                      act.result.textElementCount = --matchCount;
-                    }
-                    act.result.message = 'Not enough specified elements exist';
-                    act.result.candidateTexts = selectionTexts;
+                    act.result.message = 'Elements of specified type too few';
                   }
                 }
-                // Otherwise, i.e. if there are too few such elements to make a match possible:
+                // 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 = 'fewer';
-                  act.result.typeElementCount = selections.length;
-                  act.result.message = 'Elements of specified type too few';
+                  act.result.error = 'none';
+                  act.result.typeElementCount = 0;
+                  act.result.message = 'No elements of specified type found';
                 }
               }
-              // Otherwise, i.e. if there are no elements of the specified type:
+              // Otherwise, i.e. if the page no longer exists:
               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';
-              }
-            }
-            // 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;
+                act.result.error = 'gone';
+                act.result.message = 'Page gone';
               }
-              // 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.found) {
+                await wait(2000);
               }
-              if (act.result.success) {
+            }
+            // 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 page.context().waitForEvent('networkidle', {timeout: 10000});
-                  act.result.idleTimely = true;
+                  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) {
-                  console.log(`ERROR: Network busy after ${move} (${errorStart(error)})`);
-                  act.result.idleTimely = false;
+                  // Add the error result to the act and abort the job.
+                  addError(true, true, report, actIndex, `ERROR: ${move} failed`);
                 }
-                // Add the page URL to the result.
-                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';
-            }
-            // 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';
+                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;
                   }
+                  // Add the page URL to the result.
+                  act.result.newURL = page.url();
                 }
-                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 = report;
+                  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`;
+                    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 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 focusing the element, perform it.
+              else if (act.type === 'focus') {
+                await selection.focus({timeout: 2000});
+                act.result.success = true;
+                act.result.move = 'focused';
               }
-              // 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, 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);
                 }
-                // 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, 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';
+                    actIndex = await abortActs(report, actIndex);
+                  }
+                  // 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 link click succeeded:
-                if (! act.result.error) {
-                  // Add success data to the report.
-                  act.result.success = true;
-                  act.result.move = 'clicked';
+              }
+              // 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];
+                  }
                 }
+                act.result.success = true;
+                act.result.move = 'selected';
+                act.result.option = optionText;
               }
-            }
-            // 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);
+              // 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);
                 }
-                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];
+                // 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);
                 }
               }
-              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 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;
               }
             }
-            // Otherwise, i.e. if the move is unknown, add the failure to the act.
+            // Otherwise, i.e. if no match was found:
             else {
-              // Report the error.
-              const report = 'ERROR: move unknown';
+              // Quit and add failure data to the report.
               act.result.success = false;
-              act.result.error = report;
-              console.log(report);
+              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, 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 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);
+          // 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}`
+            };
           }
-          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 'ERROR: locallyExhausted';
+          // 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 it is newly reached within this act:
+                  // Otherwise, i.e. if there is no current element:
                   else {
-                    // Mark and return it.
-                    currentElement.dataset.pressesReached = actCount;
-                    return currentElement;
+                    // Report the error.
+                    status = 'ERROR';
+                    return 'noActiveElement';
                   }
                 }
-                // Otherwise, i.e. if there is no current element:
+                // Otherwise, i.e. if there is no focus in the page:
                 else {
                   // Report the error.
                   status = 'ERROR';
-                  return 'noActiveElement';
-                }
-              }
-              // 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));
+                  return 'ERROR: globallyExhausted';
                 }
-                // Update the item data if required.
-                if (withItems) {
-                  const itemData = {
-                    tagName,
-                    text,
-                    textLength
-                  };
-                  if (matchedText) {
-                    itemData.matchedText = matchedText;
+              }, 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));
                   }
-                  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;
+                  // Update the item data if required.
+                  if (withItems) {
+                    const itemData = {
+                      tagName,
+                      text,
+                      textLength
+                    };
+                    if (matchedText) {
+                      itemData.matchedText = matchedText;
                     }
-                    if (act.action) {
-                      presses++;
-                      await page.keyboard.press(act.action);
-                      await page.waitForLoadState();
+                    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();
+                      }
                     }
                   }
                 }
+                else {
+                  status = 'ERROR';
+                }
               }
+              // Otherwise, i.e. if there was a failure:
               else {
-                status = 'ERROR';
+                // Update the status.
+                status = await currentJSHandle.jsonValue();
               }
             }
-            // Otherwise, i.e. if there was a failure:
-            else {
-              // Update the status.
-              status = await currentJSHandle.jsonValue();
+            // Add the result to the act.
+            act.result = {
+              success: true,
+              status,
+              totals: {
+                presses,
+                amountRead
+              }
+            };
+            if (status === 'done' && matchedText) {
+              act.result.matchedText = matchedText;
             }
-          }
-          // Add the result to the act.
-          act.result = {
-            success: true,
-            status,
-            totals: {
-              presses,
-              amountRead
+            if (withItems) {
+              act.result.items = items;
             }
-          };
-          if (status === 'done' && matchedText) {
-            act.result.matchedText = matchedText;
+            // Add the totals to the report.
+            report.jobData.presses += presses;
+            report.jobData.amountRead += amountRead;
           }
-          if (withItems) {
-            act.result.items = items;
+          // Otherwise, i.e. if the act type is unknown:
+          else {
+            // Add the error result to the act and abort the job.
+            addError(true, true, report, actIndex, 'ERROR: Invalid act type');
           }
-          // Add the totals to the report.
-          report.jobData.presses += presses;
-          report.jobData.amountRead += amountRead;
         }
-        // Otherwise, i.e. if the act type is unknown:
+        // Otherwise, a page URL is required but does not exist, so:
         else {
-          // Add the error result to the act and abort the job.
-          actIndex = await addError(true, true, report, actIndex, 'ERROR: Invalid act type');
+          // Add an error result to the act and abort the job.
+          addError(true, true, report, actIndex, 'ERROR: Page has no URL');
         }
       }
-      // Otherwise, a page URL is required but does not exist, so:
+      // Otherwise, i.e. if no page exists:
       else {
         // Add an error result to the act and abort the job.
-        actIndex = await addError(true, true, report, actIndex, 'ERROR: Page has no URL');
+        addError(true, true, report, actIndex, 'ERROR: No page identified');
       }
+      // Add the end time to the act.
+      act.endTime = Date.now();
     }
-    // Otherwise, i.e. if no page exists:
-    else {
-      // 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);
-  }
-  // Otherwise, if all acts have been performed and the job succeeded:
-  else if (! report.jobData.abortTime) {
-    console.log('Acts completed');
-    await browserClose();
   }
+  console.log('Acts completed');
+  await browserClose();
+  await fs.rm(reportPath, {force: true});
+  return report;
 };
 /*
   Returns whether an initialized job report is valid and, if so, runs the job and adds the results
@@ -1383,8 +1370,8 @@ exports.doJob = async report => {
         process.exit();
       }
     });
-    // Recursively perform the acts.
-    await doActs(report, 0, null);
+    // Perform the acts and get the revised report.
+    report = await doActs(report, 0, null);
     // Add the end time and duration to the report.
     const endTime = new Date();
     report.jobData.endTime = nowString();
@@ -1400,4 +1387,5 @@ exports.doJob = async report => {
       report.jobData.toolTimes[item[0]] = item[1];
     });
   }
+  return report;
 };