@intentius/chant 0.124.26 → 0.124.28

package/src/workspace/change-set-show.schema.json

@@ -0,0 +1,102 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://intentius.io/chant/schemas/workspace/change-set-show/v1/change-set-show.schema.json",
+  "title": "chant change-set show output",
+  "description": "What `chant change-set show <digest> --json` prints (#4022): the change-set document a gate bound, stored on chant/lifecycle under its digest (_change-sets/<digest>.json, under _members/<member>/ for a workspace member). A pull-request gate's apply stores it, and chant components promote --release stores a release gate's (#4045), which names the release and environment it was planned for. Each entry carries the graph node it changes. It reads the local chant/lifecycle branch and never fetches. Version 1 of the read contract. Readers ignore fields they do not know; a field is only ever added within a version. The codes are a closed list, each in the one closed list of `reason-codes.ts`. Contract version 1 of this document is written by chant 0.124.28 and newer; the read contract as a whole by chant 0.81.0 and newer.",
+  "oneOf": [{ "$ref": "#/$defs/result" }, { "$ref": "#/$defs/failure" }],
+  "$defs": {
+    "result": {
+      "type": "object",
+      "description": "The ledger was read. Exit code 0 when a change set is shown, 1 when changeSet is null.",
+      "required": ["$schema", "contract", "chant", "member", "digest", "changeSet", "reason"],
+      "properties": {
+        "$schema": { "const": "https://intentius.io/chant/schemas/workspace/change-set-show/v1/change-set-show.schema.json" },
+        "contract": { "const": 1 },
+        "chant": { "type": "string" },
+        "error": false,
+        "member": {
+          "type": ["string", "null"],
+          "description": "The member whose ledger was read, its path of names joined with / when nested, or null for a project outside a workspace."
+        },
+        "digest": {
+          "type": "string",
+          "pattern": "^(?:jcs1-)?sha256:[0-9a-f]{64}$",
+          "description": "The digest asked for: a gate's planDigest."
+        },
+        "changeSet": {
+          "description": "The stored change-set document (change-set.schema.json), whose digest equals digest. Each entry has node, the graph node it changes as chant workspace graph names it (<member>/<id> in a workspace), or null when the graph holds no node for its address. Its graph says which member's graph that was and the commit it was read at, or is null when no graph could be read. Null when nothing is stored under digest, as for a component gate, which binds a lifecycle-plan digest, and when reason is ledger-malformed.",
+          "oneOf": [
+            { "type": "null" },
+            {
+              "type": "object",
+              "required": ["$schema", "contract", "digest", "members", "entries", "summary"],
+              "properties": {
+                "$schema": { "const": "https://intentius.io/chant/schemas/workspace/change-set/v1/change-set.schema.json" },
+                "contract": { "const": 1 },
+                "digest": { "type": "string" },
+                "releaseDigest": { "type": "string", "description": "Added in contract 1 by #4045, written by chant 0.124.28 and newer: the release a release gate's change set was planned for. Absent on a pull request's." },
+                "environment": { "type": "string", "description": "Added in contract 1 by #4045, written by chant 0.124.28 and newer: the environment a release gate's change set was planned for. Absent on a pull request's." },
+                "members": { "type": "array" },
+                "entries": {
+                  "type": "array",
+                  "items": {
+                    "type": "object",
+                    "required": ["member", "address", "action", "node"],
+                    "properties": {
+                      "node": { "type": ["string", "null"] }
+                    }
+                  }
+                },
+                "graph": {
+                  "oneOf": [
+                    { "type": "null" },
+                    {
+                      "type": "object",
+                      "required": ["member", "at"],
+                      "properties": {
+                        "member": { "type": ["string", "null"] },
+                        "at": { "type": ["string", "null"] }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        },
+        "reason": {
+          "description": "Null when the file was read, or when none is stored. ledger-malformed when a file is stored under digest and it is not a change-set document whose content hashes to digest.",
+          "oneOf": [
+            { "type": "null" },
+            {
+              "type": "object",
+              "required": ["code", "message"],
+              "properties": {
+                "code": { "enum": ["ledger-malformed"] },
+                "message": { "type": "string" }
+              }
+            }
+          ]
+        }
+      }
+    },
+    "failure": {
+      "type": "object",
+      "description": "Nothing was read. Exit code 1.",
+      "required": ["$schema", "contract", "chant", "error"],
+      "properties": {
+        "$schema": { "const": "https://intentius.io/chant/schemas/workspace/change-set-show/v1/change-set-show.schema.json" },
+        "contract": { "const": 1 },
+        "chant": { "type": "string" },
+        "error": {
+          "type": "object",
+          "required": ["code", "message"],
+          "properties": {
+            "code": { "enum": ["not-a-git-repository", "ledger-unreadable"] },
+            "message": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

package/src/workspace/change-set-show.ts

@@ -0,0 +1,72 @@
+/**
+ * The stored change-set read (#4022): `chant change-set show <digest> --json`.
+ *
+ * Prints the change-set document a gate bound, as `components pr-apply`
+ * stored it, or as a release gate stores it with #4045
+ * (`../lifecycle/change-set-store.ts`). Each entry carries the graph `node`
+ * it changes, as `chant workspace graph` names nodes. It reads the local
+ * `chant/lifecycle` branch and never fetches.
+ *
+ * A digest with nothing stored under it is a result with `changeSet: null`,
+ * since a component gate binds a lifecycle-plan digest and stores no
+ * document. A stored file that is not the document its digest names is also
+ * `changeSet: null`, with the reason `ledger-malformed`. A read that fails
+ * outright is the failure `ledger-unreadable`.
+ */
+
+import { execFileSync } from "node:child_process";
+import type { ChangeSetDocument } from "../change-set";
+import { readStoredChangeSet } from "../lifecycle/change-set-store";
+import { resolveMemberLedger } from "../lifecycle/member-ledger";
+import { readerVersion } from "./declaration";
+
+export const CHANGE_SET_SHOW_CONTRACT_VERSION = 1;
+export const CHANGE_SET_SHOW_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/change-set-show/v1/change-set-show.schema.json";
+
+/** Why the read stopped. Closed; each code is in `reason-codes.ts`. */
+export const CHANGE_SET_SHOW_ERROR_CODES = ["not-a-git-repository", "ledger-unreadable"] as const;
+/** Why a stored file was not shown. */
+export const CHANGE_SET_SHOW_REASON_CODES = ["ledger-malformed"] as const;
+
+/** What a change-set digest looks like: a plan digest's form. */
+export const CHANGE_SET_DIGEST_PATTERN = /^(?:jcs1-)?sha256:[0-9a-f]{64}$/;
+
+export type ChangeSetShowDocument =
+  | {
+      $schema: string;
+      contract: number;
+      chant: string;
+      /** The member whose ledger was read, its path of names joined with `/`, or null outside a workspace. */
+      member: string | null;
+      digest: string;
+      /** The stored document, or null when none is stored under the digest. */
+      changeSet: ChangeSetDocument | null;
+      reason: { code: (typeof CHANGE_SET_SHOW_REASON_CODES)[number]; message: string } | null;
+    }
+  | { $schema: string; contract: number; chant: string; error: { code: (typeof CHANGE_SET_SHOW_ERROR_CODES)[number]; message: string } };
+
+/**
+ * Read the change set stored under `digest` in the ledger of the member at
+ * `cwd`, or of `member` (its path of names, outermost first) when given.
+ */
+export async function changeSetShowDocument(req: { cwd: string; digest: string; member?: readonly string[] }): Promise<ChangeSetShowDocument> {
+  const head = { $schema: CHANGE_SET_SHOW_SCHEMA_ID, contract: CHANGE_SET_SHOW_CONTRACT_VERSION, chant: readerVersion() };
+  try {
+    execFileSync("git", ["rev-parse", "--git-dir"], { cwd: req.cwd, stdio: "ignore" });
+  } catch {
+    return { ...head, error: { code: "not-a-git-repository", message: "change sets are read from the chant/lifecycle branch, and this directory is not in a git repository" } };
+  }
+  try {
+    const members = req.member ? [...req.member] : (await resolveMemberLedger(req.cwd)).members;
+    const read = await readStoredChangeSet(req.digest, { cwd: req.cwd, member: members });
+    return {
+      ...head,
+      member: members.length > 0 ? members.join("/") : null,
+      digest: req.digest,
+      changeSet: read.status === "found" ? read.document : null,
+      reason: read.status === "malformed" ? { code: "ledger-malformed", message: read.message } : null,
+    };
+  } catch (err) {
+    return { ...head, error: { code: "ledger-unreadable", message: `reading the change set failed: ${err instanceof Error ? err.message : String(err)}` } };
+  }
+}

package/src/workspace/change-set.schema.json

@@ -26,7 +26,16 @@
     "digest": {
       "type": "string",
       "pattern": "^(?:jcs1-)?sha256:[0-9a-f]{64}$",
-      "description": "computePlanDigest(\"change-set-document\", \u2026) over the set digest (computePlanDigest(\"change-set\", \u2026) over the members' { member, planDigest } pairs sorted by member), each member's member, status and holes, the entries and the side effects, provisional members and their entries left out. What a gate over the whole run binds."
+      "description": "computePlanDigest(\"change-set-document\", \u2026) over the set digest (computePlanDigest(\"change-set\", \u2026) over the members' { member, planDigest } pairs sorted by member), each member's member, status and holes, the entries without their node, the side effects, and on a release gate's document its releaseDigest and environment, provisional members and their entries left out. What a gate over the whole run binds."
+    },
+    "releaseDigest": {
+      "type": "string",
+      "pattern": "^(?:jcs1-)?sha256:[0-9a-f]{64}$",
+      "description": "Added in contract 1 by #4045, written by chant 0.124.28 and newer. The release a release gate's change set was planned for: the releaseDigest of the release chant components promote --release deploys. Set with environment, and absent on every other change set. Part of digest, so a stored change set names the one release its gate bound."
+    },
+    "environment": {
+      "type": "string",
+      "description": "Added in contract 1 by #4045, written by chant 0.124.28 and newer. The environment a release gate's change set was planned for, set with releaseDigest. Part of digest."
     },
     "members": {
       "type": "array",
@@ -59,6 +68,20 @@
     },
     "summary": {
       "$ref": "#/$defs/summary"
+    },
+    "graph": {
+      "description": "Added in contract 1 by #4022, written by chant 0.124.28 and newer on a stored change set. The graph the entries' node ids come from: the workspace member whose graph it is (null outside a workspace) and the commit it was read at (null when unknown). Null when no graph could be read, so every node is null. Absent on a document never mapped. Not part of digest.",
+      "oneOf": [
+        { "type": "null" },
+        {
+          "type": "object",
+          "required": ["member", "at"],
+          "properties": {
+            "member": { "type": ["string", "null"] },
+            "at": { "type": ["string", "null"] }
+          }
+        }
+      ]
     }
   },
   "$defs": {
@@ -244,6 +267,10 @@
           "items": {
             "$ref": "#/$defs/attribute"
           }
+        },
+        "node": {
+          "type": ["string", "null"],
+          "description": "Added in contract 1 by #4022, written by chant 0.124.28 and newer on a stored change set (chant change-set show). The graph node the entry changes, as chant graph --format ir names it, with the member in front (<member>/<id>) inside a workspace, as chant workspace graph names it. A chant entry's node is its address; a terraform-family entry's is <root>/<block key>, where the block key is each module call as module.<name>/ and then the block's address with no index. Null when the graph holds no node for the address, such as a delete of a block the source no longer declares. Absent on a document never mapped onto a graph. Not part of digest."
         }
       }
     },

package/src/workspace/changes-cli.ts

@@ -32,13 +32,22 @@ export function formatChanges(doc: Result): string {
     out.push(`${p.status.padEnd(12)} ${p.change.padEnd(8)} ${p.path}${p.from ? ` (from ${p.from})` : ""}${why ? `; ${why}` : ""}`);
   }
   for (const f of doc.findings) out.push(`${f.severity === "fail" ? "error  " : "warning"}   ${f.code}: ${f.message}`);
+  if (doc.links) {
+    const l = doc.links;
+    const n = (state: string) => l.commits.filter((c) => c.state === state).length;
+    out.push(`links     ${l.commits.length} commits: ${n("linked")} name a work item, ${n("unlinked")} do not, ${n("wrong")} name one that is not there; work kinds: ${l.kinds.join(", ")}`);
+    for (const f of l.findings) {
+      out.push(`${f.severity === "fail" ? "error  " : "warning"}   ${f.code}: ${f.message}`);
+      out.push(`          fix: ${f.fix}`);
+    }
+  }
   if (doc.scope) {
     const sc = doc.scope;
     out.push(`scope     ${sc.commits.length} commits judged against the declaration at ${sc.base.slice(0, 8)}; restricted: ${sc.restricted.join(", ") || "none"}`);
     for (const f of sc.findings) out.push(`error     ${f.code}: ${f.message}`);
   }
   const s = doc.summary;
-  out.push(`${s.paths} changed paths: ${s.covered} covered, ${s.uncovered} uncovered, ${s.outOfScope} out of scope, ${s.ignored} ignored, ${s.records} records; ${doc.findings.length} findings`);
+  out.push(`${s.paths} changed paths: ${s.covered} covered, ${s.uncovered} uncovered, ${s.outOfScope} out of scope, ${s.ignored} ignored, ${s.records} records; ${doc.findings.length} findings${doc.links ? `, ${doc.links.findings.length} commit link findings` : ""}`);
   return out.join("\n");
 }
 

package/src/workspace/changes.schema.json

@@ -210,6 +210,17 @@
             }
           ]
         },
+        "links": {
+          "description": "Whether each trunk commit of the range names the work item it belongs to (#4029): the first-parent commits of base..head, merges left out. A commit names one with a `Chant-Record: <kind>:<id>` trailer of a work kind the declaration names, or a `Chant-Lease` trailer a lease history on chant/lifecycle resolves to a work item. A window match does not count. Null when no work kind was read. The field is added within contract version 1, and is written by chant 0.124.28 and newer; a reader that finds none is reading an older chant. Its findings follow `severity`, like `findings`.",
+          "oneOf": [
+            {
+              "type": "null"
+            },
+            {
+              "$ref": "#/$defs/links"
+            }
+          ]
+        },
         "ok": {
           "type": "boolean",
           "description": "False when severity is fail and there is a finding, or when scope has a finding."
@@ -637,6 +648,130 @@
           "type": "string"
         }
       }
+    },
+    "links": {
+      "type": "object",
+      "required": [
+        "kinds",
+        "commits",
+        "findings"
+      ],
+      "properties": {
+        "kinds": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The work kinds read, by name. A Chant-Record links a commit only when its kind is one of these."
+        },
+        "commits": {
+          "type": "array",
+          "description": "Oldest first.",
+          "items": {
+            "$ref": "#/$defs/linkCommit"
+          }
+        },
+        "findings": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/linkFinding"
+          }
+        }
+      }
+    },
+    "linkCommit": {
+      "type": "object",
+      "required": [
+        "commit",
+        "subject",
+        "state",
+        "ids",
+        "problems"
+      ],
+      "properties": {
+        "commit": {
+          "type": "string",
+          "pattern": "^[0-9a-f]{40,64}$"
+        },
+        "subject": {
+          "type": "string"
+        },
+        "state": {
+          "enum": [
+            "linked",
+            "unlinked",
+            "wrong"
+          ],
+          "description": "linked: a trailer names a work record that exists, or a lease that resolves to one (a lease is taken as linked when this checkout has no chant/lifecycle branch to read). unlinked: no Chant-Record or Chant-Lease trailer names anything. wrong: trailers name a work item but none of them is one that exists."
+        },
+        "ids": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The work records the trailers name, as <kind>:<id>. Empty unless state is linked."
+        },
+        "problems": {
+          "type": "array",
+          "description": "The trailers that do not link the commit. Empty unless state is wrong.",
+          "items": {
+            "type": "object",
+            "required": [
+              "trailer",
+              "message"
+            ],
+            "properties": {
+              "trailer": {
+                "type": "string",
+                "description": "The trailer as written, such as Chant-Record: decision:ws-075."
+              },
+              "message": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      }
+    },
+    "linkFinding": {
+      "type": "object",
+      "required": [
+        "id",
+        "code",
+        "commit",
+        "message",
+        "fix",
+        "severity"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "finding:<code>:<commit>."
+        },
+        "code": {
+          "enum": [
+            "commit-unlinked",
+            "commit-wrongly-linked"
+          ]
+        },
+        "commit": {
+          "type": "string",
+          "pattern": "^[0-9a-f]{40,64}$"
+        },
+        "message": {
+          "type": "string"
+        },
+        "fix": {
+          "type": "string",
+          "description": "What to change so the commit names its work item."
+        },
+        "severity": {
+          "enum": [
+            "warn",
+            "fail"
+          ]
+        }
+      }
     }
   }
 }

package/src/workspace/changes.test.ts

@@ -308,7 +308,7 @@ describe("the forward coverage check (#2773)", () => {
     const step = await changeCoverage({ cwd: tree });
     expect(step).toMatchObject({ ok: true, work: "work/W-001", severity: "warn", summary: { paths: 2, covered: 1, uncovered: 1 } });
     expect(step.findings).toEqual([expect.objectContaining({ code: "change-uncovered", path: "docs/readme.md", triage: { finding: "change-uncovered", region: "docs/readme.md" } })]);
-    await expect(changeCoverage({ cwd: tree, severity: "fail" })).rejects.toThrow(/1 change finding at severity fail: change-uncovered docs\/readme.md/);
+    await expect(changeCoverage({ cwd: tree, severity: "fail" })).rejects.toThrow(/2 change findings at severity fail: change-uncovered docs\/readme.md, commit-unlinked /);
     await expect(changeCoverage({ cwd: root })).rejects.toThrow(/not on a chant\/work\/ branch/);
     git(root, "worktree", "remove", "--force", tree);
   });

package/src/workspace/changes.ts

@@ -42,8 +42,9 @@ import { relative, resolve, sep } from "node:path";
 import picomatch from "picomatch";
 import { declaredRecordKinds, readDeclaration, readerVersion, WORKSPACE_ERROR_CODES, WorkspaceReadError, type ChangeSeverity, type Declaration } from "./declaration";
 import { declaredKindFile } from "./declared-kinds";
+import { COMMIT_UNLINKED_FIX, hasLeaseLedger, judgeCommits, mergeCommits, type CommitLink, type WorkIndex } from "./commit-links";
 import { isGeneratedPath } from "./generated-files";
-import { parseRegion } from "./intent";
+import { commitDetails, parseRegion } from "./intent";
 import { loadClassRegistry } from "./principal-classes";
 import { constraintCovers, isWorkspacePath, memberHolding } from "./record-assets";
 import { loadRecordKind, RecordReadError, type LoadedRecordKind, type RecordEntry } from "./records";
@@ -69,6 +70,45 @@ export const CHANGES_FINDING_CODES = [
 ] as const satisfies readonly ReasonCode[];
 export type ChangesFindingCode = (typeof CHANGES_FINDING_CODES)[number];
 
+/** The codes of a finding on a commit rather than a path (#4029). Closed. */
+export const COMMIT_LINK_FINDING_CODES = [
+  /** A trunk commit in the range names no work item: no Chant-Record of a work kind and no Chant-Lease. */
+  "commit-unlinked",
+  /** A trunk commit in the range names a work item that is not there: a record id no work kind has, a record of another kind, or a lease that resolves to nothing. */
+  "commit-wrongly-linked",
+] as const satisfies readonly ReasonCode[];
+export type CommitLinkFindingCode = (typeof COMMIT_LINK_FINDING_CODES)[number];
+
+/** One non-merge first-parent commit of the range, with whether it names a work item. */
+export interface LinkCommit {
+  commit: string;
+  subject: string;
+  state: Exclude<CommitLink["state"], "merge">;
+  /** The work records its trailers name, as `<kind>:<id>`. */
+  ids: string[];
+  /** The trailers that do not link it, when `state` is `wrong`. */
+  problems: CommitLink["problems"];
+}
+
+export interface LinkFinding {
+  /** `finding:<code>:<commit>`. */
+  id: string;
+  code: CommitLinkFindingCode;
+  commit: string;
+  message: string;
+  /** What to change so the commit names its work item. */
+  fix: string;
+  severity: "warn" | "fail";
+}
+
+/** Whether the range's commits name their work items (#4029). */
+export interface LinkReport {
+  /** The work kinds read, by name. */
+  kinds: string[];
+  commits: LinkCommit[];
+  findings: LinkFinding[];
+}
+
 /** Why the check failed as a whole: the declaration's codes, the record kind's, or a `--work` item no record has. */
 export const CHANGES_ERROR_CODES = [
   ...WORKSPACE_ERROR_CODES,
@@ -180,6 +220,12 @@ export type ChangesDocument =
        * or null when that declaration restricts no one.
        */
       scope: ScopeReport | null;
+      /**
+       * Whether each trunk commit of the range names the work item it belongs
+       * to (#4029), or null when no work kind was read. Findings follow the
+       * severity, like `findings`.
+       */
+      links: LinkReport | null;
       /** False when severity is fail and there are findings, or when a commit writes outside its writer's scope. */
       ok: boolean;
     })
@@ -472,6 +518,7 @@ async function run(query: ChangesQuery, head: Head): Promise<Exclude<ChangesDocu
   }
   const count = (s: ChangeStatus) => paths.filter((p) => p.status === s).length;
   const scope = await writeScopeAtBase(query, top, range, workspacePrefix);
+  const links = commitLinks(top, range, kinds, severity);
   return {
     ...head,
     workspace: { name: declaration.name, root: located.root },
@@ -484,8 +531,43 @@ async function run(query: ChangesQuery, head: Head): Promise<Exclude<ChangesDocu
     findings,
     summary: { paths: paths.length, covered: count("covered"), uncovered: count("uncovered"), outOfScope: count("out-of-scope"), ignored: count("ignored"), records: count("record") },
     scope,
-    ok: !(severity === "fail" && findings.length > 0) && (scope === null || scope.findings.length === 0),
+    links,
+    ok: !(severity === "fail" && (findings.length > 0 || (links?.findings.length ?? 0) > 0)) && (scope === null || scope.findings.length === 0),
+  };
+}
+
+/**
+ * Whether each trunk commit of the range, first-parent and merges left out,
+ * names a work item (#4029). Records are read at the head, as the paths are.
+ * Null when no work kind was read.
+ */
+function commitLinks(top: string, range: { base: string; head: string }, kinds: ReadKind[], severity: ChangeSeverity): LinkReport | null {
+  const work = kinds.filter((k) => k.role === "work");
+  if (work.length === 0) return null;
+  const index: WorkIndex = {
+    kinds: new Map(work.map((k) => [k.loaded.kind.name, new Set(k.records.flatMap((r) => (r.id === null ? [] : [r.id])))])),
+    ledger: hasLeaseLedger(top),
   };
+  const shas = git(top, ["rev-list", "--first-parent", "--reverse", `${range.base}..${range.head}`]).split("\n").filter(Boolean);
+  const judged = judgeCommits(top, shas, index, mergeCommits(top, shas));
+  const details = commitDetails(top, shas);
+  const commits: LinkCommit[] = [];
+  const findings: LinkFinding[] = [];
+  for (const sha of shas) {
+    const link = judged.get(sha)!;
+    if (link.state === "merge") continue;
+    const subject = details.get(sha)?.subject ?? "";
+    commits.push({ commit: sha, subject, state: link.state, ids: link.ids, problems: link.problems });
+    if (link.state === "linked" || severity === "off") continue;
+    const short = sha.slice(0, 8);
+    if (link.state === "unlinked") {
+      findings.push({ id: `finding:commit-unlinked:${sha}`, code: "commit-unlinked", commit: sha, severity, message: `${short} "${subject}" carries no Chant-Record trailer of a work kind and no Chant-Lease trailer, so it names no work item`, fix: COMMIT_UNLINKED_FIX });
+    } else {
+      const named = link.problems.map((p) => `${p.trailer} (${p.message})`).join("; ");
+      findings.push({ id: `finding:commit-wrongly-linked:${sha}`, code: "commit-wrongly-linked", commit: sha, severity, message: `${short} "${subject}" names no work item that exists: ${named}`, fix: `correct the trailer to name an existing work record, \`Chant-Record: ${[...index.kinds.keys()][0]}:<id>\`, or a lease taken on one` });
+    }
+  }
+  return { kinds: [...index.kinds.keys()], commits, findings };
 }
 
 /**