@nimiplatform/nimi-coding 0.3.1 → 0.5.0

package/cli/lib/authority/closed-sets.mjs

@@ -0,0 +1,645 @@
+import { Buffer } from "node:buffer";
+import { lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+
+import YAML, { isMap, isScalar, isSeq } from "yaml";
+
+import { compileAuthorityPath } from "./compile.mjs";
+import { compareText, makeDiagnostic, sortDiagnostics } from "./diagnostics.mjs";
+import { AuthorityInputError } from "./format.mjs";
+import { AuthorityReviewRefusal } from "./git-snapshot.mjs";
+import { resolveRepositoryCorpus } from "./repository-corpus.mjs";
+import { repositoryInventory } from "./repository-inventory.mjs";
+import { normativeFields } from "./lexicon.mjs";
+import { classifyTrackedTextFiles } from "./tracked-text.mjs";
+
+const CLOSED_SETS_FORMAT = "nimicoding.authority-closed-sets/v1";
+const MEMBER = /^[A-Za-z][A-Za-z0-9_.-]*$/u;
+const MEMBER_CHARACTER = /[A-Za-z0-9_.-]/u;
+const UTF8 = new TextDecoder("utf-8", { fatal: true });
+
+function validBudget(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+
+function baseDiagnostic(code, reason, repair, file = ".") {
+  return makeDiagnostic({
+    code,
+    file,
+    range: { start: { line: 1, column: 1 }, end: { line: 1, column: 1 } },
+    reason,
+    repair,
+  });
+}
+
+function budgetDiagnostic(kind, required, admitted) {
+  const option = kind === "active units" ? "max-units" : kind === "implementation sets" ? "max-sets" : "max-bytes";
+  return baseDiagnostic(
+    "AUTH_CLOSED_SETS_BUDGET",
+    `complete closed-set analysis requires ${required} ${kind} but ${option} is ${admitted}`,
+    "increase the explicit closed-set budget; partial inventories, pairings, and drift reports are forbidden",
+  );
+}
+
+function inputDiagnostic(code, reason, file = ".") {
+  return baseDiagnostic(
+    code,
+    reason,
+    "provide one exact readable Git repository, admitted canonical corpus, and valid tracked implementation inputs; partial analysis is forbidden",
+    file,
+  );
+}
+
+function refused(diagnostics, { fileCount = 0 } = {}) {
+  return {
+    ok: false,
+    complete: false,
+    partial: false,
+    diagnostics: sortDiagnostics(diagnostics),
+    fileCount,
+    unitCount: 0,
+    scannedBytes: 0,
+    inputBytes: 0,
+    summary: null,
+    closedSets: null,
+  };
+}
+
+function portableRelative(repository, candidate) {
+  return path.relative(repository, candidate).split(path.sep).join(path.posix.sep);
+}
+
+async function resolveCorpus(repository, specPath) {
+  return resolveRepositoryCorpus(repository, specPath, "closed-set authority");
+}
+
+export function normalizeClosedSetMember(member) {
+  return member.toLowerCase().replaceAll(/[_.-]/gu, "");
+}
+
+function memberAt(text, offset) {
+  if (offset >= text.length || !/[A-Za-z]/u.test(text[offset])) return null;
+  let end = offset + 1;
+  while (end < text.length && MEMBER_CHARACTER.test(text[end])) end += 1;
+  let value = text.slice(offset, end);
+  if (value.endsWith(".") && value.length > 1) value = value.slice(0, -1);
+  return MEMBER.test(value) ? { value, end } : null;
+}
+
+function spacesAt(text, offset) {
+  let end = offset;
+  while (end < text.length && /[\t ]/u.test(text[end])) end += 1;
+  return end;
+}
+
+function conjunctionAt(text, offset) {
+  for (const word of ["and", "or"]) {
+    if (text.slice(offset, offset + word.length) !== word) continue;
+    const next = offset + word.length;
+    if (next < text.length && /[\t ]/u.test(text[next])) return spacesAt(text, next);
+  }
+  return null;
+}
+
+function hasWordContinuation(text, offset) {
+  if (text[offset - 1] === ".") return false;
+  const spaced = spacesAt(text, offset);
+  return spaced > offset && /[A-Za-z]/u.test(text[spaced] ?? "");
+}
+
+function parseCommaRun(text, start) {
+  const first = memberAt(text, start);
+  if (first === null) return null;
+  const members = [first.value];
+  let cursor = first.end;
+  let commaCount = 0;
+  while (true) {
+    const beforeSeparator = cursor;
+    const spaced = spacesAt(text, cursor);
+    if (text[spaced] === ",") {
+      commaCount += 1;
+      let next = spacesAt(text, spaced + 1);
+      const conjunctionEnd = conjunctionAt(text, next);
+      if (conjunctionEnd !== null) {
+        const final = memberAt(text, conjunctionEnd);
+        if (final === null) return { members, end: beforeSeparator, commaCount: commaCount - 1, invalid: false };
+        members.push(final.value);
+        return { members, end: final.end, commaCount, invalid: hasWordContinuation(text, final.end) };
+      }
+      const item = memberAt(text, next);
+      if (item === null) return { members, end: beforeSeparator, commaCount: commaCount - 1, invalid: false };
+      members.push(item.value);
+      cursor = item.end;
+      continue;
+    }
+    if (members.length >= 2) {
+      const conjunctionEnd = conjunctionAt(text, spaced);
+      if (conjunctionEnd !== null) {
+        const final = memberAt(text, conjunctionEnd);
+        if (final !== null) {
+          members.push(final.value);
+          return { members, end: final.end, commaCount, invalid: hasWordContinuation(text, final.end) };
+        }
+      }
+    }
+    return { members, end: cursor, commaCount, invalid: hasWordContinuation(text, cursor) };
+  }
+}
+
+export function extractCommaRunEnumerations(text) {
+  const groups = [];
+  let cursor = 0;
+  while (cursor < text.length) {
+    if (!/[A-Za-z]/u.test(text[cursor]) || (cursor > 0 && (MEMBER_CHARACTER.test(text[cursor - 1]) || text[cursor - 1] === "/"))) {
+      cursor += 1;
+      continue;
+    }
+    const parsed = parseCommaRun(text, cursor);
+    if (parsed !== null && !parsed.invalid && parsed.members.length >= 3 && parsed.commaCount >= 1) {
+      const following = text[parsed.end] ?? "";
+      if (following !== "/" && !MEMBER_CHARACTER.test(following)) {
+        const members = [...parsed.members];
+        if (members.at(-1)?.endsWith(".") && members.at(-1).length > 1) members[members.length - 1] = members.at(-1).slice(0, -1);
+        groups.push(members);
+        cursor = parsed.end;
+        continue;
+      }
+    }
+    const token = memberAt(text, cursor);
+    cursor = token?.end ?? cursor + 1;
+  }
+  return groups;
+}
+
+function canonicalGroups(compiled) {
+  const groups = [];
+  let scannedBytes = 0;
+  for (const unit of compiled.ir.units) {
+    if (unit.lifecycle !== "active") continue;
+    // Scan every normative field, not just the headline one. A rule's closed
+    // vocabulary is as often stated in its condition or failure as in its
+    // statement, and scanning two of the four fields silently dropped those.
+    for (const field of normativeFields(unit.kind)) {
+      const text = unit.semantic[field];
+      scannedBytes += Buffer.byteLength(text, "utf8");
+      for (const members of extractCommaRunEnumerations(text)) groups.push({ unitId: unit.id, field, members });
+    }
+  }
+  groups.sort((left, right) => compareText(left.unitId, right.unitId) || compareText(left.field, right.field));
+  return { groups, scannedBytes };
+}
+
+function maskProto(text) {
+  const output = text.split("");
+  let state = "code";
+  let quote = "";
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (state === "line-comment") {
+      if (character === "\n") state = "code";
+      else output[index] = " ";
+    } else if (state === "block-comment") {
+      if (character === "*" && next === "/") {
+        output[index] = " ";
+        output[index + 1] = " ";
+        index += 1;
+        state = "code";
+      } else if (character !== "\n" && character !== "\r") output[index] = " ";
+    } else if (state === "string") {
+      if (character === "\\") {
+        output[index] = " ";
+        if (index + 1 < text.length) {
+          output[index + 1] = " ";
+          index += 1;
+        }
+      } else if (character === quote) {
+        output[index] = " ";
+        state = "code";
+      } else if (character !== "\n" && character !== "\r") output[index] = " ";
+    } else if (character === "/" && next === "/") {
+      output[index] = " ";
+      output[index + 1] = " ";
+      index += 1;
+      state = "line-comment";
+    } else if (character === "/" && next === "*") {
+      output[index] = " ";
+      output[index + 1] = " ";
+      index += 1;
+      state = "block-comment";
+    } else if (character === "\"" || character === "'") {
+      output[index] = " ";
+      quote = character;
+      state = "string";
+    }
+  }
+  return output.join("");
+}
+
+function closingBrace(text, opening) {
+  let depth = 0;
+  for (let index = opening; index < text.length; index += 1) {
+    if (text[index] === "{") depth += 1;
+    else if (text[index] === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function topLevelBody(body) {
+  const output = body.split("");
+  let depth = 0;
+  for (let index = 0; index < body.length; index += 1) {
+    if (body[index] === "{") {
+      depth += 1;
+      output[index] = " ";
+    } else if (body[index] === "}") {
+      output[index] = " ";
+      depth = Math.max(0, depth - 1);
+    } else if (depth > 0 && body[index] !== "\n" && body[index] !== "\r") output[index] = " ";
+  }
+  return output.join("");
+}
+
+function enumPrefix(members) {
+  if (members.length === 0) return "";
+  const candidates = [];
+  for (let index = 0; index < members[0].length; index += 1) {
+    if (members[0][index] === "_") candidates.push(members[0].slice(0, index + 1));
+  }
+  return candidates.filter((candidate) => members.every((member) => member.startsWith(candidate))).at(-1) ?? "";
+}
+
+export function extractProtoEnums(file, text) {
+  const masked = maskProto(text);
+  const records = [];
+  const expression = /\benum[\t ]+([A-Za-z][A-Za-z0-9_]*)[\t \r\n]*\{/gu;
+  let match = expression.exec(masked);
+  while (match !== null) {
+    const opening = match.index + match[0].lastIndexOf("{");
+    const closing = closingBrace(masked, opening);
+    if (closing < 0) throw new Error(`${file} contains an unterminated proto enum ${match[1]}`);
+    const body = topLevelBody(masked.slice(opening + 1, closing));
+    // Enum-value options are metadata on the value, not a different member
+    // declaration; omitting the declaration would hide it from drift deltas.
+    const rawMembers = [...body.matchAll(/\b([A-Za-z][A-Za-z0-9_]*)[\t \r\n]*=[\t \r\n]*-?(?:0[xX][0-9A-Fa-f]+|0[0-7]*|[1-9][0-9]*)[\t \r\n]*(?:\[[^\[\]]*\][\t \r\n]*)?;/gu)].map((entry) => entry[1]);
+    const prefix = enumPrefix(rawMembers);
+    records.push({
+      file,
+      enumName: match[1],
+      rawMembers,
+      normalizedMembers: rawMembers.map((member) => normalizeClosedSetMember(member.startsWith(prefix) ? member.slice(prefix.length) : member)),
+    });
+    expression.lastIndex = closing + 1;
+    match = expression.exec(masked);
+  }
+  return records.sort((left, right) => compareText(left.file, right.file) || compareText(left.enumName, right.enumName));
+}
+
+function yamlKeyPath(parts) {
+  return parts.reduce((result, part) => part.startsWith("[") ? `${result}${part}` : result.length === 0 ? part : `${result}.${part}`, "");
+}
+
+function plainMembers(node) {
+  if (!isSeq(node) || node.items.length < 3) return null;
+  const members = [];
+  for (const item of node.items) {
+    if (!isScalar(item) || item.type !== "PLAIN" || typeof item.source !== "string" || !MEMBER.test(item.source)) return null;
+    members.push(item.source);
+  }
+  return members;
+}
+
+function visitYaml(node, file, parts, records) {
+  if (isMap(node)) {
+    for (const pair of node.items) {
+      if (!isScalar(pair.key)) {
+        visitYaml(pair.value, file, parts, records);
+        continue;
+      }
+      const key = typeof pair.key.source === "string" ? pair.key.source : String(pair.key.value);
+      const childParts = [...parts, key];
+      const members = plainMembers(pair.value);
+      if (members !== null) records.push({
+        file,
+        keyPath: yamlKeyPath(childParts),
+        members,
+        normalizedMembers: members.map(normalizeClosedSetMember),
+      });
+      visitYaml(pair.value, file, childParts, records);
+    }
+  } else if (isSeq(node)) {
+    node.items.forEach((item, index) => visitYaml(item, file, [...parts, `[${index}]`], records));
+  }
+}
+
+export function extractConfigYamlSequences(file, text) {
+  const documents = YAML.parseAllDocuments(text, {
+    keepSourceTokens: true,
+    prettyErrors: false,
+    strict: true,
+    uniqueKeys: true,
+    version: "1.2",
+  });
+  const error = documents.find((document) => document.errors.length > 0)?.errors[0];
+  if (error) throw new Error(`${file} is not valid YAML: ${error.message.split(" at line")[0]}`);
+  const records = [];
+  for (const document of documents) visitYaml(document.contents, file, [], records);
+  return records.sort((left, right) => compareText(left.file, right.file) || compareText(left.keyPath, right.keyPath));
+}
+
+function protoFile(file) {
+  return file.endsWith(".proto");
+}
+
+function yamlFile(file) {
+  return /\.ya?ml$/u.test(file);
+}
+
+function implementationFileKind(file) {
+  if (protoFile(file)) return "proto";
+  if (yamlFile(file)) return "yaml";
+  return null;
+}
+
+function implementationFileInventory(trackedFiles, classified) {
+  const excludedByReason = {};
+  for (const entry of classified.excluded) {
+    excludedByReason[entry.reason] = (excludedByReason[entry.reason] ?? 0) + 1;
+  }
+  return {
+    trackedFiles,
+    scannedFiles: {
+      proto: classified.scanned.filter(protoFile).length,
+      yaml: classified.scanned.filter(yamlFile).length,
+    },
+    excludedByReason,
+    excluded: [...classified.excluded].sort((left, right) => compareText(left.file, right.file)),
+  };
+}
+
+async function implementationBytes(repository, files, authorityInputBytes, authorityScannedBytes, maxBytes) {
+  let stated = BigInt(authorityInputBytes);
+  for (const file of files) {
+    let metadata;
+    try {
+      metadata = await lstat(path.join(repository, ...file.split("/")), { bigint: true });
+    } catch (error) {
+      throw new Error(`${file} is not readable: ${error.message}`);
+    }
+    if (metadata.isSymbolicLink() || !metadata.isFile()) throw new Error(`${file} must be one regular non-symlink file`);
+    stated += metadata.size;
+  }
+  if (stated > BigInt(maxBytes)) return { budget: budgetDiagnostic("UTF-8 input bytes", stated.toString(), maxBytes) };
+
+  const texts = new Map();
+  let inputBytes = authorityInputBytes;
+  let scannedBytes = authorityScannedBytes;
+  for (const file of files) {
+    let bytes;
+    try {
+      bytes = await readFile(path.join(repository, ...file.split("/")));
+    } catch (error) {
+      throw new Error(`${file} is not readable: ${error.message}`);
+    }
+    inputBytes += bytes.length;
+    scannedBytes += bytes.length;
+    if (inputBytes > maxBytes) return { budget: budgetDiagnostic("UTF-8 input bytes", inputBytes, maxBytes) };
+    try {
+      texts.set(file, UTF8.decode(bytes));
+    } catch {
+      throw new Error(`${file} is not valid UTF-8`);
+    }
+  }
+  return { budget: null, inputBytes, scannedBytes, texts };
+}
+
+function implementationName(set) {
+  return set.kind === "proto_enum" ? set.record.enumName : set.record.keyPath;
+}
+
+function compareImplementation(left, right) {
+  return compareText(left.record.file, right.record.file)
+    || compareText(implementationName(left), implementationName(right))
+    || compareText(left.kind, right.kind);
+}
+
+function uniqueRawByNormalized(rawMembers, normalizedMembers, excludedRaw = null) {
+  const result = [];
+  const seen = new Set();
+  rawMembers.forEach((raw, index) => {
+    if (raw === excludedRaw) return;
+    const normalized = normalizedMembers[index];
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      result.push({ raw, normalized });
+    }
+  });
+  return result;
+}
+
+function comparableImplementation(set) {
+  if (set.kind === "config_yaml_sequence") return uniqueRawByNormalized(set.record.members, set.record.normalizedMembers);
+  const prefix = enumPrefix(set.record.rawMembers);
+  return uniqueRawByNormalized(set.record.rawMembers, set.record.normalizedMembers, `${prefix}UNSPECIFIED`);
+}
+
+function publicSetReference(set) {
+  return {
+    kind: set.kind,
+    file: set.record.file,
+    name: implementationName(set),
+  };
+}
+
+function pairInventories(groups, implementationSets) {
+  const pairs = [];
+  const pairedGroups = new Set();
+  const pairedSets = new Set();
+  groups.forEach((group, groupIndex) => {
+    const canonical = uniqueRawByNormalized(group.members, group.members.map(normalizeClosedSetMember));
+    const canonicalNormalized = new Set(canonical.map((member) => member.normalized));
+    implementationSets.forEach((set, setIndex) => {
+      const implementation = comparableImplementation(set);
+      const implementationNormalized = new Set(implementation.map((member) => member.normalized));
+      const overlap = [...canonicalNormalized].filter((member) => implementationNormalized.has(member)).sort(compareText);
+      if (overlap.length < 2) return;
+      pairedGroups.add(groupIndex);
+      pairedSets.add(setIndex);
+      const missingInCanonical = implementation.filter((member) => !canonicalNormalized.has(member.normalized)).map((member) => member.raw);
+      const missingInImplementation = canonical.filter((member) => !implementationNormalized.has(member.normalized)).map((member) => member.raw);
+      pairs.push({
+        canonical: group,
+        implementation: publicSetReference(set),
+        overlap,
+        missingInCanonical,
+        missingInImplementation,
+        subset: missingInCanonical.length === 0 && missingInImplementation.length > 0,
+      });
+    });
+  });
+  pairs.sort((left, right) => compareText(left.canonical.unitId, right.canonical.unitId)
+    || compareText(left.implementation.file, right.implementation.file)
+    || compareText(left.implementation.name, right.implementation.name)
+    || compareText(left.canonical.field, right.canonical.field)
+    || compareText(left.implementation.kind, right.implementation.kind));
+  return {
+    pairs,
+    pairedGroups,
+    pairedSets,
+    pairsWithDeltas: pairs.filter((pair) => pair.missingInCanonical.length > 0 || pair.missingInImplementation.length > 0).length,
+    subsetPairs: pairs.filter((pair) => pair.subset).length,
+  };
+}
+
+export async function closedSetsAuthorityRepository(repositoryPath, specPath, { maxUnits, maxSets, maxBytes }) {
+  if (![maxUnits, maxSets, maxBytes].every(validBudget)) {
+    return refused([baseDiagnostic(
+      "AUTH_CLOSED_SETS_BUDGET",
+      "closed-set analysis budgets must be positive safe integers",
+      "provide explicit positive safe max-units, max-sets, and max-bytes budgets",
+    )]);
+  }
+
+  let inventory;
+  try {
+    inventory = await repositoryInventory(repositoryPath);
+  } catch (error) {
+    if (error instanceof AuthorityReviewRefusal) {
+      return refused([inputDiagnostic("AUTH_CLOSED_SETS_REPOSITORY_INVALID", error.message, error.file ?? ".")]);
+    }
+    throw error;
+  }
+
+  let corpus;
+  try {
+    corpus = await resolveCorpus(inventory.repository, specPath);
+  } catch (error) {
+    return refused([inputDiagnostic("AUTH_CLOSED_SETS_CORPUS_INVALID", error.message)]);
+  }
+
+  let compiled;
+  try {
+    compiled = await compileAuthorityPath(corpus.path);
+  } catch (error) {
+    if (error instanceof AuthorityInputError) return refused([inputDiagnostic("AUTH_CLOSED_SETS_CORPUS_INVALID", error.message)]);
+    throw error;
+  }
+  if (!compiled.ok) return refused(compiled.diagnostics, { fileCount: compiled.fileCount });
+
+  const activeUnits = compiled.ir.units.filter((unit) => unit.lifecycle === "active");
+  if (activeUnits.length > maxUnits) {
+    return refused([budgetDiagnostic("active units", activeUnits.length, maxUnits)], { fileCount: compiled.fileCount });
+  }
+  const canonical = canonicalGroups(compiled);
+
+  const gitlinks = new Set(inventory.gitlinks);
+  const classifiedFiles = await classifyTrackedTextFiles(
+    inventory.repository,
+    inventory.files,
+    (file) => {
+      if (gitlinks.has(file)) return "gitlink";
+      return file === ".nimi/spec" || file.startsWith(".nimi/spec/")
+        ? "authority-corpus"
+        : implementationFileKind(file) === null ? "not-a-scanned-kind" : null;
+    },
+  );
+  if (classifiedFiles.error !== undefined) {
+    return refused([inputDiagnostic("AUTH_CLOSED_SETS_IMPLEMENTATION_INPUT_INVALID", classifiedFiles.error)], { fileCount: compiled.fileCount });
+  }
+  const implementationFiles = classifiedFiles.scanned;
+  const fileInventory = implementationFileInventory(inventory.files.length, classifiedFiles);
+  let scanned;
+  try {
+    scanned = await implementationBytes(
+      inventory.repository,
+      implementationFiles,
+      compiled.inputBytes,
+      canonical.scannedBytes,
+      maxBytes,
+    );
+  } catch (error) {
+    return refused([inputDiagnostic("AUTH_CLOSED_SETS_IMPLEMENTATION_INPUT_INVALID", error.message)], { fileCount: compiled.fileCount });
+  }
+  if (scanned.budget !== null) return refused([scanned.budget], { fileCount: compiled.fileCount });
+
+  const protoEnums = [];
+  const configYamlSequences = [];
+  try {
+    for (const file of implementationFiles) {
+      if (protoFile(file)) protoEnums.push(...extractProtoEnums(file, scanned.texts.get(file)));
+      else configYamlSequences.push(...extractConfigYamlSequences(file, scanned.texts.get(file)));
+    }
+  } catch (error) {
+    return refused([inputDiagnostic("AUTH_CLOSED_SETS_IMPLEMENTATION_INPUT_INVALID", error.message)], { fileCount: compiled.fileCount });
+  }
+  protoEnums.sort((left, right) => compareText(left.file, right.file) || compareText(left.enumName, right.enumName));
+  configYamlSequences.sort((left, right) => compareText(left.file, right.file) || compareText(left.keyPath, right.keyPath));
+  const setCount = protoEnums.length + configYamlSequences.length;
+  if (setCount > maxSets) {
+    return refused([budgetDiagnostic("implementation sets", setCount, maxSets)], { fileCount: compiled.fileCount });
+  }
+
+  const implementationSets = [
+    ...protoEnums.map((record) => ({ kind: "proto_enum", record })),
+    ...configYamlSequences.map((record) => ({ kind: "config_yaml_sequence", record })),
+  ].sort(compareImplementation);
+  const paired = pairInventories(canonical.groups, implementationSets);
+  const unpairedGroups = canonical.groups.filter((_, index) => !paired.pairedGroups.has(index));
+  const unpairedProtoEnums = [];
+  const unpairedConfigYamlSequences = [];
+  implementationSets.forEach((set, index) => {
+    if (paired.pairedSets.has(index)) return;
+    if (set.kind === "proto_enum") unpairedProtoEnums.push(set.record);
+    else unpairedConfigYamlSequences.push(set.record);
+  });
+  const summary = {
+    groups: canonical.groups.length,
+    sets: {
+      total: setCount,
+      protoEnums: protoEnums.length,
+      configYamlSequences: configYamlSequences.length,
+    },
+    pairs: paired.pairs.length,
+    pairsWithDeltas: paired.pairsWithDeltas,
+    subsetPairs: paired.subsetPairs,
+    unpairedGroups: unpairedGroups.length,
+    unpairedSets: {
+      total: unpairedProtoEnums.length + unpairedConfigYamlSequences.length,
+      protoEnums: unpairedProtoEnums.length,
+      configYamlSequences: unpairedConfigYamlSequences.length,
+    },
+  };
+  const closedSets = {
+    format: CLOSED_SETS_FORMAT,
+    complete: true,
+    fileInventory,
+    canonicalGroups: canonical.groups,
+    implementationSets: { protoEnums, configYamlSequences },
+    pairs: paired.pairs,
+    unpaired: {
+      canonicalGroups: unpairedGroups,
+      implementationSets: {
+        protoEnums: unpairedProtoEnums,
+        configYamlSequences: unpairedConfigYamlSequences,
+      },
+    },
+  };
+  return {
+    ok: true,
+    complete: true,
+    partial: false,
+    diagnostics: [],
+    fileCount: compiled.fileCount + implementationFiles.length,
+    unitCount: activeUnits.length,
+    scannedBytes: scanned.scannedBytes,
+    inputBytes: scanned.inputBytes,
+    trackedPathSetDigest: inventory.trackedPathSetDigest,
+    summary,
+    closedSets,
+  };
+}
+
+export { CLOSED_SETS_FORMAT };