testilo 28.0.1 → 29.0.0

package/README.md

@@ -58,7 +58,7 @@ Testilo can, however, make job preparation more efficient in these scenarios:
 
 ### Target lists
 
-The simplest version of a list of targets is a _target list_. It is an array of arrays defining 1 or more targets. It can be stored as a tab-delimited text file.
+The simplest version of a list of targets is a _target list_. It is an array of arrays defining 1 or more targets. It can be stored as a text file.
 
 A target is defined by 2 items:
 - A description
@@ -73,11 +73,11 @@ For example, a target list might be:
 ]
 ```
 
-If this target list were stored as a file, its content would be this (with “→” representing the Tab character):
+If this target list were stored as a file, its content would be this, with vertical bars separating the URLs from the descriptions:
 
 ```text
-World Wide Web Consortium→https://www.w3.org/
-Mozilla Foundation→https://foundation.mozilla.org/en/
+World Wide Web Consortium|https://www.w3.org/
+Mozilla Foundation|https://foundation.mozilla.org/en/
 ```
 
 ### Batches
@@ -221,7 +221,7 @@ The invoking module can further dispose of the batch as needed.
 
 A user can invoke `batch()` in this way:
 
-- Create a target list and save it as a text file (with tab-delimited items in newline-delimited lines) in the `targetLists` subdirectory of the `SPECDIR` directory. Name the file `x.tsv`, where `x` is the list ID.
+- Create a target list and save it as a text file (with tab-delimited items in newline-delimited lines) in the `targetLists` subdirectory of the `SPECDIR` directory. Name the file `x.txt`, where `x` is the list ID.
 - In the Testilo project directory, execute the statement `node call batch id what`.
 
 In this statement, replace `id` with the list ID and `what` with a string describing the batch. Example: `node call batch divns 'ABC company divisions'`.
@@ -249,25 +249,25 @@ A module can invoke `script()` in this way:
 ```javaScript
 const {script} = require('testilo/script');
 const {issues} = require('testilo/procs/score/tic99');
-const scriptObj = script('monthly', issues, 'regionNoText', 'mainNot1');
+const scriptObj = script('monthly', 'landmarks', issues, 'regionNoText', 'mainNot1');
 ```
 
-In this example, the script will have `'monthly'` as its ID. It will tell Testaro to test for all, and only, the rules that are classified into either the `regionNoText` or the `mainNot1` issue.
+In this example, the script will have `'monthly'` as its ID and `'landmarks'` as its description. It will tell Testaro to test for all, and only, the rules that are classified into either the `regionNoText` or the `mainNot1` issue.
 
 The invoking module can further modify and use the script (`scriptObj`) as needed.
 
-To create a script **without** issue restrictions, a module can call `script()` with only the first (ID) argument.
+To create a script **without** issue restrictions, a module can call `script()` with only the first two arguments (the ID and the description).
 
 ##### By a user
 
 A user can invoke `script()` by executing one of these statements in the Testilo project directory:
 
 ```javascript
-node call script id ticnn issuea issueb …
-node call script id
+node call script id what ticnn issuea issueb …
+node call script id what
 ```
 
-In this statement, replace `id` with an ID for the script, such as `headings`.
+In this statement, replace `id` with an ID for the script, such as `headings1`, consisting of ASCII alphanumeric characters.
 
 If specifying issues:
 - Replace `ticnn` with the base, such as `tic99`, of the name of an issue classification file in the `score` subdirectory of the `FUNCTIONDIR` directory.
@@ -275,7 +275,7 @@ If specifying issues:
 
 The `call` module will retrieve the named classification, if any.
 The `script` module will create a script.
-The `call` module will save the script as a JSON file in the `scripts` subdirectory of the `SPECDIR` directory.
+The `call` module will save the script as a JSON file in the `scripts` subdirectory of the `SPECDIR` directory, using the `id` value as the base of the file name.
 
 #### Options
 
@@ -310,7 +310,9 @@ The first two arguments are a script and a batch obtained from files or from pri
 
 The `standard` argument specifies how to handle standardization. If `also`, jobs will tell Testaro to include in its reports both the original results of the tests of tools and the Testaro-standardized results. If `only`, reports are to include only the standardized test results. If `no`, reports are to include only the original results, without standardization.
 
-The `observe` argument tells Testaro whether the jobs should allow granular observation. If `false`, Testaro will not report job progress, but will only send reports to the server when the reports are completed. It is generally user-friendly to allow granular observation, and for user applications to implement it, if they make users wait while jobs are assigned and performed, since that process typically takes a few minutes.
+The `observe` argument tells Testaro whether the jobs should allow granular observation. If `true`, it will. If `false`, Testaro will not report job progress, but will send reports to the server only when the reports are completed. It is generally user-friendly to allow granular observation, and for user applications to implement it, if they make users wait while jobs are assigned and performed, since that process typically takes a few minutes.
+
+The `requester` argument is an email address to which any notices about the job are to be sent.
 
 The `timeStamp` argument specifies the earliest UTC date and time when the jobs may be assigned, or it may be an empty string if now.
 
@@ -428,11 +430,11 @@ Testilo can enhance such a report by:
 
 ### Scoring
 
-To add scores to reports, the `score` module of Testilo performs computations on the test results and adds a `score` property to each report.
+The `score` module of Testilo performs computations on test results and adds a `score` property to a report.
 
 The `score()` function of the `score` module takes two arguments:
 - a scoring function
-- an array of report objects
+- a report object
 
 A scoring function defines scoring rules. The Testilo package contains a `procs/score` directory, in which there are modules that export scoring functions. You can use one of those scoring functions, or you can create your own.
 
@@ -493,15 +495,15 @@ A module can invoke `score()` in this way:
 ```javaScript
 const {score} = require('testilo/score');
 const {scorer} = require('testilo/procs/score/tsp99');
-const reports = …;
-score(scorer, reports);
+const report = …;
+score(scorer, report);
 ```
 
 The first argument to `score()` is a scoring function. In this example, it has been obtained from a module in the Testilo package, but it could be a custom function.
 
-The second argument to `score()` is an array of report objects. They may have been read from JSON   files and parsed, or the array may contain a single report object parsed from the body of a `POST` request received from a Testaro agent.
+The second argument to `score()` is a report object. It may have been read from a JSON file and parsed, or parsed from the body of a `POST` request received from a Testaro agent.
 
-The invoking module can further dispose of the scored reports as needed.
+The invoking module can further dispose of the scored report as needed.
 
 ##### By a user
 
@@ -509,15 +511,14 @@ A user can invoke `score()` in this way:
 
 ```bash
 node call score tsp99
-node call score tsp99 75m
+node call score tsp99 240922
 ```
 
 When a user invokes `score()` in this example, the `call` module:
 - gets the scoring module `tsp99` from its JSON file `tsp99.json` in the `score` subdirectory of the `FUNCTIONDIR` directory.
-- gets the reports from the `raw` subdirectory of the `REPORTDIR` directory.
-- writes the scored reports in JSON format to the `scored` subdirectory of the `REPORTDIR` directory.
-
-The optional third argument to `call()` (`75m` in this example) is a report selector. Without the argument, `call()` gets all the reports in the `raw` subdirectory. With the argument, `call()` gets only those reports whose names begin with the argument string.
+- gets all reports, or if the third argument to `call()` exists the reports whose file names begin with `'240922'`, from the `raw` subdirectory of the `REPORTDIR` directory.
+- adds score data to each report.
+- writes each scored report in JSON format to the `scored` subdirectory of the `REPORTDIR` directory.
 
 #### Validation
 
@@ -530,11 +531,11 @@ To test the `score` module, in the project directory you can execute the stateme
 Reports from Testaro are JavaScript objects. When represented as JSON, they are human-readable, but not human-friendly. They are basically designed for machine tractability. This is equally true for reports that have been scored by Testilo. But Testilo can _digest_ a scored report, converting it to a human-oriented HTML document, or _digest_.
 
 The `digest` module digests a scored report. Its `digest()` function takes three arguments:
-- a digesting function
-- an array of scored report objects
+- a digester (a digesting function)
+- a scored report object
 - the URL of a directory containing the scored reports
 
-The digesting function populates an HTML digest template. A copy of the template, with its placeholders replaced by computed values, becomes the digest. The digesting function defines the rules for replacing the placeholders with values. The Testilo package contains a `procs/digest` directory, in which there are subdirectories, each containing a template and a module that exports a digesting function. You can use one of those modules, or you can create your own.
+The digester populates an HTML digest template. A copy of the template, with its placeholders replaced by computed values, becomes the digest. The digester defines the rules for replacing the placeholders with values. The Testilo package contains a `procs/digest` directory, in which there are subdirectories, each containing a template and a module that exports a digester. You can use one of those modules, or you can create your own.
 
 The included templates format placeholders with leading and trailing underscore pairs (such as `__issueCount__`).
 
@@ -550,19 +551,19 @@ A module can invoke `digest()` in this way:
 const {digest} = require('testilo/digest');
 const digesterDir = `${process.env.FUNCTIONDIR}/digest/tdp99a`;
 const {digester} = require(`${digesterDir}/index`);
-const scoredReports = …;
+const scoredReport = …;
 const reportDirURL = 'https://xyz.org/a11yTesting/reports';
-digest(digester, scoredReports, reportDirURL)
-.then(digestedReports => {…});
+digest(digester, scoredReport, reportDirURL)
+.then(digestedReport => {…});
 ```
 
-The first argument to `digest()` is a digesting function. In this example, it has been obtained from a file in the Testilo package, but it could be custom-made.
+The first argument to `digest()` is a digester. In this example, it has been obtained from a file in the Testilo package, but it could be custom-made.
 
-The second argument to `digest()` is an array of scored report objects. They may have been read from JSON files and parsed, or the array may contain a single scored report output by `score()`.
+The second argument to `digest()` is a scored report object. It may have been read from a JSON file and parsed, or may be a scored report output by `score()`.
 
-The third argument is the absolute or relative URL of a directory where the reports being digested are located. The `digest()` function needs that URL because a digest includes a link to the full report. The link concatenates the directory URL with the report ID and a `.json` suffix.
+The third argument is the absolute or relative URL of a directory where the reports being digested are located. The `digest()` function needs that URL because a digest includes a link to the full scored report. The link concatenates the directory URL with the report ID and a `.json` suffix.
 
-The `digest()` function returns an array of digested reports. The invoking module can further dispose of the digested reports as needed.
+The `digest()` function returns a promise resolved with a digest. The invoking module can further dispose of the digest as needed.
 
 ##### By a user
 
@@ -570,18 +571,15 @@ A user can invoke `digest()` in this way:
 
 ```bash
 node call digest tdp99
-node call digest tdp99 75m
+node call digest tdp99 241105
 ```
 
 When a user invokes `digest()` in this example, the `call` module:
 - gets the template and the digesting module from subdirectory `tdp99` in the `digest` subdirectory of the `FUNCTIONDIR` directory.
-- gets the reports from the `scored` subdirectory of the `REPORTDIR` directory.
+- gets all reports, or if the third argument to `call()` exists all reports whose file names begin with `'241105'`, from the `scored` subdirectory of the `REPORTDIR` directory.
+- digests each report.
 - writes the digested reports to the `digested` subdirectory of the `REPORTDIR` directory.
-- includes in each digest a link to the scored report, with the link destination being based on `DIGEST_URL`.
-
-The third argument to `call()` can be an absolute URL, as shown, or a URL that is relative to the URL of the digest. For example, if it is known that the scored reports and the digests will inhabit the same directory and be retrievable with identical URLs except for the file extensions, then the third argument can be `./`.
-
-The optional fourth argument to `call()` (`75m` in this example) is a report selector. Without the argument, `call` gets all the reports in the `scored` subdirectory of the `REPORTDIR` directory. With the argument, `call` gets only those reports whose names begin with the argument string.
+- includes in each digest a link to the scored report, with the link destination being based on `SCORED_REPORT_URL`.
 
 The digests created by `digest()` are HTML files, and they expect a `style.css` file to exist in their directory. The `reports/digested/style.css` file in Testilo is an appropriate stylesheet to be copied into the directory where digested reports are written.
 
@@ -646,13 +644,48 @@ Difgests expect a `style.css` file to exist in their directory, as digests do.
 
 To test the `digest` module, in the project directory you can execute the statement `node validation/digest/validate`. If `digest` is valid, all logging statements will begin with “Success” and none will begin with “ERROR”.
 
-### Report comparison
+### Summarization
+
+The `summarize` module of Testilo can summarize a scored report. The summary contains, insofar as they exist in the report, its ID, end time, order ID, target data, and total score.
+
+#### Invocation
+
+##### By a module
+
+A module can invoke `summarize()` in this way:
+
+```javaScript
+const {summarize} = require('testilo/summarize');
+const report = …;
+const summary = summarize(report);
+…
+```
+
+The `report` argument is a scored report. The `summary` constant is an object. The module can further dispose of `summary` as needed.
+
+##### By a user
+
+A user can invoke `summarize()` in either of these two ways:
+
+```javaScript
+node call summarize divisions
+node call summarize divisions 2411
+```
+
+When a user invokes `summarize` in this example, the `call` module:
+- gets all the reports in the `scored` subdirectory of the `REPORTDIR` directory, or (if the third argument is present) all those whose file names begin with `2411`.
+- creates a summary of each report.
+- combines the summaries into an array.
+- creates a _summary report_, an object containing three properties: an ID, a description (here `'divisions'`), and the array of summaries.
+- writes the summary report in JSON format to the `summarized` subdirectory of the `REPORTDIR` directory, using the ID as the base of the file name.
+
+### Comparison
 
-If you use Testilo to perform a battery of tests on multiple targets, you may want a single report that compares the total scores received by the targets. Testilo can produce such a _comparative report_.
+If you use Testilo to perform a battery of tests on multiple targets, you may want a single report that compares the total scores received by the targets. Testilo can produce such a _comparison_.
 
-The `compare` module compares the scores in a collection of scored reports. Its `compare()` function takes two arguments:
+The `compare` module compares the scores in a summary of scored reports. Its `compare()` function takes two arguments:
 - a comparison function
-- an array of scored reports
+- a summary report
 
 The comparison function defines the rules for generating an HTML file comparing the scored reports. The Testilo package contains a `procs/compare` directory, in which there are subdirectories containing modules that export comparison functions. You can use one of those functions, or you can create your own.
 
@@ -668,25 +701,27 @@ A module can invoke `compare()` in this way:
 const {compare} = require('testilo/compare');
 const comparerDir = `${process.env.FUNCTIONDIR}/compare/tcp99`;
 const {comparer} = require(`${comparerDir}/index`);
-compare(comparer, scoredReports)
+const id = …;
+compare(id, comparer, summaryReport)
 .then(comparison => {…});
 ```
 
-The first argument to `compare()` is a comparison function. In this example, it been obtained from a file in the Testilo package, but it could be custom-made. The second argument to `compare()` is an array of report objects. The `compare()` function returns a comparative report. The invoking module can further dispose of the comparative report as needed.
+The first argument to `compare()` is an ID that will be named in the comparison. The second argument is a comparison function. In this example, it been obtained from a file in the Testilo package, but it could be custom-made. The third argument is a summary report. The `compare()` function returns a comparison. The invoking module can further dispose of the comparison as needed.
 
 ##### By a user
 
 A user can invoke `compare()` in this way:
 
 ```bash
-node call compare tcp99 legislators
-node call compare tcp99 legislators 23pl
+node call compare 'state legislators' tcp99 240813
 ```
 
 When a user invokes `compare` in this example, the `call` module:
 - gets the comparison module from subdirectory `tcp99` of the subdirectory `compare` in the `FUNCTIONDIR` directory.
-- gets all the reports in the `scored` subdirectory of the `REPORTDIR` directory, or, if there is a fourth argument, whose file names begin with `23pl`.
-- writes the comparative report as an HTML file named `legislators.html` to the `comparative` subdirectory of the `REPORTDIR` directory.
+- gets the summary report whose file name begins with `'240813'` from the `summarized` subdirectory of the `REPORTDIR` directory.
+- creates an ID for the comparison.
+- creates the comparison as an HTML document.
+- writes the comparison in the `comparative` subdirectory of the `REPORTDIR` directory, with `state legislators` as a description and the ID as the base of the file name.
 
 The comparative report created by `compare` is an HTML file, and it expects a `style.css` file to exist in its directory. The `reports/comparative/style.css` file in Testilo is an appropriate stylesheet to be copied into the directory where comparative reports are written.
 
@@ -698,7 +733,7 @@ To test the `compare` module, in the project directory you can execute the state
 
 If you use Testaro to perform all the tests of all the tools on multiple targets and score the reports with a score proc that maps tool rules onto tool-agnostic issues, you may want to tabulate the comparative efficacy of each tool in discovering instances of issues. Testilo can help you do this by producing a _credit report_.
 
-The `credit` module tabulates the contribution of each tool to the discovery of issue instances in a collection of scored reports. Its `credit()` function takes one argument: an array of scored reports.
+The `credit` module tabulates the contribution of each tool to the discovery of issue instances in a collection of scored reports. Its `credit()` function takes two arguments: a report description and an array of `score` properties of scored reports.
 
 The credit report contains four sections:
 - `counts`: for each issue, how many instances each tool reported
@@ -718,57 +753,27 @@ A module can invoke `credit()` in this way:
 
 ```javaScript
 const {credit} = require('testilo/credit');
-credit(scoredReports)
+const reportScores = […];
+credit('June 2025', reportScores)
 .then(creditReport => {…});
 ```
 
-The argument to `credit()` is an array of scored report objects. The `credit()` function returns a credit report. The invoking module can further dispose of the credit report as needed.
+The first argument to `credit()` is a description to be included in the credit report. The second argument is an array of `score` properties of scored report objects. The `credit()` function returns a credit report. The invoking module can further dispose of the credit report as needed.
 
 ##### By a user
 
-A user can invoke `credit()` in this way:
+A user can invoke `credit()` in one of these ways:
 
 ```bash
-node call credit legislators 23pl
+node call credit legislators
+node call credit legislators 241106
 ```
 
 When a user invokes `credit` in this example, the `call` module:
-- gets all the reports in the `scored` subdirectory of the `REPORTDIR` directory whose file names begin with `23pl`.
-- writes the credit report as a JSON file named `legislators.json` to the `credit` subdirectory of the `REPORTDIR` directory.
-
-The third argument to `call` (`23pl` in this example) is optional. If it is omitted, `call` will get and `credit()` will tabulate all the reports in the `scored` directory.
-
-### Summarization
-
-The `summarize` module of Testilo can summarize a collection of scored reports. The summary of each report contains, insofar as they exist in the report, its ID, end time, order ID, target data, and total score.
-
-#### Invocation
-
-##### By a module
-
-A module can invoke `summarize()` in this way:
-
-```javaScript
-const {summarize} = require('testilo/summarize');
-const reports = […];
-const summary = summarize('external', reports);
-…
-```
-
-The first argument to `summarize()` is a description of the set of summarized repeorts. The `reports` argument is an array of scored reports. The `summary` constant is an object. The module can further dispose of `summary` as needed.
-
-##### By a user
-
-A user can invoke `summarize()` in either of these two ways:
-
-```javaScript
-node call summarize divisions
-node call summarize divisions 2411
-```
-
-When a user invokes `summarize` in this example, the `call` module:
-- gets all the reports in the `scored` subdirectory of the `REPORTDIR` directory, or (if the third argument is present) all those whose file names begin with `2411`.
-- writes the summary, with `divisions` as its description, in JSON format to the `summarized` subdirectory of the `REPORTDIR` directory.
+- gets all reports, or if the third argument to `call()` exists all reports whose file names begin with `'241106'`, in the `scored` subdirectory of the `REPORTDIR` directory. 
+- gets the `score` properties of those reports.
+- creates an ID for the credit report.
+- writes the credit report as a JSON file, with the ID as the base of its file name and `legislators` as its description, to the `credit` subdirectory of the `REPORTDIR` directory.
 
 ### Track
 
@@ -800,7 +805,7 @@ node call track ttp99a 241016T2045-Uf-0 4 'ABC Foundation'
 
 When a user invokes `track()` in this example, the `call` module:
 - gets the summary from the `241016T2045-Uf-0.json` file in the `summarized` subdirectory of the `REPORTDIR` directory.
-- selects the summarized data for all audits with the `order` value of `'4'` and the `target.what` value of `'ABC Foundation'`. If the third or fourth argument to `call()` is `null` (or omitted), then `call()` does not select audits by `order` or by `target.what`, respectively.
+- selects the summarized data for all results with the `order` value of `'4'` and the `target.what` value of `'ABC Foundation'`. If the third or fourth argument to `call()` is `null` (or omitted), then `call()` does not select results by `order` or by `target.what`, respectively.
 - uses tracker `ttp99a` to create a tracking report.
 - writes the tracking report to the `tracking` subdirectory of the `REPORTDIR` directory.
 

package/call.js

@@ -17,7 +17,7 @@
 // Module to keep secrets.
 require('dotenv').config();
 // Module to perform common operations.
-const {getNowStamp, getRandomString} = require('./procs/util');
+const {getFileID, getNowStamp, getRandomString} = require('./procs/util');
 // Function to process files.
 const fs = require('fs/promises');
 // Function to process a list-to-batch conversion.
@@ -34,6 +34,8 @@ const {digest} = require('./digest');
 const {difgest} = require('./difgest');
 // Function to compare scores.
 const {compare} = require('./compare');
+// Function to credit tools for issues in reports.
+const {credit} = require('./credit');
 // Function to summarize reports.
 const {summarize} = require('./summarize');
 // Function to track audits.
@@ -50,35 +52,66 @@ const fnArgs = process.argv.slice(3);
 
 // ########## FUNCTIONS
 
+// Gets a summary report.
+const getSummaryReport = async selector => {
+  const summaryDir = `${reportDir}/summarized`;
+  const summaryReportNames = await fs.readdir(summaryDir);
+  const summaryReportName = summaryReportNames.find(reportName => reportName.startsWith(selector));
+  if (summaryReportName) {
+    const summaryReportJSON = await fs.readFile(`${summaryDir}/${summaryReportName}`, 'utf8');
+    const summaryReport = JSON.parse(summaryReportJSON);
+    return summaryReport;
+  }
+  else {
+    throw new Error(`ERROR: No summary report name starts with ${selector}`);
+  }
+};
 // Converts a target list to a batch.
 const callBatch = async (id, what) => {
   // Get the target list.
-  const listString = await fs.readFile(`${specDir}/targetLists/${id}.tsv`, 'utf8');
-  const list = listString
-  .split('\n')
-  .filter(target => target.length)
-  .map(target => target.split('\t'));
-  // Convert it to a batch.
-  const batchObj = batch(id, what, list);
-  // Save the batch.
-  if (batchObj) {
-    const batchJSON = JSON.stringify(batchObj, null, 2);
-    await fs.writeFile(`${specDir}/batches/${id}.json`, `${batchJSON}\n`);
-    console.log(`Target list ${id} converted to a batch and saved in ${specDir}/batches`);
+  try {
+    const listString = await fs.readFile(`${specDir}/targetLists/${id}.txt`, 'utf8');
+    const list = listString
+    .split('\n')
+    .filter(target => target.length)
+    .map(target => target.split('|'));
+    // Convert it to a batch.
+    const batchObj = batch(id, what, list);
+    // Save the batch.
+    if (batchObj) {
+      const batchJSON = JSON.stringify(batchObj, null, 2);
+      const batchPath = `${specDir}/batches/${id}.json`;
+      await fs.writeFile(batchPath, `${batchJSON}\n`);
+      console.log(`Target list ${id} converted to a batch and saved as ${batchPath}`);
+    }
+  }
+  catch(error) {
+    console.log(`ERROR converting target list to batch (${error.message})`);
   }
 };
 // Fulfills a script-creation request.
-const callScript = async (scriptID, classificationID = null, ... issueIDs) => {
-  // Get any issue classification.
-  const issues = classificationID
-  ? require(`${functionDir}/score/${classificationID}`).issues
-  : null;
-  // Create a script.
-  const scriptObj = script(scriptID, issues, ... issueIDs);
-  // Save the script.
-  const scriptJSON = JSON.stringify(scriptObj, null, 2);
-  await fs.writeFile(`${specDir}/scripts/${scriptID}.json`, `${scriptJSON}\n`);
-  console.log(`Script ${scriptID} created and saved in ${specDir}/scripts`);
+const callScript = async (scriptID, what, classificationID = null, ... issueIDs) => {
+  try {
+    // Get any issue classification.
+    const issues = classificationID
+    ? require(`${functionDir}/score/${classificationID}`).issues
+    : null;
+    // Sanitize the ID.
+    scriptID = scriptID.replace(/[^a-zA-Z0-9]/g, '');
+    if (scriptID === '') {
+      scriptID = `script-${getRandomString(2)}`;
+    }
+    // Create a script.
+    const scriptObj = script(scriptID, what, issues, ... issueIDs);
+    // Save the script.
+    const scriptJSON = JSON.stringify(scriptObj, null, 2);
+    const scriptPath = `${specDir}/scripts/${scriptID}.json`;
+    await fs.writeFile(scriptPath, `${scriptJSON}\n`);
+    console.log(`Script created and saved as ${scriptPath}`);
+  }
+  catch(error) {
+    console.log(`ERROR creating script (${error.message})`);
+  }
 };
 // Fulfills a merging request.
 const callMerge = async (
@@ -90,58 +123,67 @@ const callMerge = async (
   timeStamp,
   todoDir
 ) => {
-  // Get the script and the batch.
-  const scriptJSON = await fs.readFile(`${specDir}/scripts/${scriptID}.json`, 'utf8');
-  const script = JSON.parse(scriptJSON);
-  const batchJSON = await fs.readFile(`${specDir}/batches/${batchID}.json`, 'utf8');
-  const batch = JSON.parse(batchJSON);
-  // Merge them into an array of jobs.
-  const jobs = merge(script, batch, standard, observe === 'true', requester, timeStamp);
-  // Save the jobs.
-  const subdir = `${jobDir}/${todoDir === 'true' ? 'todo' : 'pending'}`;
-  for (const job of jobs) {
-    const jobJSON = JSON.stringify(job, null, 2);
-    await fs.writeFile(`${subdir}/${job.id}.json`, `${jobJSON}\n`);
+  try {
+    // If the todoDir argument is invalid:
+    if (! ['true', 'false'].includes(todoDir)) {
+      // Report this.
+      throw new Error('Invalid todoDir configuration');
+    }
+    // Get the script and the batch.
+    const scriptJSON = await fs.readFile(`${specDir}/scripts/${scriptID}.json`, 'utf8');
+    const script = JSON.parse(scriptJSON);
+    const batchJSON = await fs.readFile(`${specDir}/batches/${batchID}.json`, 'utf8');
+    const batch = JSON.parse(batchJSON);
+    // Merge them into an array of jobs.
+    const jobs = merge(script, batch, standard, observe === 'true', requester, timeStamp);
+    // Save the jobs.
+    const subdir = `${jobDir}/${todoDir === 'true' ? 'todo' : 'pending'}`;
+    for (const job of jobs) {
+      const jobJSON = JSON.stringify(job, null, 2);
+      await fs.writeFile(`${subdir}/${job.id}.json`, `${jobJSON}\n`);
+    }
+    const truncatedID = `${jobs[0].timeStamp}-${jobs[0].mergeID}-…`;
+    console.log(`Script ${scriptID} and batch ${batchID} merged as ${truncatedID} in ${subdir}`);
+  }
+  catch(error) {
+    console.log(`ERROR merging script and batch (${error.message})`);
   }
-  const truncatedID = `${jobs[0].timeStamp}-${jobs[0].mergeID}-…`;
-  console.log(`Script ${scriptID} and batch ${batchID} merged as ${truncatedID} in ${subdir}`);
 };
-// Gets selected reports.
-const getReports = async (type, selector = '') => {
+// Gets the file base names (equal to the IDs) of the selected reports.
+const getReportIDs = async (type, selector = '') => {
   const allFileNames = await fs.readdir(`${reportDir}/${type}`);
   const reportIDs = allFileNames
   .filter(fileName => fileName.endsWith('.json'))
   .filter(fileName => fileName.startsWith(selector))
   .map(fileName => fileName.slice(0, -5));
-  const reports = [];
-  for (const reportID of reportIDs) {
-    const reportJSON = await fs.readFile(`${reportDir}/${type}/${reportID}.json`, 'utf8');
-    const report = JSON.parse(reportJSON);
-    reports.push(report);
-  }
-  return reports;
+  return reportIDs;
+};
+// Gets and returns a report.
+const getReport = async (type, id) => {
+  const reportJSON = await fs.readFile(`${reportDir}/${type}/${id}.json`, 'utf8');
+  const report = JSON.parse(reportJSON);
+  return report;
 };
 // Fulfills a scoring request.
 const callScore = async (scorerID, selector = '') => {
   // Get the raw reports to be scored.
-  const reports = await getReports('raw', selector);
+  const reportIDs = await getReportIDs('raw', selector);
   // If any exist:
-  if (reports.length) {
+  if (reportIDs.length) {
     // Get the scorer.
     const {scorer} = require(`${functionDir}/score/${scorerID}`);
-    // Score the reports.
-    score(scorer, reports);
+    // Score and save the reports.
     const scoredReportDir = `${reportDir}/scored`;
     await fs.mkdir(scoredReportDir, {recursive: true});
-    // For each scored report:
-    for (const report of reports) {
-      // Save it.
+    for (const reportID of reportIDs) {
+      const report = await getReport('raw', reportID);
+      score(scorer, report);
       await fs.writeFile(
-        `${scoredReportDir}/${report.id}.json`, `${JSON.stringify(report, null, 2)}\n`
+        `${scoredReportDir}/${reportID}.json`, `${JSON.stringify(report, null, 2)}\n`
       );
-    };
-    console.log(`Reports scored and saved in ${scoredReportDir}`);
     }
+    console.log(`Reports scored and saved in ${scoredReportDir}`);
+  }
   // Otherwise, i.e. if no raw reports are to be scored:
   else {
     // Report this.
@@ -150,22 +192,26 @@ const callScore = async (scorerID, selector = '') => {
 };
 // Fulfills a digesting request.
 const callDigest = async (digesterID, selector = '') => {
-  // Get the scored reports to be digested.
-  const reports = await getReports('scored', selector);
+  // Get the base base names (equal to the IDs) of the scored reports to be digested.
+  const reportIDs = await getReportIDs('scored', selector);
   // If any exist:
-  if (reports.length) {
-    // Get the digester.
-    const {digester} = require(`${functionDir}/digest/${digesterID}/index`);
-    // Digest the reports.
-    const digestedReports = await digest(digester, reports);
-    const digestedReportDir = `${reportDir}/digested`;
-    await fs.mkdir(digestedReportDir, {recursive: true});
-    // For each digested report:
-    for (const reportID of Object.keys(digestedReports)) {
-      // Save it.
-      await fs.writeFile(`${digestedReportDir}/${reportID}.html`, digestedReports[reportID]);
-    };
-    console.log(`Reports digested and saved in ${digestedReportDir}`);
+  if (reportIDs.length) {
+    try {
+      // Get the digester.
+      const {digester} = require(`${functionDir}/digest/${digesterID}/index`);
+      // Digest and save the reports.
+      const digestDir = `${reportDir}/digested`;
+      await fs.mkdir(digestDir, {recursive: true});
+      for (const reportID of reportIDs) {
+        const report = await getReport('scored', reportID);
+        const digestedReport = await digest(digester, report);
+        await fs.writeFile(`${digestDir}/${reportID}.html`, digestedReport);
+      };
+      console.log(`Reports digested and saved in ${digestDir}`);
+    }
+    catch(error) {
+      console.log(`ERROR digesting reports (${error.message})`);
+    }
   }
   // Otherwise, i.e. if no scored reports are to be digested:
   else {
@@ -176,10 +222,8 @@ const callDigest = async (digesterID, selector = '') => {
 // Fulfills a difgesting request.
 const callDifgest = async (difgesterID, reportAID, reportBID) => {
   // Get the scored reports to be difgested.
-  const reportAArray = await getReports('scored', reportAID);
-  const reportBArray = await getReports('scored', reportBID);
-  const reportA = reportAArray[0];
-  const reportB = reportBArray[0];
+  const reportA = await getReport('scored', reportAID);
+  const reportB = await getReport('scored', reportBID);
   // If both exist:
   if (reportAID && reportBID) {
     // Get the difgester.
@@ -201,69 +245,90 @@ const callDifgest = async (difgesterID, reportAID, reportBID) => {
     console.log('ERROR: No pair of scored reports to be digested');
   }
 };
-// Fulfills a comparison request.
-// Get the scored reports to be scored.
-const callCompare = async (compareProcID, comparisonNameBase, selector = '') => {
-  const reports = await getReports('scored', selector);
-  // If any exist:
-  if (reports.length) {
-    // Get the comparer.
-    const comparerDir = `${functionDir}/compare/${compareProcID}`;
-    const {comparer} = require(`${comparerDir}/index`);
-    // Compare the reports.
-    const comparison = await compare(comparer, reports);
-    // Save the comparison.
-    const comparisonDir = `${reportDir}/comparative`;
-    await fs.mkdir(comparisonDir, {recursive: true}); 
-    await fs.writeFile(`${comparisonDir}/${comparisonNameBase}.html`, comparison);
-    console.log(`Comparison completed and saved in ${comparisonDir}`);
-  }
-};
-// Fulfills a credit request.
-const callCredit = async (tallyID, selector = '') => {
-  // Get the scored reports to be tallied.
-  const reports = await getReports('scored', selector);
+// Fulfills a summarization request.
+const callSummarize = async (what, selector = '') => {
+  // Get the IDs of the scored reports to be summarized.
+  const reportIDs = await getReportIDs('scored', selector);
   // If any exist:
-  if (reports.length) {
-    // Get the tallier.
-    const {credit} = require(`${functionDir}/analyze/credit`);
-    // Tally the reports.
-    const tally = credit(reports);
-    // Save the tally.
-    const creditDir = `${reportDir}/credit`;
-    await fs.mkdir(creditDir, {recursive: true}); 
-    await fs.writeFile(`${creditDir}/${tallyID}.json`, JSON.stringify(tally, null, 2));
-    console.log(`Reports tallied and credit report ${tallyID} saved in ${creditDir}`);
+  if (reportIDs.length) {
+    // Initialize a summary report.
+    const summaryReport = {
+      id: getFileID(2),
+      what,
+      data: []
+    };
+    // For each report to be summarized:
+    for (const reportID of reportIDs) {
+      // Get it.
+      const report = await getReport('scored', reportID);
+      // Add a summary of it to the summary report.
+      const summary = summarize(report);
+      summaryReport.data.push(summary);
+    };
+    // Save the summary report.
+    const summaryDir = `${reportDir}/summarized`;
+    await fs.mkdir(summaryDir, {recursive: true}); 
+    const filePath = `${summaryDir}/${summaryReport.id}.json`;
+    await fs.writeFile(filePath, `${JSON.stringify(summaryReport, null, 2)}\n`);
+    console.log(`Reports summarized and summary report saved as ${filePath}`);
   }
-  // Otherwise, i.e. if no scored reports are to be tallied:
+  // Otherwise, i.e. if no scored reports are to be summarized:
   else {
     // Report this.
-    console.log('ERROR: No scored reports to be tallied');
+    console.log('ERROR: No scored reports to be summarized');
   }
 };
-// Fulfills a summarization request.
-const callSummarize = async (what, selector = '') => {
-  // Get the scored reports to be summarized.
-  const reports = await getReports('scored', selector);
+// Fulfills a comparison request.
+const callCompare = async (what, compareProcID, selector) => {
+  // Get the specified summary report.
+  const summaryReport = await getSummaryReport(selector);
+  // If it exists:
+  if (summaryReport) {
+    try {
+      // Get the comparer.
+      const comparerDir = `${functionDir}/compare/${compareProcID}`;
+      const {comparer} = require(`${comparerDir}/index`);
+      // Compare the reports and save the comparison.
+      const comparisonDir = `${reportDir}/comparative`;
+      await fs.mkdir(comparisonDir, {recursive: true}); 
+      const id = getFileID(2);
+      const comparison = await compare(id, what, comparer, summaryReport);
+      const comparisonPath = `${comparisonDir}/${id}.html`;
+      await fs.writeFile(comparisonPath, comparison);
+      console.log(`Comparison completed and saved as ${comparisonPath}`);
+    }
+    catch(error) {
+      console.log(`ERROR comparing scores (${error.message})`);
+    }
+  }
+};
+// Fulfills a credit request.
+const callCredit = async (what, selector = '') => {
+  // Get the IDs of the scored reports to be credited.
+  const reportIDs = await getReportIDs('scored', selector);
   // If any exist:
-  if (reports.length) {
-    // Summarize them.
-    const summary = summarize(what, reports);
-    // Add the selector, if any, to the summary.
-    if (selector) {
-      summary.selector = selector;
+  if (reportIDs.length) {
+    // Get an array of the score properties of the reports to be credited.
+    const reportScores = [];
+    for (const id of reportIDs) {
+      const report = await getReport('scored', id);
+      reportScores.push(report.score);
     }
-    // Save the summary.
-    const summaryDir = `${reportDir}/summarized`;
-    await fs.mkdir(summaryDir, {recursive: true}); 
-    const filePath = `${summaryDir}/${summary.id}.json`;
-    await fs.writeFile(filePath, `${JSON.stringify(summary, null, 2)}\n`);
-    console.log(`Reports summarized and summary saved as ${filePath}`);
+    // Credit the reports.
+    const tally = credit(what, reportScores);
+    // Save the credit report.
+    const creditDir = `${reportDir}/credit`;
+    await fs.mkdir(creditDir, {recursive: true});
+    const creditReportID = getFileID(2);
+    tally.id = creditReportID;
+    const reportPath = `${creditDir}/${creditReportID}.json`;
+    await fs.writeFile(reportPath, `${JSON.stringify(tally, null, 2)}\n`);
+    console.log(`Reports credited and credit report saved as ${reportPath}`);
   }
-  // Otherwise, i.e. if no scored reports are to be summarized:
+  // Otherwise, i.e. if no scored reports are to be credited:
   else {
     // Report this.
-    console.log('ERROR: No scored reports to be summarized');
+    console.log('ERROR: No scored reports to be credited');
   }
 };
 // Fulfills a tracking request.
@@ -273,20 +338,20 @@ const callTrack = async (trackerID, summaryID, orderID, targetWhat) => {
     const summaryJSON = await fs.readFile(`${reportDir}/summarized/${summaryID}.json`, 'utf8');
     const summary = JSON.parse(summaryJSON);
     // Remove unwanted audits from it.
-    summary.data = summary.data.filter(audit => {
-      if (orderID && audit.order !== orderID) {
+    summary.data = summary.data.filter(result => {
+      if (orderID && result.order !== orderID) {
         return false;
       }
-      if (targetWhat && audit.target && audit.target.what !== targetWhat) {
+      if (targetWhat && result.target && result.target.what !== targetWhat) {
         return false;
       }
       return true;
     });
-    // If any audits remain:
+    // If any results remain:
     if (summary.data.length) {
       // Get the tracker.
       const {tracker} = require(`${functionDir}/track/${trackerID}/index`);
-      // Track the audits.
+      // Track the results.
       const [reportID, trackingReport] = await track(tracker, summary);
       // Save the tracking report.
       await fs.mkdir(`${reportDir}/tracking`, {recursive: true});
@@ -313,7 +378,7 @@ if (fn === 'batch' && fnArgs.length === 2) {
     console.log('Execution completed');
   });
 }
-else if (fn === 'script' && (fnArgs.length === 1 || fnArgs.length > 2)) {
+else if (fn === 'script' && (fnArgs.length === 2 || fnArgs.length > 3)) {
   callScript(... fnArgs)
   .then(() => {
     console.log('Execution completed');
@@ -349,20 +414,20 @@ else if (fn === 'difgest' && fnArgs.length === 3) {
     console.log('Execution completed');
   });
 }
-else if (fn === 'compare' && fnArgs.length > 1 && fnArgs.length < 4) {
-  callCompare(... fnArgs)
+else if (fn === 'summarize' && fnArgs.length > 0 && fnArgs.length < 3) {
+  callSummarize(... fnArgs)
   .then(() => {
     console.log('Execution completed');
   });
 }
-else if (fn === 'credit' && fnArgs.length > 0 && fnArgs.length < 3) {
-  callCredit(... fnArgs)
+else if (fn === 'compare' && fnArgs.length === 3) {
+  callCompare(... fnArgs)
   .then(() => {
     console.log('Execution completed');
   });
 }
-else if (fn === 'summarize' && fnArgs.length > 0 && fnArgs.length < 3) {
-  callSummarize(... fnArgs)
+else if (fn === 'credit' && fnArgs.length > 0 && fnArgs.length < 3) {
+  callCredit(... fnArgs)
   .then(() => {
     console.log('Execution completed');
   });

package/compare.js

@@ -1,16 +1,16 @@
 /*
   compare.js
-  Creates a comparison from scored reports.
+  Creates a comparison from a summary report.
   Arguments:
     0. Comparing function.
-    1. Array of scored reports.
+    1. Summary report.
 */
 
 // ########## FUNCTIONS
 
-// Compares the scored reports and returns a comparison.
-exports.compare = async (comparer, scoredReports) => {
+// Compares the summarized reports and returns a comparison.
+exports.compare = async (id, what, comparer, summaryReport) => {
   // Return the comparison.
-  console.log(`Comparison complete. Report count: ${scoredReports.length}`);
-  return comparer(scoredReports);
+  console.log(`Comparison complete. Report count: ${summaryReport.data.length}`);
+  return comparer(id, what, summaryReport);
 };

package/{procs/analyze/credit.js → credit.js}

@@ -1,11 +1,12 @@
 /*
   credit.js
-  Analyzes tool coverages of issues in a set of reports.
+  Analyzes tool coverages of issues in an array of score properties of scored reports.
 */
 
 // Returns a tabulation of the instance counts of issues reported by tools in scored reports.
-exports.credit = reports => {
+exports.credit = (what, reportScores) => {
   const tally = {
+    what,
     instanceCounts: {},
     onlies: {},
     mosts: {},
@@ -19,11 +20,11 @@ exports.credit = reports => {
   };
   const {instanceCounts, onlies, mosts, tools, issueCounts} = tally;
   // For each report:
-  reports.forEach(report => {
+  reportScores.forEach(reportScore => {
     // If it is valid:
-    if (report.score && report.score.details && report.score.details.issue) {
+    if (reportScore && reportScore.details && reportScore.details.issue) {
       // For each issue:
-      const issues = report.score.details && report.score.details.issue;
+      const issues = reportScore.details && reportScore.details.issue;
       Object.keys(issues).forEach(issueID => {
         // For each tool with any complaints about it:
         if (! instanceCounts[issueID]) {
@@ -51,13 +52,6 @@ exports.credit = reports => {
                 }
                 instanceCounts[issueID][toolID].rules[ruleID] += complaints.countTotal;
               }
-              // Otherwise, i.e. if no instance count was recorded:
-              else {
-                // Report this.
-                console.log(
-                  `ERROR: Report ${report.id} missing countTotal for ${toolID} in ${issueID}`
-                );
-              }
             });
           });
         }
@@ -66,11 +60,6 @@ exports.credit = reports => {
         }
       });
     }
-    // Otherwise, i.e. if it is invalid:
-    else {
-      // Report this.
-      console.log(`ERROR: Report ${report.id} missing score data`);
-    }
   });
   // Populate the total and initial non-only issue counts.
   issueCounts.nonOnlies = issueCounts.total = Object.keys(instanceCounts).length;

package/digest.js

@@ -1,25 +1,18 @@
 /*
   digest.js
-  Creates digests from scored reports.
+  Creates a digest from a scored report.
   Arguments:
     0. Digesting function.
-    1. Array of scored reports.
+    1. Scored report.
 */
 
 // ########## FUNCTIONS
 
 // Digests the scored reports and returns them, digested.
-exports.digest = async (digester, reports) => {
-  const digests = {};
-  // For each report:
-  for (const report of reports) {
-    // Use it to create a digest.
-    const digestedReport = await digester(report);
-    // Add the digest to the array of digests.
-    digests[report.id] = digestedReport;
-    console.log(`Report ${report.id} digested`);
-  };
-  // Return the digests.
-  console.log(`Digesting complete; report count ${reports.length}`);
-  return digests;
+exports.digest = async (digester, report) => {
+  // Create a digest.
+  const digest = await digester(report);
+  console.log(`Report ${report.id} digested`);
+  // Return the digest.
+  return digest;
 };

package/merge.js

@@ -28,6 +28,18 @@ const mergeIDLength = 2;
 
 // Merges a script and a batch and returns jobs.
 exports.merge = (script, batch, standard, observe, requester, timeStamp) => {
+  // If standard is invalid:
+  if (! ['also', 'only', 'no'].includes(standard)) {
+    // Report this and quit.
+    console.log('ERROR: Invalid standard treatment specified');
+    return [];
+  }
+  // If observe is invalid:
+  if (! [true, false].includes(observe)) {
+    // Report this and quit.
+    console.log('ERROR: Invalid observe configuration specified');
+    return [];
+  }
   // If a time stamp was specified:
   if (timeStamp) {
     // If it is invalid:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testilo",
-  "version": "28.0.1",
+  "version": "29.0.0",
   "description": "Prepares and processes Testaro reports",
   "main": "call.js",
   "scripts": {

package/procs/analyze/ruleCounts.js

@@ -1,9 +1,9 @@
 /*
   ruleCounts.js
-  Tabulates tool rules from a issue classification.
+  Tabulates tool rules from an issue classification.
 */
 
-const {issues} = require('../score/tic36');
+const {issues} = require('../score/tic40');
 
 const counts = {
   total: 0

package/procs/compare/tcp40/index.html

@@ -8,16 +8,17 @@
     <meta name="publisher" name="Testilo">
     <meta name="description" content="comparison of accessibility scores">
     <meta name="keywords" content="accessibility a11y web testing">
-    <title>Accessibility score comparison</title>
+    <title>Accessibility score comparison: __what__</title>
     <link rel="icon" href="favicon.ico">
     <link rel="stylesheet" href="style.css">
   </head>
   <body>
     <main>
       <header>
-        <h1>Accessibility score comparison</h1>
+        <h1>Accessibility score comparison: __what__</h1>
       </header>
       <h2>Introduction</h2>
+      <p>This is comparison __id__.</p>
       <p>The table below compares __pageCount__ web pages on <a href="https://www.w3.org/WAI/fundamentals/accessibility-intro/">accessibility</a>. The page names are links to the pages on the web. The scores are links to digests that explain in detail how the scores were computed.</p>
       <p>The pages were tested by <a href="https://www.npmjs.com/package/testaro">Testaro</a>. Testaro used ten tools (Alfa, ASLint, Axe, Editoria11y, Equal Access, HTML CodeSniffer, Nu Html Checker, QualWeb, Testaro, and WAVE) to perform about 900 automated accessibility tests.</p>
       <p><a href="https://www.npmjs.com/package/testilo">Testilo</a> classified the problems found by these tests into <dfn>issues</dfn> and assigned a <dfn>score</dfn> to each page. A perfect score would be 0. Higher scores indicate more issues, more instances of them, more serious issues, and more of the tools reporting instances of issues.</p>

package/procs/compare/tcp40/index.js

@@ -1,6 +1,6 @@
 /*
   index
-  Compares scores in reports scored by tsp39 for use by Testu.
+  Compares scores in a summary report.
 */
 
 // ########## IMPORTS
@@ -11,46 +11,26 @@ const {getBarCell, getNowDate, getNowDateSlash} = require('../../util');
 
 // CONSTANTS
 
-// Comparer ID.
-const id = 'tcp39';
 // Newlines with indentations.
 const innestJoiner = '\n          ';
 
 // ########## FUNCTIONS
 
-// Returns data on the targets.
-const getData = async scoredReports => {
-  // For each scored report:
-  const bodyData = [];
-  for (const report of scoredReports) {
-    // Get data.
-    const {id, sources, score} = report;
-    if (id && sources && sources.script && score) {
-      bodyData.push({
-        id,
-        org: sources.target.what,
-        url: sources.target.which,
-        score: score.summary.total
-      });
-    }
-  };
-  // Return the report count, the script ID of the first report, and the data of all the reports.
-  return {
-    pageCount: scoredReports.length,
-    bodyData
-  }
-};
 // Returns the maximum score.
-const getMaxScore = tableData => tableData.reduce((max, item) => Math.max(max, item.score), 0);
-// Converts report data to a table body.
-const getTableBody = async bodyData => {
-  const maxScore = getMaxScore(bodyData);
-  const rows = bodyData
+const getMaxScore = summaryReport => summaryReport.data.reduce(
+  (max, result) => Math.max(max, result.score), 0
+);
+// Converts summary report data to a table body.
+const getTableBody = async summaryReport => {
+  const maxScore = getMaxScore(summaryReport);
+  const rows = summaryReport.data
   .sort((a, b) => a.score - b.score)
-  .map(item => {
-    const {id, org, url, score} = item;
-    const pageCell = `<th scope="row"><a href="${url}">${org}</a></th>`;
-    const numCell = `<td><a href="testu/digest?jobID=${id}">${score}</a></td>`;
+  .map(result => {
+    const {id, target, score} = result;
+    const {what, which} = target;
+    const pageCell = `<th scope="row"><a href="${which}">${what}</a></th>`;
+    const scoreDestination = process.env.DIGEST_URL.replace('__id__', id);
+    const numCell = `<td><a href="${scoreDestination}">${score}</a></td>`;
     // Make the bar width proportional.
     const barCell = getBarCell(score, maxScore, 25, false);
     const row = `<tr>${pageCell}${numCell}${barCell}</tr>`;
@@ -59,18 +39,19 @@ const getTableBody = async bodyData => {
   return rows.join(innestJoiner);
 };
 // Populates a query for a comparative table.
-const populateQuery = async (scoredReports, query) => {
-  const data = await getData(scoredReports);
-  query.pageCount = data.pageCount;
-  query.tableBody = await getTableBody(data.bodyData);
+const populateQuery = async (id, what, summaryReport, query) => {
+  query.id = id;
+  query.what = what;
+  query.pageCount = summaryReport.data.length;
+  query.tableBody = await getTableBody(summaryReport);
   query.dateISO = getNowDate();
   query.dateSlash = getNowDateSlash();
 };
-// Returns a comparative report.
-exports.comparer = async scoredReports => {
+// Returns a comparison.
+exports.comparer = async (id, what, summaryReport) => {
   // Create a query to replace placeholders.
   const query = {};
-  populateQuery(scoredReports, query);
+  populateQuery(id, what, summaryReport, query);
   // Get the template.
   let template = await fs.readFile(`${__dirname}/index.html`, 'utf8');
   // Replace its placeholders.

package/procs/score/tic40.js

@@ -5801,6 +5801,13 @@ exports.issues = {
     wcag: '2.5.5',
     weight: 3,
     tools: {
+      alfa: {
+        r111: {
+          variable: false,
+          quality: 1,
+          what: 'Target size is substandard'
+        }
+      },
       testaro: {
         targetSize: {
           variable: false,

package/procs/track/ttp40/index.html

@@ -19,7 +19,7 @@
       </header>
       <h2>Introduction</h2>
       <p>This is tracking report <code>__id__</code>.</p>
-      <p>It tracks accessibility scores over time. A perfect score is 0. The tracking was performed by Testilo procedure __tp__.</p>
+      <p>It tracks accessibility scores over time. A perfect score is 0. The tracking was performed by Testilo procedure <code>__tp__</code>.</p>
       <p>The results are presented first as a graph, and then as a table.</p>
       <h2>Results as a graph</h2>
       <figure id="graph">

package/procs/track/ttp40/index.js

@@ -29,9 +29,7 @@ const populateQuery = async (id, summary, query) => {
   query.dateSlash = getNowDateSlash();
   // JSON of pruned summary.
   summary.data.forEach(result => {
-    delete result.id;
     delete result.target.id;
-    delete result.target.which;
   });
   query.summaryJSON = JSON.stringify(summary);
   // For each score:

package/score.js

@@ -1,20 +1,15 @@
 /*
   score.js
-  Scores Testaro reports.
+  Scores a Testaro report.
   Arguments:
     0. Scoring function.
-    1. Array of reports.
+    1. Report.
 */
 
 // ########## FUNCTIONS
 
-// Scores the specified raw reports.
-exports.score = (scorer, reports) => {
-  // For each report:
-  for (const report of reports) {
-    // Score it.
-    scorer(report);
-    console.log(`Report ${report.id} scored`);
-  }
-  console.log(`Scoring complete; report count ${reports.length}`);
+// Scores the specified raw report.
+exports.score = (scorer, report) => {
+  scorer(report);
+  console.log(`Report ${report.id} scored`);
 };

package/script.js

@@ -18,7 +18,7 @@ let toolIDs = [
 // ########## FUNCTIONS
 
 // Creates and returns a script.
-exports.script = (id, issues = null, ... issueIDs) => {
+exports.script = (id, what, issues = null, ... issueIDs) => {
   // Initialize data on the tools and their rules for the specified issues, if any.
   const neededTools = {};
   // If an issue classification and any issues were specified:
@@ -67,7 +67,7 @@ exports.script = (id, issues = null, ... issueIDs) => {
     // Initialize a script.
     const scriptObj = {
       id,
-      what: `accessibility tests`,
+      what,
       strict: true,
       isolate: true,
       timeLimit: Math.round(30 + (issueIDs.length || 300) / 2 + 20 * toolIDs.length),

package/summarize.js

@@ -1,35 +1,26 @@
 /*
   summarize.js
-  Returns a summary of reports.
+  Returns a summary of a report.
 */
 
 // ########## IMPORTS
 
 // Module to keep secrets.
 require('dotenv').config();
-// Module to perform common operations.
-const {getFileID} = require('./procs/util');
 
 // ########## FUNCTIONS
 
-// Returns a summary.
-exports.summarize = (what, reports) => {
-  const data = reports.map(report => {
-    const {id, jobData, score, sources} = report;
-    const order = sources && sources.order || '';
-    const target = sources && sources.target || '';
-    return {
-      id: id || '',
-      endTime: jobData && jobData.endTime || '',
-      order: order || '',
-      target,
-      score: score && score.summary && score.summary.total || null
-    };
-  });
+// Returns a report summary.
+exports.summarize = report => {
+  const {id, jobData, score, sources} = report;
+  const order = sources && sources.order || '';
+  const target = sources && sources.target || '';
   const summary = {
-    id: getFileID(2),
-    what,
-    data
+    id: id || '',
+    endTime: jobData && jobData.endTime || '',
+    order: order || '',
+    target,
+    score: score && score.summary && score.summary.total || null
   };
   return summary;
 };