@jrpool/kilotest 60.9.1 → 61.0.0

package/api/listPages.test.ts

@@ -31,7 +31,7 @@ after(() => {
 test('listPages returns one entry per tested page, sorted by page description', async () => {
   const body = await response();
   const pagesBasics = body['response content']['basics about all tested pages'];
-  const descriptions = pagesBasics.map(b => b['tested web page'].description);
+  const descriptions = pagesBasics.map(b => b.description);
   assert.deepEqual(
     descriptions,
     [
@@ -49,31 +49,32 @@ test('listPages returns one entry per tested page, sorted by page description',
 test('listPages does not include the page of the hidden report', async () => {
   const body = await response();
   const pagesBasics = body['response content']['basics about all tested pages'];
-  const ids = pagesBasics.map(b => b['basics about the latest report'].identifier);
+  const ids = pagesBasics.map(b => b.identifier);
   assert.ok(!ids.includes('260101T0007-hid'), 'hidden report must not appear in listPages');
 });
 
-test('listPages describes a multi-report page by its latest report and its report count', async () => {
+test('listPages identifies a multi-report page by its latest report', async () => {
   const body = await response();
   const pagesBasics = body['response content']['basics about all tested pages'];
-  const mixed = pagesBasics.find(b => b['tested web page'].description === 'Mixed Outcomes')!;
-  assert.equal(mixed['number of reports about the page'], 2);
-  const latest = mixed['basics about the latest report'];
-  assert.equal(latest.identifier, '260202T0000-new');
-  assert.equal(latest['completion date and time'], '2026-02-02T00:10:00.000Z');
-  assert.equal(typeof latest['days since the report was completed'], 'number');
-  assert.equal(mixed['how to get details about the latest report'].method, 'GET');
-  assert.ok(mixed['how to get details about the latest report'].URL.endsWith('/api/listIssues/260202T0000-new'));
-  assert.ok(mixed['web users can get details about the latest report at'].endsWith('/listIssues.html/260202T0000-new'));
+  const mixed = pagesBasics.find(b => b.description === 'Mixed Outcomes')!;
+  assert.equal(mixed.identifier, '260202T0000-new');
+  assert.equal(mixed.URL, 'https://example.com/mixed');
 });
 
 test('listPages describes a single-report page', async () => {
   const body = await response();
   const pagesBasics = body['response content']['basics about all tested pages'];
-  const canttell = pagesBasics.find(b => b['tested web page'].description === 'All CantTell Page')!;
-  assert.equal(canttell['number of reports about the page'], 1);
-  assert.equal(canttell['tested web page'].URL, 'https://example.com/canttell');
-  assert.equal(canttell['basics about the latest report'].identifier, '260101T0001-ct');
+  const canttell = pagesBasics.find(b => b.description === 'All CantTell Page')!;
+  assert.equal(canttell.URL, 'https://example.com/canttell');
+  assert.equal(canttell.identifier, '260101T0001-ct');
+});
+
+test('listPages includes result-retrieval instructions with an identifier placeholder', async () => {
+  const body = await response();
+  const content = body['response content'];
+  assert.equal(content['how to get test results about a page'].method, 'GET');
+  assert.ok(content['how to get test results about a page'].URL.endsWith('/api/listIssues/{identifier}'));
+  assert.ok(content['web users can get test results about a page at'].endsWith('/listIssues.html/{identifier}'));
 });
 
 test('listPages includes request-test instructions', async () => {

package/api/listPages.ts

@@ -7,7 +7,7 @@
 
 import {z} from 'zod';
 import {getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
-import {getAgoDays, getReportExtracts} from '../util.ts';
+import {getReportExtracts} from '../util.ts';
 import {listPagesResponseSchema} from './schemas.ts';
 
 // TYPES
@@ -20,42 +20,20 @@ type ResponseContent = z.infer<typeof listPagesResponseSchema>['response content
 // Returns the response body.
 export const response = async () => {
   const thisHost = getThisHost();
-  // Get extracts of all available reports, sorted by page description and completion time.
-  const reportExtracts = await getReportExtracts();
-  // Get the number of reports about each page.
-  const reportCounts = new Map<string, number>();
-  reportExtracts.forEach(({description}) => {
-    reportCounts.set(description, (reportCounts.get(description) ?? 0) + 1);
-  });
-  // Initialize an array of basics about the pages.
-  const pagesBasics: ResponseContent['basics about all tested pages'] = [];
-  // For each report:
-  reportExtracts.forEach(extract => {
-    const {description, id, reportTime, superseded, url} = extract;
-    // If it is the latest report about its page:
-    if (!superseded) {
-      // Add basics about the page, with instructions for getting details, to the array.
-      pagesBasics.push({
-        'tested web page': {
-          description,
-          URL: url
-        },
-        'number of reports about the page': reportCounts.get(description)!,
-        'basics about the latest report': {
-          identifier: id,
-          'completion date and time': reportTime,
-          'days since the report was completed': getAgoDays(new Date(reportTime))
-        },
-        'how to get details about the latest report': {
-          method: 'GET',
-          URL: `${thisHost}/api/listIssues/${id}`
-        },
-        'web users can get details about the latest report at': `${thisHost}/listIssues.html/${id}`
-      });
-    }
-  });
+  // Get extracts of the latest reports about all tested pages, sorted by page description.
+  const reportExtracts = await getReportExtracts(true);
+  // Get the basics about each tested page: its description, URL, and the identifier of
+  // its latest report, which the result-retrieval instructions below use as a placeholder.
+  const pagesBasics: ResponseContent['basics about all tested pages'] = reportExtracts.map(
+    ({description, id, url}) => ({description, URL: url, identifier: id})
+  );
   // Create the response content.
   const responseContent: ResponseContent = {
+    'how to get test results about a page': {
+      method: 'GET',
+      URL: `${thisHost}/api/listIssues/{identifier}`
+    },
+    'web users can get test results about a page at': `${thisHost}/listIssues.html/{identifier}`,
     'basics about all tested pages': pagesBasics,
     'how to request that a page with no report be tested': {
       method: 'POST',

package/api/schemas.ts

@@ -195,12 +195,15 @@ const reportTimeSchema = z.object({
 });
 
 export const listPagesResponseSchema = envelope('GET', z.object({
+  'how to get test results about a page': z.object({
+    method: z.literal('GET'),
+    URL: z.string().describe('URL template; replace {identifier} with the identifier of the latest report about the page.')
+  }),
+  'web users can get test results about a page at': z.string().describe('URL template; replace {identifier} with the identifier of the latest report about the page.'),
   'basics about all tested pages': z.array(z.object({
-    'tested web page': z.object({description: z.string(), URL: z.string()}),
-    'number of reports about the page': z.number(),
-    'basics about the latest report': reportTimeSchema,
-    'how to get details about the latest report': z.object({method: z.literal('GET'), URL: z.string()}),
-    'web users can get details about the latest report at': z.string()
+    description: z.string(),
+    URL: z.string(),
+    identifier: z.string().describe('Identifier of the latest report about the page (example: 260503T0432-x9z).')
   })),
   'how to request that a page with no report be tested': z.object({
     method: z.literal('POST'),

package/api/util.ts

@@ -51,18 +51,20 @@ export const getResponseMetadata = () => ({
 export const getToolsFacts = () => ({
   'name': 'Kilotest',
   'description': {
-    'what Kilotest does': 'Kilotest tools generate and make available findings about the front-end quality (i.e. accessibility, usability, and web standards, including HTML, CSS, ARIA, and WCAG) of web pages. A Kilotest job generates findings by using Testaro to test a page against about 1300 rules defined by an ensemble of twelve rule engines. Testaro produces a report of the job. The report describes violations of the rules. Kilotest uses Testilo to enhance the report with a classification of the rule violations into about 380 issues. Kilotest makes facts about the tested pages, the issues, and the violations retrievable at four levels of granularity.',
+    'what Kilotest does': 'Kilotest tools generate findings about the front-end quality (i.e. accessibility, usability, and web standards, including HTML, CSS, ARIA, and WCAG of W3C) of web pages. A Kilotest job generates findings by using Testaro to test a page against about 1300 rules defined by an ensemble of twelve rule engines. Testaro produces a report of the job. The report describes violations of the rules. Kilotest uses Testilo to enhance the report with a classification of the rule violations into about 380 issues and then saves the report for public retrieval. Kilotest makes facts about the tested pages, the issues, and the violations retrievable at four levels of granularity.',
     'how to retrieve findings': {
-      'level 1': 'Use the listPages tool to get a list of tested pages, each with its latest report. The listIssues output about any report lists all reports about the same page.',
-      'level 2': 'Use the listIssues tool to get a list of issues in one report.',
-      'level 3': 'Use the listViolators tool to get a list of elements on one page that were reported in one report as exhibiting one issue.',
+      'level 1': 'Use the listPages tool to get a list of tested pages, each with the identifier of its latest report, for use with the listIssues tool.',
+      'level 2': 'Use the listIssues tool to get a list of issues in one report, each with a link to the level-3 results for that issue. The response also includes a history of reports about the page, each with a link to its own level-2 results.',
+      'level 3': 'Use the listViolators tool to get a list of elements on one page that were reported in one report as exhibiting one issue, each with a link to the level-4 results for that violator.',
       'level 4': 'Use the listDiagnoses tool to get a list of diagnoses of how one element on one page exhibited one issue in one report.',
     },
     'how to generate more findings': {
-      'new testing': 'If no report is available yet about a page, use the requestNewTest tool to request that it be tested.',
-      'retesting': 'If the listIssues tool shows that the latest report about a page is obsolete, because the page has been revised or for another reason, use the requestRetest tool to request that the page be retested.',
-      'latency': 'Requests for testing and retesting are usually approved and fulfilled within one day.',
-      'confirmation': 'Use the listPages tool to determine whether a requested new report exists. There is currently no process for notification of the outcome of requests.'
+      'new testing': 'If no report is available yet about a page, use the requestNewTest tool to request that it be tested, or the orderNewTest tool for immediate testing.',
+      'retesting': 'If you believe that the latest report about a page is obsolete (e.g., because the page has been revised), use the requestRetest tool to request that the page be retested, or the orderRetest tool for immediate retesting.',
+      'approval': 'Requests are manager-reviewed, usually in 1 hour to one day. Orders are automatically reviewed. Reviews result in approval or rejection.',
+      'latency': 'An approved test typically finishes in 2 to 4 minutes.',
+      'request confirmation': 'After submitting a request and waiting for manager review, you can use the listPages tool to determine whether the request has been fulfilled: a new-test request adds a page entry linking to its results, and a retest request adds a later report about the page.',
+      'order confirmation': 'After ordering a test or retest, you will receive a rejection or a report identifier, which you can use to call the awaitTest tool. That tool blocks until the test completes, fails, or a maximum wait time elapses, and then returns the outcome. If you do not call awaitTest, you can wait 2 to 4 minutes and then, if the test is complete, the listIssues tool called with the report identifier will succeed.'
     }
   },
   'URL': `${getThisHost()}/mcp`,

package/index.test.ts

@@ -981,12 +981,12 @@ test('GET /qai/comments redirects to /tutorialAI.html', async () => {
   assert.equal(res.headers['location'], '/tutorialAI.html');
 });
 
-test('GET /diagnoses.html/<segments> redirects to the equivalent /listDiagnoses.html/<segments>, preserving the query string', async () => {
+test('GET /diagnoses.html/<issueID>/<timeStamp>/<jobID>/<catalogIndex> with a query string redirects in one step to the canonical /listDiagnoses.html URL', async () => {
   const res = await request(
-    'GET', '/diagnoses.html/duplicateID/260426T1741-77w/718?pathID=/html/body', {}, {followRedirects: false}
+    'GET', '/diagnoses.html/linkNoText/260101T0000/mix/0?pathID=/html/body', {}, {followRedirects: false}
   );
   assert.equal(res.statusCode, 301);
-  assert.equal(res.headers['location'], '/listDiagnoses.html/duplicateID/260426T1741-77w/718?pathID=/html/body');
+  assert.equal(res.headers['location'], '/listDiagnoses.html/linkNoText/260101T0000-mix/0');
 });
 
 test('GET /reportIssues.html/<reportID> redirects to the equivalent /listIssues.html/<reportID>', async () => {
@@ -1015,12 +1015,12 @@ test('GET /listViolators.html/<issueID>/<timeStamp>/<jobID> redirects to the sin
   assert.equal(res.headers['location'], '/listViolators.html/linkNoText/260101T0000-mix');
 });
 
-test('GET /listDiagnoses.html/<issueID>/<timeStamp>/<jobID>/<catalogIndex> redirects to the single-reportID URL, preserving the query string', async () => {
+test('GET /listDiagnoses.html/<issueID>/<timeStamp>/<jobID>/<catalogIndex> with a query string redirects in one step to the canonical single-reportID URL', async () => {
   const res = await request(
     'GET', '/listDiagnoses.html/linkNoText/260101T0000/mix/0?pathID=/html/body', {}, {followRedirects: false}
   );
   assert.equal(res.statusCode, 301);
-  assert.equal(res.headers['location'], '/listDiagnoses.html/linkNoText/260101T0000-mix/0?pathID=/html/body');
+  assert.equal(res.headers['location'], '/listDiagnoses.html/linkNoText/260101T0000-mix/0');
 });
 
 test('GET /requestRetestForm.html/<timeStamp>/<jobID> redirects to the single-reportID URL', async () => {
@@ -1077,6 +1077,33 @@ test('GET /api/listReports redirects to /api/listPages', async () => {
   assert.equal(res.headers['location'], '/api/listPages');
 });
 
+// TESTS: query-string canonicalization
+// No GET page handler reads the query string, so a request with a query returns a
+// duplicate of the queryless page. These verify that such requests permanently
+// redirect to the queryless URL.
+
+test('GET /listDiagnoses.html/<segments> with a query string redirects to the queryless URL', async () => {
+  const res = await request(
+    'GET', '/listDiagnoses.html/linkNoText/260101T0000-mix/0?pathID=/html/body', {}, {followRedirects: false}
+  );
+  assert.equal(res.statusCode, 301);
+  assert.equal(res.headers['location'], '/listDiagnoses.html/linkNoText/260101T0000-mix/0');
+});
+
+test('GET /listIssues.html/<reportID> with a query string redirects to the queryless URL', async () => {
+  const res = await request(
+    'GET', '/listIssues.html/260101T0000-mix?foo=bar', {}, {followRedirects: false}
+  );
+  assert.equal(res.statusCode, 301);
+  assert.equal(res.headers['location'], '/listIssues.html/260101T0000-mix');
+});
+
+test('GET / with a query string redirects to /', async () => {
+  const res = await request('GET', '/?utm_source=example', {}, {followRedirects: false});
+  assert.equal(res.statusCode, 301);
+  assert.equal(res.headers['location'], '/');
+});
+
 test('GET /requestTest.html redirects to /requestNewTest.html', async () => {
   const res = await request('GET', '/requestTest.html', {}, {followRedirects: false});
   assert.equal(res.statusCode, 301);
@@ -1647,12 +1674,15 @@ test('POST /metrics.html with a valid authCode sets a metrics-exclusion cookie',
   assert.ok(setCookie.includes('HttpOnly'));
 });
 
-test('GET /metrics.html with a valid authCode in the query string does not set a cookie or show the counts', async () => {
+test('GET /metrics.html with a valid authCode in the query string redirects to the queryless URL, which does not set a cookie or show the counts', async () => {
   const res = await request('GET', '/metrics.html?authCode=test-auth-code');
-  assert.equal(res.statusCode, 200);
-  assert.equal(res.headers['set-cookie'], undefined);
-  assert.ok(res.body.includes('Authorization code'));
-  assert.ok(!res.body.includes('Web page views'));
+  assert.equal(res.statusCode, 301);
+  assert.equal(res.headers['location'], '/metrics.html');
+  const redirected = await request('GET', res.headers['location']);
+  assert.equal(redirected.statusCode, 200);
+  assert.equal(redirected.headers['set-cookie'], undefined);
+  assert.ok(redirected.body.includes('Authorization code'));
+  assert.ok(!redirected.body.includes('Web page views'));
 });
 
 test('a request carrying the metrics-exclusion cookie does not record a pageViews or apiOperations metric', async () => {

package/index.ts

@@ -347,9 +347,10 @@ export const isPathAllowed = (method: string, pathname: string): boolean => {
   const patterns = (routes as Record<string, string[]>)[method] || [];
   return patterns.some(pattern => matchPath(pattern, pathname));
 };
-// Returns the single-reportID URL that a legacy two-segment report URL (one whose
-// path tail identifies a report with separate timeStamp and jobID segments)
-// redirects to, or null if the page has no legacy form or the tail lacks its shape.
+// Returns the single-reportID path that a legacy two-segment report path tail (one
+// identifying a report with separate timeStamp and jobID segments) canonicalizes to
+// for a page under its current name, or null if the page has no legacy form or the
+// tail lacks its shape.
 const getLegacyReportURL = (topic: string, pathTail: string): string | null => {
   const legacy = legacyReportTails[topic];
   if (!legacy) {
@@ -681,12 +682,21 @@ const handleRequest = async (request: IncomingMessage, response: ServerResponse)
     }
     // Otherwise, if it is for the home page:
     else if (['/', '/index.html'].includes(pathname)) {
-      await recordPageMetric('pageViews', 'index');
-      // Get the home page.
-      const {answerPage} = await home();
-      // Serve it.
-      setHeaders('text/html', '/index.html', 'medium');
-      response.end(answerPage);
+      // If the URL has a query string, redirect the request permanently to the
+      // queryless URL (see the same redirect for .html pages below).
+      if (search) {
+        response.writeHead(301, {Location: pathname});
+        response.end();
+      }
+      // Otherwise, i.e. if the URL has no query string:
+      else {
+        await recordPageMetric('pageViews', 'index');
+        // Get the home page.
+        const {answerPage} = await home();
+        // Serve it.
+        setHeaders('text/html', '/index.html', 'medium');
+        response.end(answerPage);
+      }
     }
     // Otherwise, if it is for the crawler specification:
     else if (pageName === 'robots.txt') {
@@ -766,18 +776,15 @@ const handleRequest = async (request: IncomingMessage, response: ServerResponse)
         // If this failed:
         if (isReportError(report)) {
           // This is not necessarily abuse: the link may have been generated (e.g. by
-          // listIssues.html) before the report was pruned or rewound, or the stored report
-          // may have become unreadable or unusable, none of which is the requester's fault.
-          // So tell the requester only that the request was invalid, without accusing them,
-          // but alert a manager with the real reason, since a syntactically valid report ID
-          // should otherwise always be usable.
+          // listIssues.html) before the report was pruned or rewound, or the identifier
+          // may have been scraped from the API documentation's examples, none of which
+          // is the requester's fault. So tell the requester only that the request was
+          // invalid, without accusing them. No manager alert is sent: a missing report
+          // is a routine miss, and a report that exists but is unreadable or unusable
+          // has already been quarantined and alerted on by getReport.
           console.error(
             `Full report ${pathTail} requested but unavailable (${report.error})`
           );
-          await sendAlert(
-            'Kilotest: requested full report unavailable',
-            `Full report ${pathTail} was requested but could not be retrieved: ${report.error}`
-          );
           await serveError({message: 'ERROR: Invalid request'}, response, true);
         }
         // Otherwise, i.e. if it succeeded:
@@ -800,20 +807,24 @@ const handleRequest = async (request: IncomingMessage, response: ServerResponse)
     // Otherwise, if it is for an HTML page other than the home page:
     else if (pageName.endsWith('.html')) {
       const topic = pageName.slice(0, -5);
-      const legacyReportURL = getLegacyReportURL(topic, pathTail);
-      // If it is for a page's old, pre-rename name:
-      if (renamedPagePrefixes[topic]) {
-        // Redirect the client permanently to the current page name, preserving any
-        // further path segments and the query string.
-        const newLocation = `/${renamedPagePrefixes[topic]}.html${pathTail ? `/${pathTail}` : ''}${search}`;
-        response.writeHead(301, {Location: newLocation});
-        response.end();
-      }
-      // Otherwise, if the URL identifies a report with the legacy two-segment form
-      // (a timeStamp segment and a jobID segment), redirect the request permanently
-      // to the URL with the single reportID segment, preserving the query string.
-      else if (legacyReportURL !== null) {
-        response.writeHead(301, {Location: `${legacyReportURL}${search}`});
+      // Compute the path in the current request signature: the current name if the
+      // page name is a pre-rename one, and the single-reportID tail if the tail
+      // identifies a report with the legacy two-segment form (a timeStamp segment
+      // and a jobID segment).
+      const canonicalTopic = renamedPagePrefixes[topic] ?? topic;
+      const canonicalPath = getLegacyReportURL(canonicalTopic, pathTail) ??
+        `/${canonicalTopic}.html${pathTail ? `/${pathTail}` : ''}`;
+      // If the request signature contains any obsolete element (a pre-rename page
+      // name, a legacy two-segment report tail, or a query string, which no GET
+      // page handler reads, since the search argument passed to answer() is
+      // consumed only for POST requests, where it is reconstructed from the
+      // request body), convert all of them at once by redirecting the request
+      // permanently to the canonical path with no query string. A request with a
+      // query otherwise returns a byte-identical duplicate of the queryless page,
+      // which search engines report as a duplicate without a user-selected
+      // canonical (e.g. the pathID queries still requested on listDiagnoses URLs).
+      if (canonicalPath !== pathname || search) {
+        response.writeHead(301, {Location: canonicalPath});
         response.end();
       }
       // Otherwise, if the page can be generated and is not POST-only (a POST-only path also matches

package/lhm.plugin.json

@@ -96,81 +96,48 @@
           "response content": {
             "type": "object",
             "properties": {
+              "how to get test results about a page": {
+                "type": "object",
+                "properties": {
+                  "method": {
+                    "type": "string",
+                    "const": "GET"
+                  },
+                  "URL": {
+                    "type": "string",
+                    "description": "URL template; replace {identifier} with the identifier of the latest report about the page."
+                  }
+                },
+                "required": [
+                  "method",
+                  "URL"
+                ],
+                "additionalProperties": false
+              },
+              "web users can get test results about a page at": {
+                "type": "string",
+                "description": "URL template; replace {identifier} with the identifier of the latest report about the page."
+              },
               "basics about all tested pages": {
                 "type": "array",
                 "items": {
                   "type": "object",
                   "properties": {
-                    "tested web page": {
-                      "type": "object",
-                      "properties": {
-                        "description": {
-                          "type": "string"
-                        },
-                        "URL": {
-                          "type": "string"
-                        }
-                      },
-                      "required": [
-                        "description",
-                        "URL"
-                      ],
-                      "additionalProperties": false
-                    },
-                    "number of reports about the page": {
-                      "type": "number"
-                    },
-                    "basics about the latest report": {
-                      "type": "object",
-                      "properties": {
-                        "identifier": {
-                          "type": "string",
-                          "description": "Identifier of the report (example: 260503T0432-x9z)."
-                        },
-                        "completion date and time": {
-                          "type": "string"
-                        },
-                        "days since the report was completed": {
-                          "type": [
-                            "number",
-                            "null"
-                          ]
-                        }
-                      },
-                      "required": [
-                        "identifier",
-                        "completion date and time",
-                        "days since the report was completed"
-                      ],
-                      "additionalProperties": false
-                    },
-                    "how to get details about the latest report": {
-                      "type": "object",
-                      "properties": {
-                        "method": {
-                          "type": "string",
-                          "const": "GET"
-                        },
-                        "URL": {
-                          "type": "string"
-                        }
-                      },
-                      "required": [
-                        "method",
-                        "URL"
-                      ],
-                      "additionalProperties": false
+                    "description": {
+                      "type": "string"
                     },
-                    "web users can get details about the latest report at": {
+                    "URL": {
                       "type": "string"
+                    },
+                    "identifier": {
+                      "type": "string",
+                      "description": "Identifier of the latest report about the page (example: 260503T0432-x9z)."
                     }
                   },
                   "required": [
-                    "tested web page",
-                    "number of reports about the page",
-                    "basics about the latest report",
-                    "how to get details about the latest report",
-                    "web users can get details about the latest report at"
+                    "description",
+                    "URL",
+                    "identifier"
                   ],
                   "additionalProperties": false
                 }
@@ -231,6 +198,8 @@
               }
             },
             "required": [
+              "how to get test results about a page",
+              "web users can get test results about a page at",
               "basics about all tested pages",
               "how to request that a page with no report be tested",
               "how a web user can request that the page be tested"
@@ -4423,5 +4392,5 @@
       }
     }
   ],
-  "version": "60.9.1"
+  "version": "61.0.0"
 }

package/llms-full.txt

@@ -74,7 +74,7 @@ Kilotest offers these tools:
 
 - `listPages`
   - method: `GET`
-  - purpose: list all tested pages, each with its latest report and its number of reports
+  - purpose: list all tested pages, each with the identifier of its latest report
   - path: `/api/listPages`
   - caveat: Cached results are likely to be stale and should not be used
 - `listIssues`
@@ -163,7 +163,7 @@ When you request a test or a retest:
   - approval followed by the requested testing
   - rejection
 - how to confirm approval
-  - check test completion by calling `listPages` and looking for the page and the completion date of its latest report in the list
+  - check test completion by calling `listPages` and looking for the page in the list
   - you advise the user to check in approximately 1 day for the test results on the Kilotest website, starting at `https://kilotest.com/listPages.html`
 
 For immediate testing without waiting for manual approval, use `orderNewTest` or `orderRetest` instead of `requestNewTest` or `requestRetest`. Each enqueues the job right away and returns a report identifier along with a question about whether to wait for completion. To wait, call `awaitTest` with that identifier; it blocks until the report is ready, the job fails, or a maximum wait time elapses. To check later instead, call `listIssues` with the same identifier.

package/openapi-3.0.yaml

@@ -2,7 +2,7 @@ openapi: 3.0.3
 info:
   title: Kilotest API
   description: 'Kilotest is an ensemble testing and reporting service for front-end web quality. It uses an ensemble of 12 rule engines to test web pages for front-end quality (accessibility, usability, and web standards, including HTML, CSS, ARIA, and WCAG). Kilotest acts as a web server for human users, an MCP server for AI platforms, and an API for programmatic access. With this API you can request that a page be tested or retested, discover available reports, incrementally retrieve facts from a report: from what reports are available, to what issues were reported in one report, to what elements violated one issue, to what diagnoses rule engines gave for one violation.'
-  version: 60.9.1
+  version: 61.0.0
   license:
     name: MIT
     url: https://github.com/jrpool/kilotest/blob/main/LICENSE
@@ -60,61 +60,39 @@ paths:
                   response content:
                     type: object
                     properties:
+                      how to get test results about a page:
+                        type: object
+                        properties:
+                          method:
+                            type: string
+                            enum:
+                              - GET
+                          URL:
+                            type: string
+                            description: URL template; replace {identifier} with the identifier of the latest report about the page.
+                        required:
+                          - method
+                          - URL
+                        additionalProperties: false
+                      web users can get test results about a page at:
+                        type: string
+                        description: URL template; replace {identifier} with the identifier of the latest report about the page.
                       basics about all tested pages:
                         type: array
                         items:
                           type: object
                           properties:
-                            tested web page:
-                              type: object
-                              properties:
-                                description:
-                                  type: string
-                                URL:
-                                  type: string
-                              required:
-                                - description
-                                - URL
-                              additionalProperties: false
-                            number of reports about the page:
-                              type: number
-                            basics about the latest report:
-                              type: object
-                              properties:
-                                identifier:
-                                  type: string
-                                  description: 'Identifier of the report (example: 260503T0432-x9z).'
-                                completion date and time:
-                                  type: string
-                                days since the report was completed:
-                                  type: number
-                                  nullable: true
-                              required:
-                                - identifier
-                                - completion date and time
-                                - days since the report was completed
-                              additionalProperties: false
-                            how to get details about the latest report:
-                              type: object
-                              properties:
-                                method:
-                                  type: string
-                                  enum:
-                                    - GET
-                                URL:
-                                  type: string
-                              required:
-                                - method
-                                - URL
-                              additionalProperties: false
-                            web users can get details about the latest report at:
+                            description:
+                              type: string
+                            URL:
                               type: string
+                            identifier:
+                              type: string
+                              description: 'Identifier of the latest report about the page (example: 260503T0432-x9z).'
                           required:
-                            - tested web page
-                            - number of reports about the page
-                            - basics about the latest report
-                            - how to get details about the latest report
-                            - web users can get details about the latest report at
+                            - description
+                            - URL
+                            - identifier
                           additionalProperties: false
                       how to request that a page with no report be tested:
                         type: object
@@ -156,6 +134,8 @@ paths:
                           - URL
                         additionalProperties: false
                     required:
+                      - how to get test results about a page
+                      - web users can get test results about a page at
                       - basics about all tested pages
                       - how to request that a page with no report be tested
                       - how a web user can request that the page be tested

package/openapi.yaml

@@ -2,7 +2,7 @@ openapi: 3.1.0
 info:
   title: Kilotest API
   description: 'Kilotest is an ensemble testing and reporting service for front-end web quality. It uses an ensemble of 12 rule engines to test web pages for front-end quality (accessibility, usability, and web standards, including HTML, CSS, ARIA, and WCAG). Kilotest acts as a web server for human users, an MCP server for AI platforms, and an API for programmatic access. With this API you can request that a page be tested or retested, discover available reports, incrementally retrieve facts from a report: from what reports are available, to what issues were reported in one report, to what elements violated one issue, to what diagnoses rule engines gave for one violation.'
-  version: 60.9.1
+  version: 61.0.0
   license:
     name: MIT
     identifier: MIT
@@ -58,61 +58,38 @@ paths:
                   response content:
                     type: object
                     properties:
+                      how to get test results about a page:
+                        type: object
+                        properties:
+                          method:
+                            type: string
+                            const: GET
+                          URL:
+                            type: string
+                            description: URL template; replace {identifier} with the identifier of the latest report about the page.
+                        required:
+                          - method
+                          - URL
+                        additionalProperties: false
+                      web users can get test results about a page at:
+                        type: string
+                        description: URL template; replace {identifier} with the identifier of the latest report about the page.
                       basics about all tested pages:
                         type: array
                         items:
                           type: object
                           properties:
-                            tested web page:
-                              type: object
-                              properties:
-                                description:
-                                  type: string
-                                URL:
-                                  type: string
-                              required:
-                                - description
-                                - URL
-                              additionalProperties: false
-                            number of reports about the page:
-                              type: number
-                            basics about the latest report:
-                              type: object
-                              properties:
-                                identifier:
-                                  type: string
-                                  description: 'Identifier of the report (example: 260503T0432-x9z).'
-                                completion date and time:
-                                  type: string
-                                days since the report was completed:
-                                  type:
-                                    - number
-                                    - 'null'
-                              required:
-                                - identifier
-                                - completion date and time
-                                - days since the report was completed
-                              additionalProperties: false
-                            how to get details about the latest report:
-                              type: object
-                              properties:
-                                method:
-                                  type: string
-                                  const: GET
-                                URL:
-                                  type: string
-                              required:
-                                - method
-                                - URL
-                              additionalProperties: false
-                            web users can get details about the latest report at:
+                            description:
+                              type: string
+                            URL:
+                              type: string
+                            identifier:
                               type: string
+                              description: 'Identifier of the latest report about the page (example: 260503T0432-x9z).'
                           required:
-                            - tested web page
-                            - number of reports about the page
-                            - basics about the latest report
-                            - how to get details about the latest report
-                            - web users can get details about the latest report at
+                            - description
+                            - URL
+                            - identifier
                           additionalProperties: false
                       how to request that a page with no report be tested:
                         type: object
@@ -153,6 +130,8 @@ paths:
                           - URL
                         additionalProperties: false
                     required:
+                      - how to get test results about a page
+                      - web users can get test results about a page at
                       - basics about all tested pages
                       - how to request that a page with no report be tested
                       - how a web user can request that the page be tested

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrpool/kilotest",
-  "version": "60.9.1",
+  "version": "61.0.0",
   "description": "Ensemble testing for front-end web quality",
   "type": "module",
   "main": "index.ts",

package/robots.txt

@@ -14,4 +14,7 @@ Disallow: /rewindReportsForm.html
 Disallow: /expungeReportsForm.html
 Disallow: /renewWCAGForm.html
 Disallow: /renewWCAG.html
+# JSON endpoints, whose contents are not indexable pages; crawling them is pointless.
+Disallow: /api/
+Disallow: /fullReport.json
 Sitemap: https://kilotest.com/sitemap.xml

package/server.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/jrpool/kilotest",
     "source": "github"
   },
-  "version": "60.9.1",
+  "version": "61.0.0",
   "remotes": [
     {
       "type": "streamable-http",