@jrpool/kilotest 59.1.4 → 60.0.0

package/api/requestRetest.ts

@@ -7,7 +7,7 @@
 
 import {z} from 'zod';
 import {buildRequestDisposition, getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
-import {checkLength, isJobID, isTimeStamp, processTestRequest} from '../util.ts';
+import {checkLength, isReportID, processTestRequest} from '../util.ts';
 import {requestRetestResponseSchema} from './schemas.ts';
 
 // TYPES
@@ -19,16 +19,16 @@ type ResponseContent = z.infer<typeof requestRetestResponseSchema>['response con
 
 // Returns the response body.
 export const response = async (args: string[]) => {
-  const [timeStamp = '', jobID = '', reason = ''] = args;
+  const [reportID = '', reason = ''] = args;
   const thisHost = getThisHost();
   const reasonCheck = checkLength(reason, 20, 100, 'reason');
   // Initialize the response-content properties.
   let requestDetails: ResponseContent['details about your request'];
   let requestDisposition: ResponseContent['disposition of your request'] = null;
-  // If the timestamp or job ID is not syntactically valid:
-  if (!isTimeStamp(timeStamp) || !isJobID(jobID)) {
+  // If the report identifier is not syntactically valid:
+  if (!isReportID(reportID)) {
     requestDetails = {
-      error: 'request invalid: the report timestamp or job identifier is malformed'
+      error: 'request invalid: the reportID is malformed'
     };
   }
   // Otherwise, if the encoded reason is too short or too long:
@@ -40,7 +40,7 @@ export const response = async (args: string[]) => {
   // Otherwise, i.e. if the request is facially valid:
   else {
     // Process the request. This resolves the cited report's description and URL itself.
-    const processResult = await processTestRequest(reason, {timeStamp, jobID});
+    const processResult = await processTestRequest(reason, {reportID});
     // If the cited report does not exist:
     if (processResult.result === 'nonreport') {
       requestDetails = {
@@ -81,9 +81,9 @@ export const response = async (args: string[]) => {
     'tool collection': getToolsFacts(),
     'tool name': 'requestRetest',
     'this request': {
-      description: 'Process my request to retest a page. The timeStamp and jobID parameters identify the latest available report about the page. Those parameters were in the response to my earlier listIssues request. The reason property of the request body is the reason why the page should be retested.',
+      description: 'Process my request to retest a page. The reportID parameter identifies the latest available report about the page. It was in the response to my earlier listIssues request. The reason property of the request body is the reason why the page should be retested.',
       method: 'POST',
-      URL: `${thisHost}/api/requestRetest/${timeStamp}/${jobID}`,
+      URL: `${thisHost}/api/requestRetest/${reportID}`,
       body: {
         reason
       },
@@ -91,12 +91,12 @@ export const response = async (args: string[]) => {
         'tool name': 'listIssues',
         description: 'Provide details about one report, including basics about the issues reported in it.',
         method: 'GET',
-        URL: `${thisHost}/api/listIssues/${timeStamp}/${jobID}`
+        URL: `${thisHost}/api/listIssues/${reportID}`
       }
     },
     'URLs of similar requests for web users': {
-      'this request': `${thisHost}/requestRetestForm.html/${timeStamp}/${jobID}`,
-      'closest ancestor request': `${thisHost}/listIssues.html/${timeStamp}/${jobID}`
+      'this request': `${thisHost}/requestRetestForm.html/${reportID}`,
+      'closest ancestor request': `${thisHost}/listIssues.html/${reportID}`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/routes.ts

@@ -43,7 +43,7 @@ export const routes = [
   {
     operationId: 'listIssues',
     method: 'get',
-    path: '/api/listIssues/{timeStamp}/{jobID}',
+    path: '/api/listIssues/{reportID}',
     summary: 'List basics about the issues in one report',
     pathParamsSchema: z.object(listIssuesSchema),
     responseSchema: listIssuesResponseSchema
@@ -51,7 +51,7 @@ export const routes = [
   {
     operationId: 'listViolators',
     method: 'get',
-    path: '/api/listViolators/{issueID}/{timeStamp}/{jobID}',
+    path: '/api/listViolators/{issueID}/{reportID}',
     summary: 'List elements reported as exhibiting one issue',
     pathParamsSchema: z.object(listViolatorsSchema),
     responseSchema: listViolatorsResponseSchema
@@ -59,7 +59,7 @@ export const routes = [
   {
     operationId: 'listDiagnoses',
     method: 'get',
-    path: '/api/listDiagnoses/{catalogIndex}/{issueID}/{timeStamp}/{jobID}',
+    path: '/api/listDiagnoses/{catalogIndex}/{issueID}/{reportID}',
     summary: 'List diagnoses of how one element exhibited one issue',
     pathParamsSchema: z.object(listDiagnosesSchema),
     responseSchema: listDiagnosesResponseSchema
@@ -67,7 +67,7 @@ export const routes = [
   {
     operationId: 'getReport',
     method: 'get',
-    path: '/api/getReport/{timeStamp}/{jobID}',
+    path: '/api/getReport/{reportID}',
     summary: 'Get one full report in JSON',
     pathParamsSchema: z.object(getReportSchema),
     responseSchema: getReportResponseSchema
@@ -83,11 +83,10 @@ export const routes = [
   {
     operationId: 'requestRetest',
     method: 'post',
-    path: '/api/requestRetest/{timeStamp}/{jobID}',
+    path: '/api/requestRetest/{reportID}',
     summary: 'Request that a page be retested',
     pathParamsSchema: z.object({
-      timeStamp: requestRetestSchema.timeStamp,
-      jobID: requestRetestSchema.jobID
+      reportID: requestRetestSchema.reportID
     }),
     bodySchema: z.object({reason: requestRetestSchema.reason}),
     responseSchema: requestRetestResponseSchema
@@ -111,11 +110,10 @@ export const routes = [
   {
     operationId: 'orderRetest',
     method: 'post',
-    path: '/api/orderRetest/{timeStamp}/{jobID}',
+    path: '/api/orderRetest/{reportID}',
     summary: 'Order that a page be retested immediately, without manual approval',
     pathParamsSchema: z.object({
-      timeStamp: orderRetestSchema.timeStamp,
-      jobID: orderRetestSchema.jobID
+      reportID: orderRetestSchema.reportID
     }),
     bodySchema: z.object({reason: orderRetestSchema.reason}),
     responseSchema: orderRetestResponseSchema
@@ -123,7 +121,7 @@ export const routes = [
   {
     operationId: 'awaitTest',
     method: 'post',
-    path: '/api/awaitTest/{timeStamp}/{jobID}',
+    path: '/api/awaitTest/{reportID}',
     summary: 'Wait for a job ordered via orderNewTest or orderRetest to complete',
     pathParamsSchema: z.object(awaitTestSchema),
     // No caller-supplied fields beyond the path parameters; an empty body schema (rather

package/api/schemas.ts

@@ -14,31 +14,27 @@ type ZodTypeAny = import('zod').ZodTypeAny;
 
 // REQUEST SCHEMAS
 
-// listIssues: GET /api/listIssues/{timeStamp}/{jobID}
+// listIssues: GET /api/listIssues/{reportID}
 export const listIssuesSchema = {
-  timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
-  jobID: z.string().describe('Job identifier of the report (example: x9z)')
+  reportID: z.string().describe('Identifier of the report (example: 260503T0432-x9z)')
 };
 
-// listViolators: GET /api/listViolators/{issueID}/{timeStamp}/{jobID}
+// listViolators: GET /api/listViolators/{issueID}/{reportID}
 export const listViolatorsSchema = {
   issueID: z.string().describe('Issue identifier (example: contrastPoor)'),
-  timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
-  jobID: z.string().describe('Job identifier of the report (example: x9z)')
+  reportID: z.string().describe('Identifier of the report (example: 260503T0432-x9z)')
 };
 
-// listDiagnoses: GET /api/listDiagnoses/{catalogIndex}/{issueID}/{timeStamp}/{jobID}
+// listDiagnoses: GET /api/listDiagnoses/{catalogIndex}/{issueID}/{reportID}
 export const listDiagnosesSchema = {
   catalogIndex: z.string().describe('Identifier of the issue-exhibiting element in the catalog of elements on the page (example: 372)'),
   issueID: z.string().describe('Issue identifier (example: contrastPoor)'),
-  timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
-  jobID: z.string().describe('Job identifier of the report (example: x9z)')
+  reportID: z.string().describe('Identifier of the report (example: 260503T0432-x9z)')
 };
 
-// getReport: GET /api/getReport/{timeStamp}/{jobID}
+// getReport: GET /api/getReport/{reportID}
 export const getReportSchema = {
-  timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
-  jobID: z.string().describe('Job identifier of the report (example: x9z)')
+  reportID: z.string().describe('Identifier of the report (example: 260503T0432-x9z)')
 };
 
 // requestNewTest: POST /api/requestNewTest
@@ -48,10 +44,9 @@ export const requestNewTestSchema = {
   reason: z.string().describe('20- to 100-character reason why the page should be tested')
 };
 
-// requestRetest: POST /api/requestRetest/{timeStamp}/{jobID}
+// requestRetest: POST /api/requestRetest/{reportID}
 export const requestRetestSchema = {
-  timeStamp: z.string().describe('Timestamp of the latest report about the page in YYMMDDTHHmm format (example: 260503T0432)'),
-  jobID: z.string().describe('Job identifier of the latest report about the page (example: x9z)'),
+  reportID: z.string().describe('Identifier of the latest report about the page (example: 260503T0432-x9z)'),
   reason: z.string().describe('20- to 100-character reason why the page should be retested')
 };
 
@@ -67,17 +62,15 @@ export const orderNewTestSchema = {
   reason: z.string().describe('20- to 100-character reason why the page should be tested')
 };
 
-// orderRetest: POST /api/orderRetest/{timeStamp}/{jobID}
+// orderRetest: POST /api/orderRetest/{reportID}
 export const orderRetestSchema = {
-  timeStamp: z.string().describe('Timestamp of the latest report about the page in YYMMDDTHHmm format (example: 260503T0432)'),
-  jobID: z.string().describe('Job identifier of the latest report about the page (example: x9z)'),
+  reportID: z.string().describe('Identifier of the latest report about the page (example: 260503T0432-x9z)'),
   reason: z.string().describe('20- to 100-character reason why the page should be retested')
 };
 
-// awaitTest: POST /api/awaitTest
+// awaitTest: POST /api/awaitTest/{reportID}
 export const awaitTestSchema = {
-  timeStamp: z.string().describe('Timestamp of the ordered job, from the report identifier returned by orderNewTest, in YYMMDDTHHmm format (example: 260503T0432)'),
-  jobID: z.string().describe('Job identifier of the ordered job, from the report identifier returned by orderNewTest (example: x9z)')
+  reportID: z.string().describe('Report identifier returned by orderNewTest or orderRetest (example: 260503T0432-x9z)')
 };
 
 // listPages takes no input; omitted (mcp.ts already uses inputSchema: {}).
@@ -164,7 +157,7 @@ const responseMetadataSchema = z.object({
 
 // Facts about a report, as constructed by Kilotest's own getReportBasics (never copied from a Testaro report).
 const reportBasicsSchema = z.object({
-  identifier: z.string().describe('timeStamp-jobID identifier of the report.'),
+  identifier: z.string().describe('Identifier of the report (example: 260503T0432-x9z).'),
   'completion date and time': z.string(),
   'days since the report was completed': z.number().nullable(),
   'tested web page': z.object({description: z.string(), URL: z.string()}),
@@ -196,7 +189,7 @@ const issueBasicsOrErrorSchema = z.union([
 
 // Facts about a report among those about one page.
 const reportTimeSchema = z.object({
-  identifier: z.string().describe('timeStamp-jobID identifier of the report.'),
+  identifier: z.string().describe('Identifier of the report (example: 260503T0432-x9z).'),
   'completion date and time': z.string(),
   'days since the report was completed': z.number().nullable()
 });
@@ -367,10 +360,7 @@ export const requestFeatureResponseSchema = envelope(
 );
 
 // Identifies the report a successfully ordered or awaited job will produce, once complete.
-const reportIdentifierSchema = z.object({
-  timeStamp: z.string().describe('Timestamp to pass to listIssues once the report is ready.'),
-  jobID: z.string().describe('Job identifier to pass to listIssues once the report is ready.')
-}).meta({id: 'ReportIdentifier'});
+const reportIdentifierSchema = z.string().describe('Identifier of the report, to pass to listIssues once the report is ready (example: 260503T0432-x9z).');
 
 export const orderNewTestResponseSchema = envelope(
   'POST',
@@ -443,7 +433,7 @@ export const awaitTestResponseSchema = envelope(
     'closest ancestor request': z.null()
   }),
   // awaitTest can be reached from either orderNewTest or orderRetest, and its own
-  // parameters (timeStamp/jobID) do not say which one produced them, so both possible
+  // reportID parameter does not say which one produced it, so both possible
   // ancestors are reported, rather than arbitrarily naming just one as "the" ancestor.
   z.array(requestReferenceSchema).length(2)
 );

package/api/util.test.ts

@@ -74,7 +74,7 @@ test('getIssueSpec returns null for the ignorable issue ID', () => {
 
 test('getReportBasics returns an error for a nonexistent report', async () => {
   process.env.DB_DIR = (await import('../test/dbFixture.ts')).fixtureDBDir;
-  const basics: any = await getReportBasics('999999T9999', 'xyz');
+  const basics: any = await getReportBasics('999999T9999-xyz');
   assert.ok(basics.error);
   if (savedDBDir !== undefined) {
     process.env.DB_DIR = savedDBDir;
@@ -91,7 +91,7 @@ test('getReportBasics returns an error for a report whose extract cannot be read
   const reportPath = path.join(process.env.DB_DIR, 'reports', '888888T8888-bad.json');
   await fs.writeFile(reportPath, '{"malformed": true}\n');
   try {
-    const basics: any = await getReportBasics('888888T8888', 'bad');
+    const basics: any = await getReportBasics('888888T8888-bad');
     assert.ok(basics.error);
   }
   finally {

package/api/util.ts

@@ -133,20 +133,20 @@ export const getRuleEnginesFacts = (ruleEngineIDSet: Iterable<string>) => {
 };
 // Returns the basics about a report, or an error object if the report cannot be read.
 export const getReportBasics = async (
-  timeStamp: string, jobID: string
+  reportID: string
 ): Promise<ReportBasics | {error: string}> => {
   // Verify that the report exists.
-  const reportStats = await getReportStats(timeStamp, jobID);
+  const reportStats = await getReportStats(reportID);
   // If it does not exist:
   if (!reportStats) {
     // Log and return this.
-    console.error(`Report ${timeStamp}-${jobID} does not exist.`);
+    console.error(`Report ${reportID} does not exist.`);
     return {
-      error: `Report ${timeStamp}-${jobID} could not be retrieved.`
+      error: `Report ${reportID} could not be retrieved.`
     };
   }
   // Otherwise, i.e. if it exists, get an extract of the report.
-  const extract = await getReportExtract(timeStamp, jobID);
+  const extract = await getReportExtract(reportID);
   // If this failed, return why.
   if ('error' in extract) {
     return extract;
@@ -154,10 +154,10 @@ export const getReportBasics = async (
   const {url, description, reportTime} = extract;
   // Get whether this report has been superseded.
   const isSuperseded = (await getReportExtracts(true))
-  .every(ex => ex.timeStamp !== timeStamp || ex.jobID !== jobID);
+  .every(ex => ex.id !== reportID);
   // Get the basics about the report.
   const basics = {
-    identifier: `${timeStamp}-${jobID}`,
+    identifier: reportID,
     'completion date and time': reportTime,
     'days since the report was completed': getAgoDays(new Date(reportTime)),
     'tested web page': {

package/capability.md

@@ -6,7 +6,7 @@ Web-page front-end quality audit. Kilotest tests web pages for front-end quality
 
 ## Purpose
 
-Language models and AI platforms often need accurate, page-specific data about the front-end quality of a web page to answer user questions. Rule engines, such as `axe-core`, `QualWeb`, and `WAVE`, provide such data, but with large coverage gaps. Orchestrating and reconciling numerous complementary rule engines would be difficult. Kilotest solves that problem by testing pages with an ensemble of numerous independent rule engines, making their results comparable, saving the results as JSON reports, and mining the reports for facts at selectable levels of detail.
+Language models and AI platforms often need accurate, page-specific data about the front-end quality of a web page to answer user questions. Any single rule engine, such as `axe-core`, `QualWeb`, or `WAVE`, provides such data, but with a large coverage gap. Orchestrating and reconciling numerous complementary rule engines would be difficult. Kilotest solves that problem by testing pages with an ensemble of numerous independent rule engines, making their results comparable, saving the results as JSON reports, and mining the reports for facts at selectable levels of detail.
 
 ## Interfaces
 
@@ -18,11 +18,11 @@ Language models and AI platforms often need accurate, page-specific data about t
 
 ## Initial input
 
-A request for a list of available reports.
+A request for a list of tested pages.
 
 ## Initial output
 
-A list of available reports.
+A list of tested pages, with URLs for requesting further details about their test results.
 
 ## Subsequent inputs
 
@@ -34,7 +34,7 @@ A list of available reports.
 
 - From a **request** for a new test or a retest: if valid, confirmation of receipt. If the request is manager-approved and executed, the list of available reports will include the new report, typically in 1 hour to 1 day.
 - From an **order** for a new test or a retest: if valid, confirmation of receipt and immediate approval or rejection. If the request is approved, the output will include the identifier of the forthcoming report and two methods for getting the report: (1) allowing time (2 to 4 minutes) for completion of the report and then requesting it, and (2) making a request whose response will await the report and then link to it. Orders are enabled in the MCP and API interfaces only.
-- From a request for findings: Details about issues reported, related WCAG standards, what rules were violated, and which DOM elements violated them.
+- From a request for findings: Details at several granularities about issues reported, related WCAG standards, what rules were violated, and which DOM elements violated them.
 - From complaints and suggestions about features: acknowledgment of receipt and of the manager being notified.
 
 ## Side effects

package/docs/AI-TOOLS.md

@@ -65,9 +65,49 @@ The external features that support the use of Kilotest as a collection of AI too
 Releasing a new version is a two-script procedure:
 
 - On a feature branch, commit all substantive changes, then execute `npm run prePR -- <level>` (`major`, `minor`, or `patch`). The script bumps `package.json` and `package-lock.json`, regenerates `openapi.yaml` and the versions of `server.json` and `lhm.plugin.json` via the `version` hook, commits and pushes the result, and records the branch name for the next step.
-- Submit a pull request and merge it to `main` (triggers `publish-mcp.yml` automatically for the MCP Registry).
+- Submit a pull request and merge it to `main` (triggers `publish-mcp.yml`, which publishes `server.json` to the MCP Registry).
 - Execute `npm run postPR`. The script checks out and pulls `main`, verifies that the merge landed, publishes to npm (whose `postpublish` hook updates the LobeHub listing), deletes the feature branch, and prunes remote-tracking branches. If the LobeHub update fails, retry it alone with `npm run publish:lhm`.
 
+### Contract changes and external registries
+
+A change to the tool or API contract (tool names, parameter names, schemas, response shapes, or paths) makes every stored copy of the contract stale. Which copies exist and what to do about each:
+
+#### In-repository contract copies
+
+- `openapi.yaml`: regenerated automatically by the `version` hook during `npm run prePR`; never edit it by hand.
+- `openapi-3.0.yaml`: an OpenAPI 3.0.3 conversion of `openapi.yaml`, regenerated by the same hook, for registries whose importers reject 3.1 documents; never edit it by hand.
+- `server.json`: contains only the server descriptor (name, description, repository, remotes, version), no tool schemas. Its version is synced by `update-versions.ts`; edit it manually only if the server description or remote URL changes.
+- `lhm.plugin.json`: embeds every tool’s input and output schema and its descriptions, in the LobeHub manifest format. It is hand-maintained, not generated, so transform it to match `api/schemas.ts` and `mcp.ts` whenever the contract changes.
+- `llms.txt`, `llms-full.txt`, `capability.md`, `README.md`: hand-maintained; search them for stale parameter and path names after a contract change.
+
+#### External registries that update themselves, needing no maintainer action
+
+- The official MCP Registry: `publish-mcp.yml` republishes `server.json` whenever `server.json` or `api/version.ts` changes on `main`, i.e. on every release. The listing contains no tool schemas, so a contract change alone needs nothing extra.
+- PulseMCP and the VS Code MCP gallery: crawl the MCP Registry.
+- Smithery and Glama: derive their tool listings from the deployed server’s own `tools/list` response (and repository scans) on their own crawl schedules. Their listings can lag temporarily behind a contract change, but they correct themselves.
+- `openapi-directory` (APIs.guru): maintains its own copy of `openapi.yaml`, refreshed from the registered source URL on its own schedule.
+- `public-apis`, the WAI evaluation tools list, Awesome MCP Servers, and the Claude connector directory: store only a link or a connector name and remote URL; contract changes do not affect them.
+
+#### External registries requiring maintainer action
+
+- The LobeHub MCP Market listing is published from `lhm.plugin.json` and is non-automated, because LobeHub requires browser-based OAuth. A normal release pushes the updated file via the `postpublish` hook; to push a contract update without a release, run `npm run publish:lhm`.
+- The RapidAPI Hub listing stores a copy of the API endpoints. Its importer accepts only OpenAPI 3.0 documents, so after releasing a contract change, update the definition in Studio: `My APIs` → the Kilotest API project → `Hub Listing` → `Definitions` → `CI/CD` → `Import OpenAPI`, and upload the regenerated `openapi-3.0.yaml` (not `openapi.yaml`, which is 3.1 and is rejected). The `/publish/…` pages contain only listing metadata, not the spec.
+
+#### Step by step
+
+When you make an API or tool contract change in a feature branch, here are all the maintenance steps:
+
+1. `lhm.plugin.json`: Transform it to match `api/schemas.ts` and `mcp.ts`.
+2. `llms.txt`, `llms-full.txt`, `capability.md`, `README.md`: Update parameter and path names.
+3. Stage and commit all changes.
+4. Execute `npm run prePR -- <level>` (`major`, `minor`, or `patch`).
+5. Submit a pull request.
+6. When all checks succeed, squash-merge to `main`.
+7. Execute `npm run postPR` (with interactive browser OAuth).
+8. Visit the [RapidAPI Studio](https://rapidapi.com/studio) and update the API definition at `Hub Listing` → `Definitions` → `CI/CD` → `Import OpenAPI` by uploading the regenerated `openapi-3.0.yaml`.
+
+If any step fails, see the details above for troubleshooting instructions.
+
 ## Use cases
 
 The rationale for Kilotest as a collection of tools for language models is set forth in the `llms-full.txt` file and is not repeated here.

package/docs/decisions/009-report-id.md

@@ -0,0 +1,16 @@
+---
+date: 2026-10-17
+status: accepted
+---
+
+# Report identifier
+
+## Context, problem, and decision
+
+Kilotest identifies each report with a string composed of the creation time stamp of the job that produced the report, in `YYMMDDTHHmm` format, and a random alphanumeric suffix, joined with a hyphen (example: `260503T0432-x9z`). The storage layer already treats this composed string as a unit: it is the report filename stem, the job identifier, and the value emitted as the report `identifier` in API responses.
+
+Formerly, however, the request surfaces treated the identifier as two parameters, `timeStamp` and `jobID`, so that URLs had the form `/api/listIssues/{timeStamp}/{jobID}` and MCP tools took separate `timeStamp` and `jobID` inputs. The two components were never decomposed for separate semantic use: every split site recombined them immediately or validated them separately for no benefit. The split representation therefore added parameters, path segments, and boilerplate without adding meaning.
+
+The identifier is now consistently treated as a unit named `reportID`, validated by a single `isReportID` predicate. Routes that had `{timeStamp}` and `{jobID}` path parameters now have one `{reportID}` parameter. The name `reportID`, rather than `jobID`, is used because a job is ephemeral (typically a few minutes), while a report lives indefinitely and is consulted repeatedly.
+
+Because human users may have bookmarked web URLs containing the two-segment tail, legacy web paths redirect permanently (301 for GET, 308 for POST) to the single-parameter URLs, preserving query strings. The REST API and the MCP interface had no known consumers when this change was made, so they were cut over without transitional compatibility; the external registry listings (`openapi.yaml`, `server.json`, `lhm.plugin.json`) were updated quasi-simultaneously.