@jrpool/kilotest 58.2.4 → 59.0.2

package/api/getReport.test.ts

@@ -35,7 +35,7 @@ test('getReport returns the full report for a valid report', async () => {
   assert.ok((content['size of the report in bytes'] as number) > 0);
   const report = content['full report'] as any;
   assert.equal(report.id, '260101T0000-mix');
-  assert.equal(report.target.what, 'Mixed Outcomes Page');
+  assert.equal(report.target.what, 'Mixed Outcomes');
   assert.equal(report.target.url, 'https://example.com/mixed');
   assert.equal(report.acts.length, 2);
 });

package/api/listIssues.test.ts

@@ -113,3 +113,35 @@ test('listIssues handles instances with missing issueID and null instances witho
   const ids = issues.map(i => i.identifier);
   assert.ok(ids.includes('duplicateID'));
 });
+
+test('listIssues lists the history of reports about the page, from oldest to latest', async () => {
+  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(
+    history.map(entry => [
+      entry['whether it is the oldest report about the page'],
+      entry['whether it is the latest report about the page'],
+      entry['whether it is the report described in this response']
+    ]),
+    [[true, false, true], [false, true, false]]
+  );
+  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'));
+});
+
+test('listIssues gives a one-report history for the only report about a page', async () => {
+  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);
+  assert.equal(history[0]!['whether it is the latest report about the page'], true);
+  assert.equal(history[0]!['whether it is the report described in this response'], true);
+});
+
+test('listIssues gives no history for a nonexistent report', async () => {
+  const body = await response(['999999T9999', 'xyz']);
+  assert.equal(body['response content']['history of reports about the page'], null);
+});

package/api/listIssues.ts

@@ -16,7 +16,14 @@ import {
   getThisHost
 } from './util.ts';
 import {
-  getReport, getReportStats, getTestActInstances, getTestActs, isReportError, objectSort
+  getAgoDays,
+  getPageReportExtracts,
+  getReport,
+  getReportStats,
+  getTestActInstances,
+  getTestActs,
+  isReportError,
+  objectSort
 } from '../util.ts';
 import {listIssuesResponseSchema} from './schemas.ts';
 
@@ -38,6 +45,7 @@ export const response = async (args: string[]) => {
   // Initialize the response content.
   const responseContent: ResponseContent = {
     'basics about the report': reportBasics,
+    'history of reports about the page': null,
     'details about the report': null,
     'how to request that the page be retested': null,
     'how a web user can request that the page be retested': null,
@@ -55,6 +63,28 @@ export const response = async (args: string[]) => {
         device = {id: 'default'},
         browserID = null
       } = report;
+      // Get extracts of all reports about the page, from oldest to latest.
+      const pageExtracts = await getPageReportExtracts(report.target.what);
+      const lastIndex = pageExtracts.length - 1;
+      // Add the history of reports about the page to the response content.
+      responseContent['history of reports about the page'] = pageExtracts.map((extract, index) => {
+        const extractTimeStamp = extract.timeStamp;
+        const extractJobID = extract.jobID;
+        return {
+          identifier: `${extractTimeStamp}-${extractJobID}`,
+          'completion date and time': extract.reportTime,
+          'days since the report was completed': getAgoDays(new Date(extract.reportTime)),
+          'whether it is the oldest report about the page': index === 0,
+          'whether it is the latest report about the page': index === lastIndex,
+          'whether it is the report described in this response':
+          extractTimeStamp === timeStamp && extractJobID === jobID,
+          'how to get details about the report': {
+            method: 'GET' as const,
+            URL: `${thisHost}/api/listIssues/${extractTimeStamp}/${extractJobID}`
+          },
+          'web users can get details about the report at': `${thisHost}/listIssues.html/${extractTimeStamp}/${extractJobID}`
+        };
+      });
       // Get details about the job definition.
       const jobDefinitionDetails = {
         'whether the job prohibited redirection': strict,
@@ -159,7 +189,7 @@ export const response = async (args: string[]) => {
       if (reportBasics['whether a later report about the same page exists']) {
         // Add information about requesting a retest to the response content.
         responseContent['how to request that the page be retested'] = {
-          notice: 'A later report about the same page already exists. The listIssues output about that report includes instructions for requesting a retest.'
+          notice: 'A later report about the same page already exists (see the history of reports about the page). The listIssues output about the latest report includes instructions for requesting a retest.'
         };
       }
       // Otherwise, i.e. if the report has not been superseded:
@@ -172,7 +202,7 @@ export const response = async (args: string[]) => {
             reason: '20- to 100-character reason why the page should be retested'
           },
           'how to check whether the request has been fulfilled':
-          'use the listReports tool to determine whether a report about the page has become available (typical wait time: 1 hour to 1 day)'
+          'use the listPages tool to determine whether a later report about the page has become available (typical wait time: 1 hour to 1 day)'
         };
         // Add instructions for a web user to request a retest.
         responseContent['how a web user can request that the page be retested'] = {
@@ -207,19 +237,19 @@ export const response = async (args: string[]) => {
     'tool collection': getToolsFacts(),
     'tool name': 'listIssues',
     'this request': {
-      description: 'Provide details about one report, including basics about the issues reported in it. The timeStamp and jobID parameters identify the report that I want details about. Those parameters were in the response to my earlier listReports request.',
+      description: 'Provide details about one report, including basics about the issues reported in it. The timeStamp and jobID parameters identify the report that I want details about. Those parameters were in the response to my earlier listPages request, or in the history of reports about the page in an earlier listIssues response.',
       method: 'GET',
       URL: `${thisHost}/api/listIssues/${timeStamp}/${jobID}`,
       'closest ancestor request': {
-        'tool name': 'listReports',
-        description: 'Provide basics about all available reports.',
+        'tool name': 'listPages',
+        description: 'Provide basics about all tested pages.',
         method: 'GET',
-        URL: `${thisHost}/api/listReports`,
+        URL: `${thisHost}/api/listPages`,
       }
     },
     'URLs of similar requests for web users': {
       'this request': `${thisHost}/listIssues.html/${timeStamp}/${jobID}`,
-      'closest ancestor request': `${thisHost}/listReports.html`
+      'closest ancestor request': `${thisHost}/listPages.html`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/listPages.test.ts

@@ -0,0 +1,92 @@
+/*
+  listPages.test.ts
+  Tests for api/listPages.ts using the fixture corpus.
+*/
+
+// IMPORTS
+
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import {response} from './listPages.ts';
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+
+before(async () => {
+  process.env.DB_DIR = (await import('../test/dbFixture.ts')).fixtureDBDir;
+});
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+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);
+  assert.deepEqual(
+    descriptions,
+    [
+      'All CantTell Page',
+      'Branch Coverage Page',
+      'Empty Results Page',
+      'Mixed Outcomes',
+      'Multi Violator Page',
+      'No Outcomes Page',
+      'Prevented Page'
+    ]
+  );
+});
+
+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);
+  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 () => {
+  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'));
+});
+
+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');
+});
+
+test('listPages includes request-test instructions', async () => {
+  const body = await response();
+  const content = body['response content'];
+  assert.ok(content['how to request that a page with no report be tested']);
+  assert.ok(content['how a web user can request that the page be tested']);
+  assert.equal(content['how to request that a page with no report be tested'].method, 'POST');
+});
+
+test('listPages includes tool name and metadata', async () => {
+  const body = await response();
+  assert.equal(body['tool name'], 'listPages');
+  assert.ok(body['response metadata'].identifier);
+  assert.ok(body['response metadata']['date and time']);
+});

package/api/listPages.ts

@@ -0,0 +1,93 @@
+/*
+  listPages.ts
+  Returns basics about all tested pages.
+*/
+
+// IMPORTS
+
+import {z} from 'zod';
+import {getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
+import {getAgoDays, getReportExtracts} from '../util.ts';
+import {listPagesResponseSchema} from './schemas.ts';
+
+// TYPES
+
+// The response content defined by the response schema.
+type ResponseContent = z.infer<typeof listPagesResponseSchema>['response content'];
+
+// FUNCTIONS
+
+// 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, jobID, reportTime, superseded, timeStamp, 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: `${timeStamp}-${jobID}`,
+          '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/${timeStamp}/${jobID}`
+        },
+        'web users can get details about the latest report at': `${thisHost}/listIssues.html/${timeStamp}/${jobID}`
+      });
+    }
+  });
+  // Create the response content.
+  const responseContent: ResponseContent = {
+    'basics about all tested pages': pagesBasics,
+    'how to request that a page with no report be tested': {
+      method: 'POST',
+      URL: `${thisHost}/api/requestNewTest`,
+      'request body': {
+        description: '10- to 100-character description of the page conforming to the naming convention used in this list of pages',
+        URL: '12- to 300-character URL of the page, including the https:// scheme and any query',
+        reason: '20- to 100-character reason why the page should be tested'
+      },
+      'how to check whether the request has been fulfilled': 'use this listPages tool to determine whether the page has been tested (typical wait time: 1 hour to 1 day)'
+    },
+    'how a web user can request that the page be tested': {
+      URL: `${thisHost}/requestNewTestForm.html`
+    }
+  };
+  // Create a response body.
+  const body = {
+    'tool collection': getToolsFacts(),
+    'tool name': 'listPages',
+    'this request': {
+      description: 'Provide basics about all tested pages.',
+      method: 'GET',
+      URL: `${thisHost}/api/listPages`,
+      'closest ancestor request': null
+    },
+    'URLs of similar requests for web users': {
+      'this request': `${thisHost}/listPages.html`,
+      'closest ancestor request': null
+    },
+    'response metadata': getResponseMetadata(),
+    'response content': responseContent
+  };
+  // Return it.
+  return body;
+};

package/api/orderNewTest.test.ts

@@ -115,7 +115,7 @@ test('orderNewTest rejects a URL that redirects to a disallowed target, and aler
 });
 
 test('orderNewTest rejects an already-tested page', async () => {
-  const body = await response(['Mixed Outcomes Page', 'https://example.com/mixed', 'A reason that is long enough.']);
+  const body = await response(['Mixed Outcomes', 'https://example.com/mixed', 'A reason that is long enough.']);
   const details = body['response content']['details about your order'] as any;
   assert.equal(details.error, undefined);
   const disposition = body['response content']['disposition of your order'] as any;
@@ -209,5 +209,5 @@ test('orderNewTest response omits a web UI URL for this request but includes the
   const body = await response(['Brand New Ordered Page 2', 'https://example.com/brandnewordered2', 'A reason that is long enough.']);
   const similarWeb = body['URLs of similar requests for web users'] as any;
   assert.equal(similarWeb['this request'], null);
-  assert.ok(similarWeb['closest ancestor request'].includes('listReports.html'));
+  assert.ok(similarWeb['closest ancestor request'].includes('listPages.html'));
 });

package/api/orderNewTest.ts

@@ -127,15 +127,15 @@ export const response = async (args: string[]) => {
         reason
       },
       'closest ancestor request': {
-        'tool name': 'listReports',
-        description: 'Provide basics about all available reports.',
+        'tool name': 'listPages',
+        description: 'Provide basics about all tested pages.',
         method: 'GET',
-        URL: `${thisHost}/api/listReports`
+        URL: `${thisHost}/api/listPages`
       }
     },
     'URLs of similar requests for web users': {
       'this request': null,
-      'closest ancestor request': `${thisHost}/listReports.html`
+      'closest ancestor request': `${thisHost}/listPages.html`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/orderRetest.test.ts

@@ -87,7 +87,7 @@ test('orderRetest rejects a reason longer than 100 characters', async () => {
 });
 
 test('orderRetest rejects a superseded report', async () => {
-  // 260101T0000-mix is an earlier report of "Mixed Outcomes Page" than 260202T0000-new,
+  // 260101T0000-mix is an earlier report of "Mixed Outcomes" than 260202T0000-new,
   // so it is superseded.
   const body = await response(['260101T0000', 'mix', 'A reason that is long enough.']);
   const details = body['response content']['details about your order'] as any;

package/api/requestNewTest.test.ts

@@ -110,7 +110,7 @@ test('requestNewTest rejects a URL that redirects to a disallowed target, and al
 });
 
 test('requestNewTest rejects an already-tested page', async () => {
-  const body = await response(['Mixed Outcomes Page', 'https://example.com/mixed', 'A reason that is long enough.']);
+  const body = await response(['Mixed Outcomes', 'https://example.com/mixed', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   // A report for this description and URL already exists, so processTestRequest
   // returns 'reportExists' and the failure is reported via the disposition, not details.error.

package/api/requestNewTest.ts

@@ -81,8 +81,8 @@ export const response = async (args: string[]) => {
       requestResult,
       {
         whatHappensNext: 'Your request is likely to be approved and processed within 1 hour to 1 day.',
-        howToCheck: 'You can call the listReports tool to learn whether the page has been tested and a report is available.',
-        howWebUserChecks: `A web user can visit ${thisHost}/listReports.html to learn whether the page has been tested and a report is available.`
+        howToCheck: 'You can call the listPages tool to learn whether the page has been tested.',
+        howWebUserChecks: `A web user can visit ${thisHost}/listPages.html to learn whether the page has been tested.`
       },
       {result: 'reportExists', reason: 'a report about a page with the same description or URL is available.'}
     );
@@ -106,15 +106,15 @@ export const response = async (args: string[]) => {
         reason
       },
       'closest ancestor request': {
-        'tool name': 'listReports',
-        description: 'Provide basics about all available reports.',
+        'tool name': 'listPages',
+        description: 'Provide basics about all tested pages.',
         method: 'GET',
-        URL: `${thisHost}/api/listReports`
+        URL: `${thisHost}/api/listPages`
       }
     },
     'URLs of similar requests for web users': {
       'this request': `${thisHost}/requestNewTestForm.html`,
-      'closest ancestor request': `${thisHost}/listReports.html`
+      'closest ancestor request': `${thisHost}/listPages.html`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/requestRetest.test.ts

@@ -85,7 +85,7 @@ test('requestRetest rejects a malformed timestamp or job identifier', async () =
 });
 
 test('requestRetest rejects a superseded report', async () => {
-  // 260101T0000-mix is an earlier report of "Mixed Outcomes Page" than 260202T0000-new,
+  // 260101T0000-mix is an earlier report of "Mixed Outcomes" than 260202T0000-new,
   // so it is superseded and processTestRequest returns 'superseded', reported via the
   // disposition rather than details.error.
   const body = await response(['260101T0000', 'mix', 'A reason that is long enough.']);
@@ -168,10 +168,10 @@ test('requestRetest accepts a valid retest request for the latest report of a pa
   const body = await response(['260202T0000', 'new', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   assert.equal(details.error, undefined);
-  assert.equal(details['page to be retested'].description, 'Mixed Outcomes Page');
+  assert.equal(details['page to be retested'].description, 'Mixed Outcomes');
   assert.ok(logged.some(line =>
     line.startsWith('WARNING (Kilotest: request for a retest awaits approval)')
-    && line.includes('Mixed Outcomes Page')
+    && line.includes('Mixed Outcomes')
     && line.includes('https://example.com/mixed')
     // The alert reports the resulting queue size, so a maintainer who has been away can
     // see at a glance how close the queue is to full.

package/api/requestRetest.ts

@@ -64,8 +64,8 @@ export const response = async (args: string[]) => {
         requestResult,
         {
           whatHappensNext: 'Your request is likely to be approved and processed within 1 hour to 1 day.',
-          howToCheck: 'You can call the listReports tool to learn whether the page has been retested and a new report is available.',
-          howWebUserChecks: `A web user can visit ${thisHost}/listReports.html to learn whether the page has been retested and a new report is available.`
+          howToCheck: 'You can call the listPages tool, or the listIssues tool on the current report, to learn whether the page has been retested and a new report is available.',
+          howWebUserChecks: `A web user can visit ${thisHost}/listPages.html to learn whether the page has been retested and a new report is available.`
         },
         {result: 'superseded', reason: 'a later report about a page with the same description is available.'}
       );

package/api/routes.test.ts

@@ -23,7 +23,7 @@ test('routes includes all expected operation IDs', () => {
     'getReport',
     'listDiagnoses',
     'listIssues',
-    'listReports',
+    'listPages',
     'listViolators',
     'orderNewTest',
     'orderRetest',

package/api/routes.ts

@@ -17,7 +17,7 @@ import {
   orderNewTestSchema,
   orderRetestSchema,
   awaitTestSchema,
-  listReportsResponseSchema,
+  listPagesResponseSchema,
   listIssuesResponseSchema,
   listViolatorsResponseSchema,
   listDiagnosesResponseSchema,
@@ -34,11 +34,11 @@ import {
 
 export const routes = [
   {
-    operationId: 'listReports',
+    operationId: 'listPages',
     method: 'get',
-    path: '/api/listReports',
-    summary: 'List all available reports',
-    responseSchema: listReportsResponseSchema
+    path: '/api/listPages',
+    summary: 'List all tested pages',
+    responseSchema: listPagesResponseSchema
   },
   {
     operationId: 'listIssues',

package/api/schemas.ts

@@ -43,7 +43,7 @@ export const getReportSchema = {
 
 // requestNewTest: POST /api/requestNewTest
 export const requestNewTestSchema = {
-  description: z.string().describe('1- to 100-character description of the page conforming to the naming convention used in the listReports output'),
+  description: z.string().describe('1- to 100-character description of the page conforming to the naming convention used in the listPages output'),
   URL: z.string().describe('12- to 300-character URL of the page, including the https:// scheme and any query'),
   reason: z.string().describe('20- to 100-character reason why the page should be tested')
 };
@@ -62,7 +62,7 @@ export const requestFeatureSchema = {
 
 // orderNewTest: POST /api/orderNewTest
 export const orderNewTestSchema = {
-  description: z.string().describe('1- to 100-character description of the page conforming to the naming convention used in the listReports output'),
+  description: z.string().describe('1- to 100-character description of the page conforming to the naming convention used in the listPages output'),
   URL: z.string().describe('12- to 300-character URL of the page, including the https:// scheme and any query'),
   reason: z.string().describe('20- to 100-character reason why the page should be tested')
 };
@@ -80,7 +80,7 @@ export const awaitTestSchema = {
   jobID: z.string().describe('Job identifier of the ordered job, from the report identifier returned by orderNewTest (example: x9z)')
 };
 
-// listReports takes no input; omitted (mcp.ts already uses inputSchema: {}).
+// listPages takes no input; omitted (mcp.ts already uses inputSchema: {}).
 
 // RESPONSE SCHEMAS
 
@@ -194,10 +194,20 @@ const issueBasicsOrErrorSchema = z.union([
   z.object({error: z.string()})
 ]).meta({id: 'IssueBasicsOrError'});
 
-export const listReportsResponseSchema = envelope('GET', z.object({
-  'basics about all available reports': z.array(reportBasicsSchema.extend({
-    'how to get details about the report': z.object({method: z.literal('GET'), URL: z.string()}),
-    'web users can get details about the report at': z.string()
+// Facts about a report among those about one page.
+const reportTimeSchema = z.object({
+  identifier: z.string().describe('timeStamp-jobID identifier of the report.'),
+  'completion date and time': z.string(),
+  'days since the report was completed': z.number().nullable()
+});
+
+export const listPagesResponseSchema = envelope('GET', z.object({
+  '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()
   })),
   'how to request that a page with no report be tested': z.object({
     method: z.literal('POST'),
@@ -210,6 +220,13 @@ export const listReportsResponseSchema = envelope('GET', z.object({
 
 export const listIssuesResponseSchema = envelope('GET', z.object({
   'basics about the report': reportBasicsOrErrorSchema,
+  'history of reports about the page': z.array(reportTimeSchema.extend({
+    'whether it is the oldest report about the page': z.boolean(),
+    'whether it is the latest report about the page': z.boolean(),
+    'whether it is the report described in this response': z.boolean(),
+    'how to get details about the report': z.object({method: z.literal('GET'), URL: z.string()}),
+    'web users can get details about the report at': z.string()
+  })).nullable().describe('All reports about the same page, from oldest to latest, or null if the report is unavailable.'),
   'details about the report': z.object({
     'job definition': z.object({
       'whether the job prohibited redirection': z.unknown().describe('Copied from the report (strict); type not guaranteed.'),