@jrpool/kilotest 46.0.8 → 46.0.14

package/llms-full.txt

@@ -22,10 +22,10 @@ To provide a more inexpensive, thorough, and accurate assessment, the agent coul
 
 The tool that tests web pages for front-end quality has attributes that no other such tool has. It:
 
-- selects an ensemble of 10 rule engines that implement tests for, in total, more than a thousand rules for front-end quality
+- selects an ensemble of 12 rule engines that implement tests for, in total, more than a thousand rules for front-end quality
 - runs the tests of the rule engines
 - combines the reports of the rule engines into a single integrated report
-- consolidates the 1000+ rules having 10 different naming systems into 300+ “issues” with a uniform naming system
+- consolidates the 1000+ rules having 12 different naming systems into 300+ “issues” with a uniform naming system
 
 The tools that report test results extract from reports statistics and details at various levels of granularity, as required by an agent to fulfill particular user requests.
 
@@ -46,9 +46,9 @@ The rule engines in the Kilotest ensemble take responsibility for determining wh
 
 ## Kilotest versus other MCP servers
 
-In the marketplace for MCP servers that test for front-end quality, all servers other than that of Kilotest leverage at most 1 rule engine, most often `axe-core`. The Kilotest testing tool leverages `axe-core` plus 9 other rule engines. This has these main effects:
+In the marketplace for MCP servers that test for front-end quality, all servers other than that of Kilotest leverage at most 1 rule engine, most often `axe-core`. The Kilotest testing tool leverages `axe-core` plus 11 other rule engines. This has these main effects:
 
-- For web pages that have not yet been tested, a single-rule-engine MCP can provide faster results than Kilotest. A tool running only the `axe-core` tests can complete its work in about 5 seconds or less. The testing tool of Kilotest usually completes its work in 2 to 3 minutes, because all 10 rule engines are run, and some of the tests involve navigation and interaction with the page and LLM inference. Moreover, Kilotest currently allows users (both humans and models) to **recommend** new pages for testing but authorizes only Kilotest managers to make the tool proceed with the testing. The wait for manager action can take up to a day. A feature permitting immediate testing ordered by AI agents is planned, but, until it is implemented, Kilotest will be useful for not-yet-tested pages only in long-running (multi-day) workflows.
+- For web pages that have not yet been tested, a single-rule-engine MCP can provide faster results than Kilotest. A tool running only the `axe-core` tests can complete its work in about 5 seconds or less. The testing tool of Kilotest usually completes its work in 2 to 3 minutes, because all 12 rule engines are run, and some of the tests involve navigation and interaction with the page and LLM inference. Moreover, Kilotest currently allows users (both humans and models) to **recommend** new pages for testing but authorizes only Kilotest managers to make the tool proceed with the testing. The wait for manager action can take up to a day. A feature permitting immediate testing ordered by AI agents is planned, but, until it is implemented, Kilotest will be useful for not-yet-tested pages only in long-running (multi-day) workflows.
 - For web pages about which reports are already available, Kilotest can provide faster results than a single-rule-engine MCP server, because Kilotest stores test results for subsequent retrieval. A retrieval from a Kilotest reporting tool can be completed in less than 2 seconds.
 - Kilotest results are more comprehensive than single-rule-engine MCP server results. Every rule engine provides limited coverage of front-end quality, so false negatives (missed defects) are more common with single-rule-engine MCP servers. This difference [has been documented in research](https://arxiv.org/pdf/2304.07591).
 
@@ -165,7 +165,6 @@ More information about Kilotest features and internals:
 
 - [Kilotest as connector to and collection of AI Tools](https://github.com/jrpool/kilotest/blob/main/docs/AI-TOOLS.md)
 - [OpenAPI specification for Kilotest](https://kilotest.com/openapi.yaml)
-- [Tool caller for testing](https://github.com/jrpool/kilotest/blob/main/api/testSuite.js)
 
 ### General
 
@@ -173,7 +172,7 @@ More information about Kilotest features and internals:
 - [Tutorial, “Accessibility testing strategies”](https://kilotest.com/tutorial.html)
 - [Tutorial on authorizing language models to use Kilotest](https://kilotest.com/qai/)
 - [README file](https://github.com/jrpool/kilotest/blob/main/README.md)
-- [Testaro rule-engine orchestrator](https://github.com/jrpool/testaro)
-- [Testaro rule classifier](https://github.com/jrpool/testaro-issues)
+- [Testaro rule-engine orchestrator](https://github.com/YRA-Tech/testaro)
+- [Testaro rule classifier](https://github.com/YRA-Tech/testaro-issues)
 - [Research report on Testaro](https://arxiv.org/abs/2309.10167)
 - [Blog post on the Kilotest use case](https://medium.com/cvs-health-tech-blog/how-to-run-a-thousand-accessibility-tests-63692ad120c3)

package/llms.txt

@@ -1,6 +1,6 @@
 # Kilotest
 
-Kilotest helps language models and AI platforms to give thorough, accurate and truthful answers when users ask about the front-end quality (i.e. accessibility, usability, and standards conformity) of web pages. Kilotest integrates an ensemble often independent rule engines to test any public web page. Kilotest creates a structured report of the results and saves the report for future reference. Kilotest API endpoints and MCP tools can provide multipage, single-page, and element-level test results.
+Kilotest helps language models and AI platforms to give thorough, accurate and truthful answers when users ask about the front-end quality (i.e. accessibility, usability, and standards conformity) of web pages. Kilotest integrates an ensemble of twelve independent rule engines to test any public web page. Kilotest creates a structured report of the results and saves the report for future reference. Kilotest API endpoints and MCP tools can provide multipage, single-page, and element-level test results.
 
 ## API
 

package/mcp.js

@@ -44,7 +44,7 @@ exports.mcpPath = '/mcp';
 // FUNCTIONS
 
 // Creates and returns an McpServer with Kilotest tools registered.
-const createMCPServer = () => {
+exports.createMCPServer = () => {
   const server = new McpServer({
     name: 'Kilotest',
     version,
@@ -210,7 +210,7 @@ const createMCPServer = () => {
 // Handles an MCP request.
 exports.handleMCP = async (request, response) => {
   const transport = new StreamableHTTPServerTransport({sessionIdGenerator: undefined});
-  const server = createMCPServer();
+  const server = exports.createMCPServer();
   await server.connect(transport);
   await transport.handleRequest(request, response);
 };

package/mcp.test.js

@@ -0,0 +1,281 @@
+/*
+  mcp.test.js
+  Tests for mcp.js, covering tool registration and handler behavior.
+*/
+
+// IMPORTS
+
+const {test} = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const http = require('node:http');
+const {mcpPath, createMCPServer} = require('./mcp');
+
+// CONSTANTS
+
+// Set DB_DIR to the fixture database for all tests.
+process.env.DB_DIR = path.join(__dirname, 'test', 'fixtures', 'db');
+
+// TESTS
+
+test('mcpPath is /mcp', () => {
+  assert.equal(mcpPath, '/mcp');
+});
+
+test('createMCPServer registers all 8 tools', () => {
+  const server = createMCPServer();
+  const toolNames = Object.keys(server._registeredTools);
+  assert.equal(toolNames.length, 8);
+  assert.deepEqual(toolNames, [
+    'listReports',
+    'listIssues',
+    'listViolators',
+    'listDiagnoses',
+    'getReport',
+    'requestTest',
+    'requestRetest',
+    'requestFeature'
+  ]);
+});
+
+test('each tool has a description and a handler function', () => {
+  const server = createMCPServer();
+  const tools = server._registeredTools;
+  for (const [name, tool] of Object.entries(tools)) {
+    assert.ok(tool.description, `${name} has a description`);
+    assert.equal(typeof tool.handler, 'function', `${name} has a handler function`);
+  }
+});
+
+test('listReports handler returns content and structuredContent', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.listReports.handler({});
+  assert.ok(result.content);
+  assert.equal(result.content[0].type, 'text');
+  assert.ok(result.structuredContent);
+});
+
+test('listIssues handler returns content and structuredContent for a valid report', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.listIssues.handler({
+    timeStamp: '260101T0000',
+    jobID: 'mix'
+  });
+  assert.ok(result.content);
+  assert.equal(result.content[0].type, 'text');
+  assert.ok(result.structuredContent);
+});
+
+test('listViolators handler returns content and structuredContent for a valid issue', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.listViolators.handler({
+    issueID: 'linkNoText',
+    timeStamp: '260101T0000',
+    jobID: 'mix'
+  });
+  assert.ok(result.content);
+  assert.equal(result.content[0].type, 'text');
+  assert.ok(result.structuredContent);
+});
+
+test('listDiagnoses handler returns content and structuredContent for a valid diagnosis', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.listDiagnoses.handler({
+    catalogIndex: '0',
+    issueID: 'linkNoText',
+    timeStamp: '260101T0000',
+    jobID: 'mix'
+  });
+  assert.ok(result.content);
+  assert.equal(result.content[0].type, 'text');
+  assert.ok(result.structuredContent);
+});
+
+test('getReport handler returns content and structuredContent for a valid report', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.getReport.handler({
+    timeStamp: '260101T0000',
+    jobID: 'mix'
+  });
+  assert.ok(result.content);
+  assert.equal(result.content[0].type, 'text');
+  assert.ok(result.structuredContent);
+});
+
+test('requestTest handler returns content and structuredContent', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.requestTest.handler({
+    description: 'Test Page',
+    URL: 'https://example.com/test',
+    reason: 'Because accessibility matters'
+  });
+  assert.ok(result.content);
+  assert.equal(result.content[0].type, 'text');
+  assert.ok(result.structuredContent);
+});
+
+test('requestRetest handler returns content and structuredContent for a valid report', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.requestRetest.handler({
+    timeStamp: '260101T0000',
+    jobID: 'mix',
+    reason: 'Because the report is obsolete'
+  });
+  assert.ok(result.content);
+  assert.equal(result.content[0].type, 'text');
+  assert.ok(result.structuredContent);
+});
+
+test('requestFeature handler returns content and structuredContent', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.requestFeature.handler({
+    feature: 'A new feature idea'
+  });
+  assert.ok(result.content);
+  assert.equal(result.content[0].type, 'text');
+  assert.ok(result.structuredContent);
+});
+
+test('listIssues handler returns an error for a nonexistent report', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.listIssues.handler({
+    timeStamp: '990101T0000',
+    jobID: 'xxx'
+  });
+  const reportBasics = result.structuredContent['response content']['basics about the report'];
+  assert.ok(reportBasics.error);
+});
+
+test('listViolators handler returns an error for an unknown issue', async () => {
+  const server = createMCPServer();
+  const result = await server._registeredTools.listViolators.handler({
+    issueID: 'nonexistentIssue',
+    timeStamp: '260101T0000',
+    jobID: 'mix'
+  });
+  const issueBasics = result.structuredContent['response content']['basics about the issue'];
+  assert.ok(issueBasics.error);
+});
+
+// INTEGRATION TESTS FOR handleMCP
+
+// Helper: sends a single MCP JSON-RPC request to a local server and returns the parsed SSE response.
+const sendMCPRequest = (port, method, params, id) => new Promise((resolve, reject) => {
+  const body = JSON.stringify({jsonrpc: '2.0', method, params, id});
+  const req = http.request({
+    port,
+    method: 'POST',
+    path: '/mcp',
+    headers: {
+      'content-type': 'application/json',
+      'accept': 'application/json, text/event-stream',
+      'content-length': Buffer.byteLength(body)
+    }
+  }, res => {
+    let data = '';
+    res.on('data', chunk => {
+      data += chunk;
+    });
+    res.on('end', () => {
+      resolve({statusCode: res.statusCode, headers: res.headers, body: data});
+    });
+  });
+  req.on('error', reject);
+  req.write(body);
+  req.end();
+});
+
+// Helper: parses the JSON-RPC result from an SSE response body.
+const parseSSEResult = body => {
+  const jsonLine = body.split('\n').find(line => line.startsWith('data: '));
+  if (!jsonLine) {
+    throw new Error('No data line in SSE response');
+  }
+  return JSON.parse(jsonLine.slice(6));
+};
+
+// Helper: starts a local HTTP server with handleMCP and returns it.
+const startMCPServer = () => new Promise(resolve => {
+  const {handleMCP} = require('./mcp');
+  const server = http.createServer((req, res) => handleMCP(req, res));
+  server.listen(0, () => resolve(server));
+});
+
+// Helper: closes a server with a timeout fallback.
+const closeMCPServer = server => new Promise(resolve => {
+  if (!server) {
+    resolve();
+    return;
+  }
+  server.closeAllConnections?.();
+  const timer = setTimeout(() => {
+    server.closeAllConnections?.();
+    resolve();
+  }, 1000);
+  server.close(() => {
+    clearTimeout(timer);
+    resolve();
+  });
+});
+
+test('handleMCP responds to initialize with server info', async () => {
+  const server = await startMCPServer();
+  try {
+    const port = server.address().port;
+    const res = await sendMCPRequest(port, 'initialize', {
+      protocolVersion: '2025-06-18',
+      capabilities: {},
+      clientInfo: {name: 'test', version: '1.0'}
+    }, 1);
+    assert.equal(res.statusCode, 200);
+    const result = parseSSEResult(res.body);
+    assert.equal(result.result.serverInfo.name, 'Kilotest');
+    assert.equal(result.result.protocolVersion, '2025-06-18');
+  }
+  finally {
+    await closeMCPServer(server);
+  }
+});
+
+test('handleMCP lists all 8 tools via tools/list', async () => {
+  const server = await startMCPServer();
+  try {
+    const port = server.address().port;
+    const res = await sendMCPRequest(port, 'tools/list', {}, 2);
+    assert.equal(res.statusCode, 200);
+    const result = parseSSEResult(res.body);
+    const toolNames = result.result.tools.map(t => t.name);
+    assert.equal(toolNames.length, 8);
+    assert.deepEqual(toolNames, [
+      'listReports',
+      'listIssues',
+      'listViolators',
+      'listDiagnoses',
+      'getReport',
+      'requestTest',
+      'requestRetest',
+      'requestFeature'
+    ]);
+  }
+  finally {
+    await closeMCPServer(server);
+  }
+});
+
+test('handleMCP executes listReports tool via tools/call', async () => {
+  const server = await startMCPServer();
+  try {
+    const port = server.address().port;
+    const res = await sendMCPRequest(port, 'tools/call', {
+      name: 'listReports',
+      arguments: {}
+    }, 3);
+    assert.equal(res.statusCode, 200);
+    const result = parseSSEResult(res.body);
+    assert.ok(result.result.content);
+    assert.equal(result.result.content[0].type, 'text');
+  }
+  finally {
+    await closeMCPServer(server);
+  }
+});

package/openapi.yaml

@@ -1,7 +1,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 10 rule engines to test public web pages for front-end quality (accessibility, usability, and standards conformity). 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.'
+  description: 'Kilotest is an ensemble testing and reporting service for front-end web quality. It uses an ensemble of 12 rule engines to test public web pages for front-end quality (accessibility, usability, and standards conformity). 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: 2.1.0
   license:
     name: MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrpool/kilotest",
-  "version": "46.0.8",
+  "version": "46.0.14",
   "description": "Ensemble testing for front-end web quality",
   "main": "index.js",
   "engines": {
@@ -9,7 +9,7 @@
   "scripts": {
     "start": "node index",
     "lint": "npx eslint && npx markdownlint-cli2",
-    "test": "c8 node --test",
+    "test": "c8 node --require ./test/setup.cjs --test --test-concurrency=1 --test-timeout=70",
     "test:smoke": "node smokeTest",
     "generate:openapi": "node scripts/generate-openapi"
   },
@@ -66,7 +66,8 @@
       "mcp.js",
       "alerts.js",
       "util.js",
-      "api/**/*.js"
+      "api/**/*.js",
+      "web/**/*.js"
     ],
     "exclude": [
       "coverage/**",
@@ -74,8 +75,12 @@
       "test{,-*}.{js,cjs,mjs}",
       "**/*{.,-}test.{js,cjs,mjs}",
       "**/__tests__/**",
-      "web/**",
       "scripts/**"
-    ]
+    ],
+    "check-coverage": true,
+    "lines": 100,
+    "statements": 100,
+    "functions": 100,
+    "branches": 100
   }
 }

package/routing.test.js

@@ -23,7 +23,7 @@ let server;
 before(async () => {
   process.env.DB_DIR = path.join(__dirname, 'test', 'fixtures', 'db');
   server = http.createServer(requestHandler);
-  await new Promise(resolve => server.listen(port, resolve));
+  await new Promise(resolve => server.listen(port, () => resolve()));
 });
 
 after(async () => {
@@ -33,7 +33,17 @@ after(async () => {
   else {
     delete process.env.DB_DIR;
   }
-  await new Promise(resolve => server.close(() => resolve()));
+  server.closeAllConnections?.();
+  await new Promise(resolve => {
+    const timer = setTimeout(() => {
+      server.closeAllConnections?.();
+      resolve();
+    }, 1000);
+    server.close(() => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
 });
 
 // HELPERS
@@ -73,5 +83,5 @@ test('GET /api/listReports returns a valid JSON response', async () => {
   const body = JSON.parse(result.body);
   assert.equal(body['tool name'], 'listReports');
   const reports = body['response content']['basics about all available reports'];
-  assert.equal(reports.length, 6);
+  assert.equal(reports.length, 8);
 });

package/scripts/generate-openapi.js

@@ -58,7 +58,7 @@ const generate = () => {
     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 10 rule engines to test public web pages for front-end quality (accessibility, usability, and standards conformity). 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.',
+      description: 'Kilotest is an ensemble testing and reporting service for front-end web quality. It uses an ensemble of 12 rule engines to test public web pages for front-end quality (accessibility, usability, and standards conformity). 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,
       license: {
         name: license,

package/test/fixtures/buildFixtures.js

@@ -233,6 +233,89 @@ const main = async () => {
     hiddenReport
   );
 
+  // Fixture 8: multiViolator. Three violators for the same issue: two with 1 reporter each (exercising the catalogIndex tiebreaker) and one with 2 reporters (exercising the reporter-count descending sort).
+  const multiViolatorCatalog = {
+    '0': catalogItem('A', 'Home', '/html/body/a[1]', '10:10:40:20'),
+    '1': catalogItem('A', 'Contact', '/html/body/a[2]', '10:40:40:20'),
+    '2': catalogItem('A', 'Help', '/html/body/a[3]', '10:70:40:20')
+  };
+  const multiViolatorActs = [
+    testAct(engineAxe, [
+      instance('r11', 'The link does not have an accessible name', 'failed',
+        issueLinkNoText, 0, 2, 1),
+      instance('r11', 'The link does not have an accessible name', 'failed',
+        issueLinkNoText, 2, 2, 1)
+    ]),
+    testAct(engineAlfa, [
+      instance('r11', 'The link does not have an accessible name', 'failed',
+        issueLinkNoText, 1, 2, 1),
+      instance('r11', 'The link does not have an accessible name', 'failed',
+        issueLinkNoText, 2, 2, 1)
+    ])
+  ];
+  await writeJSON(
+    path.join(reportsDir, '260101T0008-mul.json'),
+    report('260101T0008-mul', 'Multi Violator Page',
+      'https://example.com/multiviolator', multiViolatorActs, multiViolatorCatalog)
+  );
+
+  // Fixture 9: branchCoverage. Covers remaining branch gaps in listDiagnoses and listIssues: an issue with a short WCAG code (guideline layer), a catalog item with no tagName or text, an instance where ruleID equals what and count is missing, a test act with null instances, and an instance with no issueID.
+  const issueDuplicateID = 'duplicateID';
+  const branchCatalog = {
+    '0': catalogItem('DIV', '', '/html/body/div[1]', '0:0:100:50'),
+    '1': {id: '', startTag: '<div>', text: null, textLinkable: false, boxID: '5:5:90:40', pathID: '/html/body/div[2]', headingIndex: '', checkpoint: 0},
+    '2': {id: '', text: 'No tags', textLinkable: false, headingIndex: '', checkpoint: 0}
+  };
+  const branchActs = [
+    testAct(engineAxe, [
+      instance('r99', 'r99', 'failed',
+        issueDuplicateID, 0, 2, 1),
+      {
+        ruleID: 'r100',
+        what: 'Element has no role',
+        ordinalSeverity: 1,
+        outcome: 'failed',
+        catalogIndex: '1',
+        checkpoint: 0,
+        issueID: issueDuplicateID
+      },
+      instance('r101', 'Duplicate ID found', 'failed',
+        issueDuplicateID, 2, 2, 1),
+      instance('r102', 'Duplicate ID in orphan', 'failed',
+        issueDuplicateID, 3, 2, 1)
+    ]),
+    {
+      type: 'test',
+      which: engineAlfa,
+      startTime: '26-01-01T00:00',
+      endTime: '26-01-01T00:01',
+      result: {
+        standardResult: {}
+      }
+    },
+    testAct(engineIbm, [
+      {
+        ruleID: 'r50',
+        what: 'Link has no text',
+        ordinalSeverity: 2,
+        outcome: 'failed',
+        catalogIndex: '0',
+        checkpoint: 0
+      }
+    ])
+  ];
+  await writeJSON(
+    path.join(reportsDir, '260101T0009-brd.json'),
+    report('260101T0009-brd', 'Branch Coverage Page',
+      'https://example.com/branch', branchActs, branchCatalog)
+  );
+  // Remove preventions from the brd fixture to cover the preventions ?? {} branch in listIssues.
+  const brdReport = JSON.parse(
+    await fs.readFile(path.join(reportsDir, '260101T0009-brd.json'), 'utf8')
+  );
+  delete brdReport.jobData.preventions;
+  await writeJSON(path.join(reportsDir, '260101T0009-brd.json'), brdReport);
+
   // Write an empty recs.json so getRecs does not try to create one.
   await writeJSON(path.join(targetDir, 'jobs', 'recs.json'), {});
 

package/test/fixtures/db/reports/260101T0008-mul.json

@@ -0,0 +1,137 @@
+{
+  "id": "260101T0008-mul",
+  "what": "Multi Violator Page",
+  "strict": false,
+  "standard": "only",
+  "device": {
+    "id": "default"
+  },
+  "browserID": "chromium",
+  "creationTimeStamp": "260101T0008",
+  "executionTimeStamp": "260101T0008",
+  "target": {
+    "what": "Multi Violator Page",
+    "url": "https://example.com/multiviolator"
+  },
+  "sources": {
+    "worker": "test-worker"
+  },
+  "acts": [
+    {
+      "type": "test",
+      "which": "axe",
+      "startTime": "26-01-01T00:00",
+      "endTime": "26-01-01T00:01",
+      "result": {
+        "standardResult": {
+          "instances": [
+            {
+              "ruleID": "r11",
+              "what": "The link does not have an accessible name",
+              "ordinalSeverity": 2,
+              "outcome": "failed",
+              "count": 1,
+              "catalogIndex": "0",
+              "checkpoint": 0,
+              "issueID": "linkNoText"
+            },
+            {
+              "ruleID": "r11",
+              "what": "The link does not have an accessible name",
+              "ordinalSeverity": 2,
+              "outcome": "failed",
+              "count": 1,
+              "catalogIndex": "2",
+              "checkpoint": 0,
+              "issueID": "linkNoText"
+            }
+          ],
+          "outcomeTotals": {
+            "failed": 2,
+            "cantTell": 0
+          }
+        }
+      }
+    },
+    {
+      "type": "test",
+      "which": "alfa",
+      "startTime": "26-01-01T00:00",
+      "endTime": "26-01-01T00:01",
+      "result": {
+        "standardResult": {
+          "instances": [
+            {
+              "ruleID": "r11",
+              "what": "The link does not have an accessible name",
+              "ordinalSeverity": 2,
+              "outcome": "failed",
+              "count": 1,
+              "catalogIndex": "1",
+              "checkpoint": 0,
+              "issueID": "linkNoText"
+            },
+            {
+              "ruleID": "r11",
+              "what": "The link does not have an accessible name",
+              "ordinalSeverity": 2,
+              "outcome": "failed",
+              "count": 1,
+              "catalogIndex": "2",
+              "checkpoint": 0,
+              "issueID": "linkNoText"
+            }
+          ],
+          "outcomeTotals": {
+            "failed": 2,
+            "cantTell": 0
+          }
+        }
+      }
+    }
+  ],
+  "jobData": {
+    "startTime": "26-01-01T00:00",
+    "endTime": "26-01-01T00:10",
+    "elapsedSeconds": 600,
+    "preventions": {},
+    "issuelessRules": []
+  },
+  "catalog": {
+    "0": {
+      "tagName": "A",
+      "id": "",
+      "startTag": "<a>",
+      "text": "Home",
+      "textLinkable": false,
+      "boxID": "10:10:40:20",
+      "pathID": "/html/body/a[1]",
+      "headingIndex": "",
+      "checkpoint": 0
+    },
+    "1": {
+      "tagName": "A",
+      "id": "",
+      "startTag": "<a>",
+      "text": "Contact",
+      "textLinkable": false,
+      "boxID": "10:40:40:20",
+      "pathID": "/html/body/a[2]",
+      "headingIndex": "",
+      "checkpoint": 0
+    },
+    "2": {
+      "tagName": "A",
+      "id": "",
+      "startTag": "<a>",
+      "text": "Help",
+      "textLinkable": false,
+      "boxID": "10:70:40:20",
+      "pathID": "/html/body/a[3]",
+      "headingIndex": "",
+      "checkpoint": 0
+    }
+  },
+  "images": {},
+  "checkpoints": []
+}