@jrpool/kilotest 59.1.4 → 60.0.0

package/README.md

@@ -10,7 +10,7 @@ An ensemble testing and reporting service for front-end web quality
 
 ## Features
 
-This application uses an ensemble of 12 rule engines to test web pages for front-end quality (i.e. accessibility, usability, and web standards, including HTML, CSS, ARIA, and WCAG (HTML, CSS, ARIA, WCAG)).
+This application uses an ensemble of 12 rule engines to test web pages for front-end quality (i.e. accessibility, usability, and web standards, including HTML, CSS, ARIA, and WCAG).
 
 The testing paradigm employed by Kilotest is discussed in these papers:
 
@@ -55,10 +55,7 @@ See the [`SERVICE.md`](docs/SERVICE.md) file for instructions on how to make Kil
 
 Kilotest is not only a web application but also an API and an MCP server. AI platforms and models can use Kilotest via those interfaces.
 
-The URL for models using the MCP server is `https://kilotest.com/mcp`. The MCP server is listed at these services:
-
-- [Smithery](https://smithery.ai/servers/pool/kilotest)
-- [Glama](https://glama.ai/mcp/connectors/com.kilotest/kilotest)
+The public URL for models using the MCP server at `kilotest.com` is `https://kilotest.com/mcp`. The MCP server is registered at several registries. See [AI-TOOLS.md](docs/AI-TOOLS.md#External-features) for details.
 
 There is additional documentation at:
 

package/api/awaitTest.test.ts

@@ -43,24 +43,24 @@ after(() => {
 
 // TESTS
 
-test('awaitTest rejects a malformed timestamp or job identifier', async () => {
-  const body = await response(['999999T9999', 'xyz']);
+test('awaitTest rejects a malformed report identifier', async () => {
+  const body = await response(['999999T9999-xyz']);
   const details = body['response content']['details about your wait'] as any;
   assert.ok(details.error.includes('malformed'));
   assert.equal(body['response content']['disposition of your wait'], null);
 });
 
 test('awaitTest returns "completed" for an identifier with an already-available report', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const details = body['response content']['details about your wait'] as any;
-  assert.deepEqual(details['report identifier'], {timeStamp: '260101T0000', jobID: 'mix'});
+  assert.equal(details['report identifier'], '260101T0000-mix');
   const disposition = body['response content']['disposition of your wait'] as any;
   assert.equal(disposition.outcome, 'completed');
   assert.ok(disposition['how you can check for completion'].includes('listIssues'));
 });
 
 test('awaitTest returns an error for an identifier naming neither a report nor a pending job', async () => {
-  const body = await response(['260101T0000', 'zzz']);
+  const body = await response(['260101T0000-zzz']);
   const details = body['response content']['details about your wait'] as any;
   assert.ok(details.error.includes('no report'));
   assert.equal(body['response content']['disposition of your wait'], null);
@@ -71,7 +71,7 @@ test('awaitTest returns "failed" when the job has moved to the failed directory'
   await fs.mkdir(path.dirname(failedPath), {recursive: true});
   await fs.writeFile(failedPath, JSON.stringify({target: {what: 'Failed Page', url: 'https://example.com/failed'}}));
   try {
-    const body = await response(['260101T4444', 'flj']);
+    const body = await response(['260101T4444-flj']);
     const disposition = body['response content']['disposition of your wait'] as any;
     assert.equal(disposition.outcome, 'failed');
     assert.equal(disposition['how you can check for completion'], 'Not applicable.');
@@ -85,7 +85,7 @@ test('awaitTest returns "timedOut" when a claimed job neither completes nor fail
   const claimedPath = path.join(fixtureDBDir, 'jobs', 'claimed', '260101T5555-toj.json');
   await fs.writeFile(claimedPath, JSON.stringify({target: {what: 'Stuck Page', url: 'https://example.com/stuck'}}));
   try {
-    const body = await response(['260101T5555', 'toj']);
+    const body = await response(['260101T5555-toj']);
     const disposition = body['response content']['disposition of your wait'] as any;
     assert.equal(disposition.outcome, 'timedOut');
     assert.ok(disposition['how you can check for completion'].includes('listIssues'));
@@ -96,14 +96,14 @@ test('awaitTest returns "timedOut" when a claimed job neither completes nor fail
 });
 
 test('awaitTest response has no web UI equivalents for this request or its ancestors', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const similarWeb = body['URLs of similar requests for web users'] as any;
   assert.equal(similarWeb['this request'], null);
   assert.equal(similarWeb['closest ancestor request'], null);
 });
 
 test('awaitTest reports both orderNewTest and orderRetest as possible ancestors', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const ancestors = (body['this request'] as any)['closest ancestor request'];
   assert.equal(ancestors.length, 2);
   const names = ancestors.map((a: any) => a['tool name']).sort();

package/api/awaitTest.ts

@@ -7,7 +7,7 @@
 
 import {z} from 'zod';
 import {getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
-import {awaitJob, isJobID, isTimeStamp} from '../util.ts';
+import {awaitJob, isReportID} from '../util.ts';
 import {awaitTestResponseSchema} from './schemas.ts';
 
 // TYPES
@@ -19,35 +19,35 @@ type ResponseContent = z.infer<typeof awaitTestResponseSchema>['response content
 
 // Returns the response body.
 export const response = async (args: string[]) => {
-  const [timeStamp = '', jobID = ''] = args;
+  const [reportID = ''] = args;
   const thisHost = getThisHost();
   // Initialize the response-content properties.
   let requestDetails: ResponseContent['details about your wait'];
   let requestDisposition: ResponseContent['disposition of your wait'] = null;
-  // If the timestamp or job ID is not syntactically valid:
-  if (!isTimeStamp(timeStamp) || !isJobID(jobID)) {
+  // If the report identifier is not syntactically valid:
+  if (!isReportID(reportID)) {
     requestDetails = {
-      error: 'wait invalid: the report timeStamp or jobID is malformed'
+      error: 'wait invalid: the reportID is malformed'
     };
   }
   // Otherwise, i.e. if the identifier is syntactically valid:
   else {
     requestDetails = {
-      'report identifier': {timeStamp, jobID}
+      'report identifier': reportID
     };
     // Wait for the job to complete, fail, or time out. No progress notices are sent
     // during this wait; the caller receives only this one, final response.
-    const outcome = await awaitJob(timeStamp, jobID);
+    const outcome = await awaitJob(reportID);
     if (outcome === 'notFound') {
       requestDetails = {
-        error: `wait invalid: no report with timeStamp "${timeStamp}" and jobID "${jobID}" is completed, pending, or in progress`
+        error: `wait invalid: no report with identifier "${reportID}" is completed, pending, or in progress`
       };
     }
     else if (outcome === 'completed') {
       requestDisposition = {
         outcome: 'completed',
         'what happened': 'The report is ready.',
-        'how you can check for completion': `Call the listIssues tool with timeStamp "${timeStamp}" and jobID "${jobID}" to retrieve the report.`
+        'how you can check for completion': `Call the listIssues tool with reportID "${reportID}" to retrieve the report.`
       };
     }
     else if (outcome === 'failed') {
@@ -61,7 +61,7 @@ export const response = async (args: string[]) => {
       requestDisposition = {
         outcome: 'timedOut',
         'what happened': 'The job was not completed within the maximum wait time, but it may still be running.',
-        'how you can check for completion': `Call the listIssues tool with timeStamp "${timeStamp}" and jobID "${jobID}" after a few minutes to check whether the report is ready.`
+        'how you can check for completion': `Call the listIssues tool with reportID "${reportID}" after a few minutes to check whether the report is ready.`
       };
     }
   }
@@ -75,9 +75,9 @@ export const response = async (args: string[]) => {
     'tool collection': getToolsFacts(),
     'tool name': 'awaitTest',
     'this request': {
-      description: 'Wait for a job ordered via the orderNewTest or orderRetest tool to complete. The timeStamp and jobID parameters are the report identifier that orderNewTest or orderRetest returned. This call blocks until the report is ready, the job fails, or a maximum wait time elapses.',
+      description: 'Wait for a job ordered via the orderNewTest or orderRetest tool to complete. The reportID parameter is the report identifier that orderNewTest or orderRetest returned. This call blocks until the report is ready, the job fails, or a maximum wait time elapses.',
       method: 'POST',
-      URL: `${thisHost}/api/awaitTest/${timeStamp}/${jobID}`,
+      URL: `${thisHost}/api/awaitTest/${reportID}`,
       // awaitTest's own parameters do not say whether the job was ordered via orderNewTest
       // or orderRetest, so both are reported as possible ancestors, rather than
       // arbitrarily naming just one.

package/api/getReport.test.ts

@@ -29,7 +29,7 @@ after(() => {
 // TESTS
 
 test('getReport returns the full report for a valid report', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const content = body['response content'];
   assert.equal(typeof content['size of the report in bytes'], 'number');
   assert.ok((content['size of the report in bytes'] as number) > 0);
@@ -41,21 +41,21 @@ test('getReport returns the full report for a valid report', async () => {
 });
 
 test('getReport returns an error for a nonexistent report', async () => {
-  const body = await response(['999999T9999', 'xyz']);
+  const body = await response(['999999T9999-xyz']);
   const content = body['response content'];
   assert.equal(content['full report'], null);
   assert.equal(typeof content['size of the report in bytes'], 'string');
 });
 
 test('getReport returns an error for the hidden report', async () => {
-  const body = await response(['260101T0007', 'hid']);
+  const body = await response(['260101T0007-hid']);
   const content = body['response content'];
   assert.equal(content['full report'], null);
   assert.equal(typeof content['size of the report in bytes'], 'string');
 });
 
 test('getReport includes tool name and metadata', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   assert.equal(body['tool name'], 'getReport');
   assert.ok(body['response metadata'].identifier);
 });

package/api/getReport.ts

@@ -23,18 +23,18 @@ type ResponseContent = z.infer<typeof getReportResponseSchema>['response content
 
 // Returns the response body.
 export const response = async (args: string[]) => {
-  const [timeStamp = '', jobID = ''] = args;
+  const [reportID = ''] = args;
   const thisHost = getThisHost();
-  // Get the report size. A malformed timestamp or job ID resolves to a nonexistent file
+  // Get the report size. A malformed report identifier resolves to a nonexistent file
   // path, which getReportStats already reports as unavailable, so no separate syntactic
   // check is needed here.
-  const reportStats = await getReportStats(timeStamp, jobID);
+  const reportStats = await getReportStats(reportID);
   // Create the response content.
   const responseContent: ResponseContent = reportStats
   ? {
     'size of the report in bytes': reportStats.reportSize,
     // Get the report (which may be only an error message).
-    'full report': await getReport(timeStamp, jobID)
+    'full report': await getReport(reportID)
   }
   : {
     'size of the report in bytes': 'Error: The report could not be accessed for an unknown reason.',
@@ -45,19 +45,19 @@ export const response = async (args: string[]) => {
     'tool collection': getToolsFacts(),
     'tool name': 'getReport',
     'this request': {
-      description: 'Provide one full report in JSON format. The timeStamp and jobID parameters identify the report that I want details about. Those parameters were in the response to my earlier listIssues request.',
+      description: 'Provide one full report in JSON format. The reportID parameter identifies the report that I want details about. It was in the response to my earlier listIssues request.',
       method: 'GET',
-      URL: `${thisHost}/api/getReport/${timeStamp}/${jobID}`,
+      URL: `${thisHost}/api/getReport/${reportID}`,
       'closest ancestor request': {
         'tool name': 'listIssues',
         description: 'Provide details about one report, including basics about the issues reported in it.',
         method: 'GET',
-        URL: `${thisHost}/api/listIssues/${timeStamp}/${jobID}`
+        URL: `${thisHost}/api/listIssues/${reportID}`
       }
     },
     'URLs of similar requests for web users': {
-      'this request': `${thisHost}/fullReport.json/${timeStamp}/${jobID}`,
-      'closest ancestor request': `${thisHost}/listIssues.html/${timeStamp}/${jobID}`
+      'this request': `${thisHost}/fullReport.json/${reportID}`,
+      'closest ancestor request': `${thisHost}/listIssues.html/${reportID}`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/listDiagnoses.test.ts

@@ -29,7 +29,7 @@ after(() => {
 // TESTS
 
 test('listDiagnoses returns 2 diagnoses for catalogIndex 0, linkNoText, in the mixed report (axe and alfa, excluding cantTell)', async () => {
-  const body = await response(['0', 'linkNoText', '260101T0000', 'mix']);
+  const body = await response(['0', 'linkNoText', '260101T0000-mix']);
   const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'] as any;
   assert.equal(diagnoses.length, 2);
   const rules = diagnoses.map((d: any) => d['identifier of the violated rule']).sort();
@@ -39,13 +39,13 @@ test('listDiagnoses returns 2 diagnoses for catalogIndex 0, linkNoText, in the m
 });
 
 test('listDiagnoses returns 0 diagnoses when all instances are cantTell', async () => {
-  const body = await response(['0', 'focusIndicationBad', '260101T0001', 'ct']);
+  const body = await response(['0', 'focusIndicationBad', '260101T0001-ct']);
   const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'] as any;
   assert.equal(diagnoses.length, 0);
 });
 
 test('listDiagnoses treats missing outcome as a violation', async () => {
-  const body = await response(['0', 'linkNoText', '260101T0002', 'no']);
+  const body = await response(['0', 'linkNoText', '260101T0002-no']);
   const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'] as any;
   assert.equal(diagnoses.length, 1);
   assert.equal(diagnoses[0]['description of the violation'], 'Button has no accessible name');
@@ -53,7 +53,7 @@ test('listDiagnoses treats missing outcome as a violation', async () => {
 });
 
 test('listDiagnoses returns element basics from the catalog', async () => {
-  const body = await response(['0', 'linkNoText', '260101T0000', 'mix']);
+  const body = await response(['0', 'linkNoText', '260101T0000-mix']);
   const elementBasics = body['response content']['basics about the element'] as any;
   assert.equal(elementBasics.identifier, '0');
   assert.equal(elementBasics['tag name'], 'A');
@@ -61,7 +61,7 @@ test('listDiagnoses returns element basics from the catalog', async () => {
 });
 
 test('listDiagnoses returns element details from the catalog', async () => {
-  const body = await response(['0', 'linkNoText', '260101T0000', 'mix']);
+  const body = await response(['0', 'linkNoText', '260101T0000-mix']);
   const elementDetails = body['response content']['details about the element'] as any;
   assert.equal(elementDetails['start tag'], '<a>');
   assert.equal(elementDetails['XPath'], '/html/body/a[1]');
@@ -69,39 +69,39 @@ test('listDiagnoses returns element details from the catalog', async () => {
 });
 
 test('listDiagnoses returns an error for an unknown issue ID', async () => {
-  const body = await response(['0', 'nonexistentIssue', '260101T0000', 'mix']);
+  const body = await response(['0', 'nonexistentIssue', '260101T0000-mix']);
   const basics = body['response content']['basics about the issue'] as any;
   assert.ok(basics.error);
 });
 
 test('listDiagnoses returns an error for a nonexistent catalog index', async () => {
-  const body = await response(['999', 'linkNoText', '260101T0000', 'mix']);
+  const body = await response(['999', 'linkNoText', '260101T0000-mix']);
   const basics = body['response content']['basics about the element'] as any;
   assert.ok(basics.error);
 });
 
 test('listDiagnoses returns an error for a nonexistent report', async () => {
-  const body = await response(['0', 'linkNoText', '999999T9999', 'xyz']);
+  const body = await response(['0', 'linkNoText', '999999T9999-xyz']);
   const basics = body['response content']['basics about the report'] as any;
   assert.ok(basics.error);
 });
 
 test('listDiagnoses returns guideline layer for an issue with a short WCAG code', async () => {
-  const body = await response(['0', 'duplicateID', '260101T0009', 'brd']);
+  const body = await response(['0', 'duplicateID', '260101T0009-brd']);
   const issueBasics = body['response content']['basics about the issue'] as any;
   assert.equal(issueBasics['related WCAG standard'].layer, 'guideline');
   assert.equal(issueBasics['related WCAG standard'].identifier, '4.1');
 });
 
 test('listDiagnoses returns null tag name and inner text for a catalog item missing them', async () => {
-  const body = await response(['1', 'duplicateID', '260101T0009', 'brd']);
+  const body = await response(['1', 'duplicateID', '260101T0009-brd']);
   const elementBasics = body['response content']['basics about the element'] as any;
   assert.equal(elementBasics['tag name'], null);
   assert.equal(elementBasics['inner text'], null);
 });
 
 test('listDiagnoses returns null rule ID when ruleID equals what', async () => {
-  const body = await response(['0', 'duplicateID', '260101T0009', 'brd']);
+  const body = await response(['0', 'duplicateID', '260101T0009-brd']);
   const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'] as any;
   const axeDiagnosis = diagnoses.find((d: any) => d['description of the violation'] === 'r99');
   assert.ok(axeDiagnosis);
@@ -109,7 +109,7 @@ test('listDiagnoses returns null rule ID when ruleID equals what', async () => {
 });
 
 test('listDiagnoses defaults count to 1 when count is missing', async () => {
-  const body = await response(['1', 'duplicateID', '260101T0009', 'brd']);
+  const body = await response(['1', 'duplicateID', '260101T0009-brd']);
   const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'] as any;
   const ibmDiagnosis = diagnoses.find((d: any) => d['description of the violation'] === 'Element has no role');
   assert.ok(ibmDiagnosis);
@@ -117,7 +117,7 @@ test('listDiagnoses defaults count to 1 when count is missing', async () => {
 });
 
 test('listDiagnoses returns null for missing start tag, XPath, and bounding box', async () => {
-  const body = await response(['2', 'duplicateID', '260101T0009', 'brd']);
+  const body = await response(['2', 'duplicateID', '260101T0009-brd']);
   const elementDetails = body['response content']['details about the element'] as any;
   assert.equal(elementDetails['start tag'], null);
   assert.equal(elementDetails['XPath'], null);
@@ -125,7 +125,7 @@ test('listDiagnoses returns null for missing start tag, XPath, and bounding box'
 });
 
 test('listDiagnoses returns issue error for a falsy issue ID', async () => {
-  const body = await response(['0', '', '260101T0009', 'brd']);
+  const body = await response(['0', '', '260101T0009-brd']);
   const issueBasics = body['response content']['basics about the issue'] as any;
   assert.ok(issueBasics.error);
 });

package/api/listDiagnoses.ts

@@ -27,15 +27,15 @@ type Diagnoses = Extract<ResponseContent['diagnoses of how the element exhibited
 
 // Returns the response body.
 export const response = async (args: string[]) => {
-  const [catalogIndex = '', issueID = '', timeStamp = '', jobID = ''] = args;
+  const [catalogIndex = '', issueID = '', reportID = ''] = args;
   const thisHost = getThisHost();
   // Get the report.
-  const report = await getReport(timeStamp, jobID);
+  const report = await getReport(reportID);
   // Get the specification of the issue.
   const issueSpec = issueID ? getIssueSpec(issueID) : null;
   // Initialize the response content.
   const responseContent: ResponseContent = {
-    'basics about the report': isReportError(report) ? report : await getReportBasics(timeStamp, jobID),
+    'basics about the report': isReportError(report) ? report : await getReportBasics(reportID),
     'basics about the issue': {
       'error': 'No information about the specified issue is available'
     },
@@ -115,19 +115,19 @@ export const response = async (args: string[]) => {
     'tool collection': getToolsFacts(),
     'tool name': 'listDiagnoses',
     'this request': {
-      description: 'Provide details about one element reported as exhibiting one issue in one report, including the diagnoses provided by rule engines about how the element exhibited the issue. The catalogIndex, issueID, timeStamp, and jobID parameters identify the element, issue, and report that I want details about. Those parameters were in the response to my earlier listViolators request.',
+      description: 'Provide details about one element reported as exhibiting one issue in one report, including the diagnoses provided by rule engines about how the element exhibited the issue. The catalogIndex, issueID, and reportID parameters identify the element, issue, and report that I want details about. Those parameters were in the response to my earlier listViolators request.',
       method: 'GET',
-      URL: `${thisHost}/api/listDiagnoses/${catalogIndex}/${issueID}/${timeStamp}/${jobID}`,
+      URL: `${thisHost}/api/listDiagnoses/${catalogIndex}/${issueID}/${reportID}`,
       'closest ancestor request': {
         'tool name': 'listViolators',
         description: 'Provide details about one issue in one report, including basics about the elements of the tested page that were reported as exhibiting the issue.',
         method: 'GET',
-        URL: `${thisHost}/api/listViolators/${issueID}/${timeStamp}/${jobID}`
+        URL: `${thisHost}/api/listViolators/${issueID}/${reportID}`
       }
     },
     'URLs of similar requests for web users': {
-      'this request': `${thisHost}/listDiagnoses.html/${issueID}/${timeStamp}/${jobID}/${catalogIndex}`,
-      'closest ancestor request': `${thisHost}/listViolators.html/${issueID}/${timeStamp}/${jobID}`
+      'this request': `${thisHost}/listDiagnoses.html/${issueID}/${reportID}/${catalogIndex}`,
+      'closest ancestor request': `${thisHost}/listViolators.html/${issueID}/${reportID}`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/listIssues.test.ts

@@ -29,7 +29,7 @@ after(() => {
 // TESTS
 
 test('listIssues returns 2 issues for the mixed-outcomes report, excluding cantTell', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const issues = body['response content']['basics about all issues reported in the report'];
   assert.ok(issues);
   assert.equal(issues.length, 2);
@@ -38,14 +38,14 @@ test('listIssues returns 2 issues for the mixed-outcomes report, excluding cantT
 });
 
 test('listIssues returns 0 issues for the all-cantTell report', async () => {
-  const body = await response(['260101T0001', 'ct']);
+  const body = await response(['260101T0001-ct']);
   const issues = body['response content']['basics about all issues reported in the report'];
   assert.ok(issues);
   assert.equal(issues.length, 0);
 });
 
 test('listIssues treats missing outcome as a violation, not cantTell', async () => {
-  const body = await response(['260101T0002', 'no']);
+  const body = await response(['260101T0002-no']);
   const issues = body['response content']['basics about all issues reported in the report'];
   assert.ok(issues);
   assert.equal(issues.length, 1);
@@ -53,14 +53,14 @@ test('listIssues treats missing outcome as a violation, not cantTell', async ()
 });
 
 test('listIssues returns 0 issues for the empty report', async () => {
-  const body = await response(['260101T0005', 'emp']);
+  const body = await response(['260101T0005-emp']);
   const issues = body['response content']['basics about all issues reported in the report'];
   assert.ok(issues);
   assert.equal(issues.length, 0);
 });
 
 test('listIssues reports prevented rule engines for the prevented report', async () => {
-  const body = await response(['260101T0006', 'prv']);
+  const body = await response(['260101T0006-prv']);
   const details = body['response content']['details about the report'] as any;
   const preventions = details['test results']['rule engines that could not test the page'];
   assert.equal(preventions.length, 1);
@@ -69,7 +69,7 @@ test('listIssues reports prevented rule engines for the prevented report', async
 });
 
 test('listIssues includes reporter names for each issue in the mixed report', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const issues = body['response content']['basics about all issues reported in the report'];
   assert.ok(issues);
   const linkIssue = issues.find(i => i.identifier === 'linkNoText');
@@ -81,7 +81,7 @@ test('listIssues includes reporter names for each issue in the mixed report', as
 });
 
 test('listIssues counts issues by priority correctly for the mixed report', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const details = body['response content']['details about the report'] as any;
   const counts = details['test results']['counts of issues by priority'];
   // linkNoText weight 4 (highest), allCaps weight 1 (lowest).
@@ -92,19 +92,19 @@ test('listIssues counts issues by priority correctly for the mixed report', asyn
 });
 
 test('listIssues reports the superseded status for the mixed report', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const basics = body['response content']['basics about the report'] as any;
   assert.equal(basics['whether a later report about the same page exists'], true);
 });
 
 test('listIssues returns an error for a nonexistent report', async () => {
-  const body = await response(['999999T9999', 'xyz']);
+  const body = await response(['999999T9999-xyz']);
   const basics = body['response content']['basics about the report'] as any;
   assert.ok(basics.error);
 });
 
 test('listIssues handles instances with missing issueID and null instances without error', async () => {
-  const body = await response(['260101T0009', 'brd']);
+  const body = await response(['260101T0009-brd']);
   const issues = body['response content']['basics about all issues reported in the report'];
   // The brd fixture has one instance with duplicateID (a valid issue) and one with no issueID (skipped).
   // The alfa act has no instances array, so it should be handled as empty.
@@ -115,7 +115,7 @@ test('listIssues handles instances with missing issueID and null instances witho
 });
 
 test('listIssues lists the history of reports about the page, from oldest to latest', async () => {
-  const body = await response(['260101T0000', 'mix']);
+  const body = await response(['260101T0000-mix']);
   const history = body['response content']['history of reports about the page']!;
   assert.deepEqual(history.map(entry => entry.identifier), ['260101T0000-mix', '260202T0000-new']);
   assert.deepEqual(
@@ -128,12 +128,12 @@ test('listIssues lists the history of reports about the page, from oldest to lat
   );
   assert.equal(history[1]!['completion date and time'], '2026-02-02T00:10:00.000Z');
   assert.equal(typeof history[1]!['days since the report was completed'], 'number');
-  assert.ok(history[1]!['how to get details about the report'].URL.endsWith('/api/listIssues/260202T0000/new'));
-  assert.ok(history[1]!['web users can get details about the report at'].endsWith('/listIssues.html/260202T0000/new'));
+  assert.ok(history[1]!['how to get details about the report'].URL.endsWith('/api/listIssues/260202T0000-new'));
+  assert.ok(history[1]!['web users can get details about the report at'].endsWith('/listIssues.html/260202T0000-new'));
 });
 
 test('listIssues gives a one-report history for the only report about a page', async () => {
-  const body = await response(['260101T0001', 'ct']);
+  const body = await response(['260101T0001-ct']);
   const history = body['response content']['history of reports about the page']!;
   assert.equal(history.length, 1);
   assert.equal(history[0]!['whether it is the oldest report about the page'], true);
@@ -142,6 +142,6 @@ test('listIssues gives a one-report history for the only report about a page', a
 });
 
 test('listIssues gives no history for a nonexistent report', async () => {
-  const body = await response(['999999T9999', 'xyz']);
+  const body = await response(['999999T9999-xyz']);
   assert.equal(body['response content']['history of reports about the page'], null);
 });