@zxyycom/vibe-check 0.0.1

package/src/package-checks/json-validation/json-validation.ts

@@ -0,0 +1,212 @@
+import { resolve } from "node:path";
+
+import type { CheckExecutionContext, CheckMessage, CheckResult } from "../../check/check.ts";
+import {
+  readStrictJsonDocument,
+  type JsonDocumentIssue
+} from "../json-document/strict-document.ts";
+import { collectProjectFiles } from "../project-files/collection.ts";
+import { partitionProjectFilesByEligibility } from "../project-files/input-eligibility.ts";
+import type { JsonValidationFinalData } from "./final-data.ts";
+import type { ResolvedJsonValidationOptions } from "./options.ts";
+import { validJsonValidationOptions } from "./options-validation.ts";
+
+export const JSON_VALIDATION_CHECK_DEFINITION = {
+  checkId: "json-validation",
+  displayName: "JSON validation"
+} as const;
+
+/** `json-validation` whole-Check unavailable outcome 的稳定 reason code。 */
+export type JsonValidationUnavailableCode =
+  | "invalid-options"
+  | "document-unavailable"
+  | "execution-cancelled"
+  | "scan-input-unavailable";
+
+/** Validates the lower-case JSON subset selected by this Check's options. */
+export function executeJsonValidation(
+  context: CheckExecutionContext<ResolvedJsonValidationOptions>
+): CheckResult<JsonValidationFinalData> {
+  if (!validJsonValidationOptions(context.options)) return unavailable("invalid-options");
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+
+  const inputs = jsonInputPaths(context);
+  if (inputs === undefined) return unavailable("scan-input-unavailable");
+  if (context.signal.aborted) return unavailable("execution-cancelled");
+  if (inputs.selectedPathCount === 0) return noEligibleInput();
+  reportRejectedInputs(context, inputs.rejectedPaths);
+  return appendRejectedInputMessage(
+    validateJsonPaths(context, inputs.acceptedPaths, inputs.rejectedPaths.length),
+    inputs.rejectedPaths.length
+  );
+}
+
+function validateJsonPaths(
+  context: CheckExecutionContext<ResolvedJsonValidationOptions>,
+  paths: readonly string[],
+  rejectedInputCount: number
+): CheckResult<JsonValidationFinalData> {
+  const counts = { invalidFileCount: 0, validFileCount: 0 };
+  for (const path of paths) {
+    if (context.signal.aborted) return unavailable("execution-cancelled");
+    const document = readJsonDocument(context, path);
+    if (context.signal.aborted) return unavailable("execution-cancelled");
+    if (document.kind === "unavailable") return unavailable("document-unavailable");
+    if (document.kind === "valid") {
+      counts.validFileCount += 1;
+      continue;
+    }
+
+    counts.invalidFileCount += 1;
+    reportInvalidDocument(context, path, document.reason);
+  }
+
+  return resultForValidationCounts(paths.length, rejectedInputCount, counts);
+}
+
+interface JsonInputPaths {
+  readonly acceptedPaths: readonly string[];
+  readonly rejectedPaths: readonly string[];
+  readonly selectedPathCount: number;
+}
+
+function jsonInputPaths(
+  context: CheckExecutionContext<ResolvedJsonValidationOptions>
+): JsonInputPaths | undefined {
+  try {
+    const selectedPaths = collectProjectFiles(context.project.root, context.options.files);
+    const partition = partitionProjectFilesByEligibility(selectedPaths, isJsonInputPath);
+    return Object.freeze({ ...partition, selectedPathCount: selectedPaths.length });
+  } catch {
+    return undefined;
+  }
+}
+
+function isJsonInputPath(path: string): boolean {
+  return path.endsWith(".json");
+}
+
+function noEligibleInput(): CheckResult<JsonValidationFinalData> {
+  return Object.freeze({ status: "not-applicable", reason: { code: "no-eligible-input" } });
+}
+
+function readJsonDocument(
+  context: CheckExecutionContext<ResolvedJsonValidationOptions>,
+  path: string
+) {
+  return readStrictJsonDocument({
+    filePath: resolve(context.project.root, path),
+    maximumBytes: context.options.maximumBytes
+  });
+}
+
+function reportInvalidDocument(
+  context: CheckExecutionContext<ResolvedJsonValidationOptions>,
+  path: string,
+  reason: JsonDocumentIssue
+): void {
+  const record: JsonValidationRecordData = Object.freeze({ path, reason });
+  context.records.report({ id: path }, record);
+}
+
+function resultForValidationCounts(
+  scannedFileCount: number,
+  rejectedInputCount: number,
+  counts: Readonly<{ invalidFileCount: number; validFileCount: number }>
+): CheckResult<JsonValidationFinalData> {
+  const data = Object.freeze({
+    scannedFileCount,
+    validFileCount: counts.validFileCount,
+    invalidFileCount: counts.invalidFileCount,
+    issueCount: counts.invalidFileCount + rejectedInputCount,
+    rejectedInputCount
+  });
+  if (counts.invalidFileCount === 0) return Object.freeze({ data, status: "passed" });
+  return Object.freeze({
+    data,
+    messages: Object.freeze([
+      Object.freeze({
+        code: "invalid-json-documents",
+        level: "error" as const,
+        message: `${counts.invalidFileCount} JSON document(s) are invalid; inspect this Check's Records for each path and reason.`
+      })
+    ]),
+    status: "failed"
+  });
+}
+
+function reportRejectedInputs(
+  context: CheckExecutionContext<ResolvedJsonValidationOptions>,
+  paths: readonly string[]
+): void {
+  for (const path of paths) {
+    const data: JsonValidationInputRejectedRecordData = Object.freeze({
+      blocking: false,
+      kind: "input-rejected",
+      path,
+      reason: "unsupported-file-type"
+    });
+    context.records.report({ id: `/input-rejected/${path}` }, data);
+  }
+}
+
+function appendRejectedInputMessage(
+  result: CheckResult<JsonValidationFinalData>,
+  rejectedInputCount: number
+): CheckResult<JsonValidationFinalData> {
+  if (rejectedInputCount === 0) return result;
+  const message: CheckMessage = Object.freeze({
+    code: "input-rejected",
+    level: "warning",
+    message: `${rejectedInputCount} selected jsonValidation input file(s) were rejected because only lower-case .json paths are supported; inspect this Check's Records and narrow files.include/exclude.`
+  });
+  return Object.freeze({
+    ...result,
+    messages: Object.freeze([...(result.messages ?? []), message])
+  });
+}
+
+function unavailable(code: JsonValidationUnavailableCode): CheckResult<JsonValidationFinalData> {
+  return Object.freeze({
+    status: "unavailable",
+    reason: { code },
+    messages: Object.freeze([
+      Object.freeze({ code, level: "error" as const, message: unavailableMessage(code) })
+    ])
+  });
+}
+
+function unavailableMessage(code: JsonValidationUnavailableCode): string {
+  switch (code) {
+    case "invalid-options":
+      return "jsonValidation options are invalid; recreate the Check with jsonValidation(options) or restore its complete resolved options.";
+    case "scan-input-unavailable":
+      return "JSON validation could not collect its configured project files; check the project root, permissions, and selected file source.";
+    case "document-unavailable":
+      return "A selected JSON document could not be read safely; check that the file still exists, is readable, and was not replaced during the Run.";
+    case "execution-cancelled":
+      return "JSON validation was cancelled before it could form a complete result; inspect the caller's cancellation reason and retry if appropriate.";
+  }
+}
+
+/** 一条 invalid JSON document supplemental Record 的 data。 */
+export interface JsonValidationDocumentRecordData {
+  readonly path: string;
+  readonly reason: JsonValidationRecordReason;
+}
+
+/** 一条 files policy 已选中但不受 JSON validation 支持的输入 Finding。 */
+export interface JsonValidationInputRejectedRecordData {
+  readonly blocking: false;
+  readonly kind: "input-rejected";
+  readonly path: string;
+  readonly reason: "unsupported-file-type";
+}
+
+/** JSON validation 发布的 document issue 或 input-rejection Record data。 */
+export type JsonValidationRecordData =
+  | JsonValidationDocumentRecordData
+  | JsonValidationInputRejectedRecordData;
+
+/** JSON document Record 的稳定问题原因。 */
+export type JsonValidationRecordReason = JsonDocumentIssue;

package/src/package-checks/json-validation/options-resolution.ts

@@ -0,0 +1,50 @@
+import {
+  hasRequiredAndOptionalRecordKeys,
+  snapshotClosedRecord
+} from "../../data-boundary/closed-values.ts";
+import {
+  defaultProjectFileSelection,
+  resolveProjectFileSelection,
+  snapshotProjectFileSelection
+} from "../project-files/configuration.ts";
+import type { ResolvedJsonValidationOptions } from "./options.ts";
+import { validJsonValidationOptions } from "./options-validation.ts";
+
+const DEFAULT_MAXIMUM_BYTES = 1_048_576;
+const DEFAULT_FILES = Object.freeze({
+  exclude: defaultProjectFileSelection.exclude,
+  include: Object.freeze(["**/*.json"]),
+  source: defaultProjectFileSelection.source
+});
+
+/** 将可省略 JSON validation policy 物化为完整、冻结的 execution options。 */
+export function resolveJsonValidationOptions(
+  value: unknown
+): ResolvedJsonValidationOptions | undefined {
+  const input = snapshotClosedRecord(value);
+  if (
+    input === undefined ||
+    !hasRequiredAndOptionalRecordKeys(input, {
+      optional: ["files", "maximumBytes"],
+      required: []
+    })
+  ) {
+    return undefined;
+  }
+  const files =
+    input.files === undefined
+      ? snapshotProjectFileSelection(DEFAULT_FILES)
+      : resolveProjectFileSelection(input.files, DEFAULT_FILES);
+  const maximumBytes =
+    input.maximumBytes === undefined ? DEFAULT_MAXIMUM_BYTES : input.maximumBytes;
+  if (
+    files === undefined ||
+    typeof maximumBytes !== "number" ||
+    !Number.isSafeInteger(maximumBytes) ||
+    maximumBytes <= 0
+  ) {
+    return undefined;
+  }
+  const options = Object.freeze({ files, maximumBytes });
+  return validJsonValidationOptions(options) ? options : undefined;
+}

package/src/package-checks/json-validation/options-validation.ts

@@ -0,0 +1,27 @@
+import {
+  hasExactPlainRecordKeys,
+  snapshotClosedRecord
+} from "../../data-boundary/closed-values.ts";
+import { validProjectFileSelection } from "../project-files/configuration.ts";
+import type { ResolvedJsonValidationOptions } from "./options.ts";
+
+function exactRecord(
+  value: unknown,
+  keys: readonly string[]
+): Readonly<Record<string, unknown>> | undefined {
+  const record = snapshotClosedRecord(value);
+  return record !== undefined && hasExactPlainRecordKeys(record, keys) ? record : undefined;
+}
+
+function positiveSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+
+export function validJsonValidationOptions(value: unknown): value is ResolvedJsonValidationOptions {
+  const options = exactRecord(value, ["files", "maximumBytes"]);
+  return (
+    options !== undefined &&
+    validProjectFileSelection(options.files) &&
+    positiveSafeInteger(options.maximumBytes)
+  );
+}

package/src/package-checks/json-validation/options.ts

@@ -0,0 +1,18 @@
+import type {
+  ProjectFileSelection,
+  ProjectFileSelectionOptions
+} from "../project-files/configuration.ts";
+
+/** `jsonValidation(options?)` 接受的可省略 authoring policy。 */
+export interface JsonValidationOptions {
+  /** 参与本 Check 的 repository-file selection；省略字段使用 package defaults。 */
+  readonly files?: ProjectFileSelectionOptions;
+  /** 单个 JSON document 允许的最大 raw byte 数；省略时为 1 MiB。 */
+  readonly maximumBytes?: number;
+}
+
+/** `json-validation` execution 消费的完整、冻结 options。 */
+export interface ResolvedJsonValidationOptions {
+  readonly files: ProjectFileSelection;
+  readonly maximumBytes: number;
+}

package/src/package-checks/maintenance-reminders/assessment-results.ts

@@ -0,0 +1,117 @@
+import type { CheckMessage, CheckResult } from "../../check/check.ts";
+import type {
+  MaintenanceReminder,
+  MaintenanceRemindersUnavailableCode,
+  ReminderEvaluation,
+  ReminderMeasurement,
+  FirstParentHistoryResolution,
+  FirstParentHistoryUnavailableReason
+} from "./maintenance-reminders.ts";
+import type {
+  MaintenanceReminderAssessment,
+  MaintenanceReminderMode,
+  MaintenanceReminderUnavailableReason,
+  MaintenanceRemindersFinalData,
+  UnavailableMaintenanceReminderAssessment
+} from "./final-data.ts";
+
+const REMINDER_MESSAGE_CODE = Object.freeze({
+  due: "maintenance-reminder-due",
+  unavailable: "maintenance-reminder-unavailable"
+});
+
+export function completedResult(
+  evaluations: readonly ReminderEvaluation[]
+): CheckResult<MaintenanceRemindersFinalData> {
+  const assessments = evaluations.map((evaluation) => evaluation.assessment);
+  const messages = evaluations.flatMap(messageForEvaluation);
+  const failed = evaluations.some(
+    (evaluation) =>
+      evaluation.assessment.mode === "enforcing" && evaluation.assessment.assessment !== "clear"
+  );
+  return {
+    status: failed ? ("failed" as const) : ("passed" as const),
+    data: { entries: assessments },
+    ...(messages.length === 0 ? {} : { messages })
+  };
+}
+
+export function unavailableResult(
+  code: MaintenanceRemindersUnavailableCode
+): CheckResult<MaintenanceRemindersFinalData> {
+  return {
+    status: "unavailable" as const,
+    reason: { code },
+    messages: [{ code, level: "error", message: wholeCheckUnavailableMessage(code) }]
+  };
+}
+
+function wholeCheckUnavailableMessage(code: MaintenanceRemindersUnavailableCode): string {
+  switch (code) {
+    case "invalid-options":
+      return "maintenanceReminders options are invalid; recreate the Check with maintenanceReminders(entries) or restore its complete resolved options.";
+    case "execution-cancelled":
+      return "Maintenance reminder evaluation was cancelled before it could form a complete result; inspect the caller's cancellation reason and retry if appropriate.";
+    case "maintenance-reminders-internal-failure":
+      return "Maintenance reminders could not form a complete ordered assessment; check package/runtime integrity and retry.";
+  }
+}
+
+function messageForEvaluation(evaluation: ReminderEvaluation): readonly CheckMessage[] {
+  const { assessment, message } = evaluation;
+  if (assessment.assessment === "clear") return [];
+  const level = assessment.mode === "enforcing" ? ("error" as const) : ("warning" as const);
+  const suffix = assessment.assessment === "unavailable" ? ` (${assessment.reason})` : "";
+  return [
+    {
+      code:
+        assessment.assessment === "due"
+          ? REMINDER_MESSAGE_CODE.due
+          : REMINDER_MESSAGE_CODE.unavailable,
+      level,
+      message: `${assessment.id}: ${message}${suffix}`
+    }
+  ];
+}
+
+export function unavailableAssessment(
+  entry: Readonly<MaintenanceReminder>,
+  headCommit: string | null,
+  reason: MaintenanceReminderUnavailableReason
+): UnavailableMaintenanceReminderAssessment {
+  return {
+    assessment: "unavailable",
+    baseCommit: entry.baseCommit,
+    changedLines: null,
+    commitCount: null,
+    exceeded: [],
+    headCommit,
+    id: entry.id,
+    mode: modeOf(entry),
+    reason
+  };
+}
+
+export function modeOf(entry: Readonly<MaintenanceReminder>): MaintenanceReminderMode {
+  return entry.mode === "enforcing" ? "enforcing" : "advisory";
+}
+
+export function unavailableHistory(
+  reason: FirstParentHistoryUnavailableReason
+): FirstParentHistoryResolution {
+  return { kind: "unavailable", reason };
+}
+
+export function reminderEvaluation(
+  entry: Readonly<MaintenanceReminder>,
+  assessment: MaintenanceReminderAssessment
+): ReminderEvaluation {
+  return { assessment, message: entry.message };
+}
+
+export function completedMeasurement(
+  entry: Readonly<MaintenanceReminder>,
+  assessment: MaintenanceReminderAssessment
+): ReminderMeasurement {
+  return { kind: "succeeded", value: reminderEvaluation(entry, assessment) };
+}

package/src/package-checks/maintenance-reminders/final-data.ts

@@ -0,0 +1,239 @@
+import { snapshotClosedRecord } from "../../data-boundary/closed-values.ts";
+import {
+  exactFinalDataRecord,
+  finalDataArray,
+  invalidFinalData,
+  nonNegativeSafeInteger
+} from "../final-data-parsing.ts";
+
+const EMPTY_EXCEEDED: readonly [] = Object.freeze([]);
+
+const FULL_COMMIT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
+const REMINDER_ID = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+
+/** 单条维护提醒无法测量时使用的稳定 reason code。 */
+export const MAINTENANCE_REMINDER_UNAVAILABLE_REASON = Object.freeze({
+  baseCommitUnavailable: "base-commit-unavailable",
+  baseNotFirstParentAncestor: "base-not-first-parent-ancestor",
+  firstParentHistoryInvalid: "first-parent-history-invalid",
+  firstParentHistoryUnavailable: "first-parent-history-unavailable",
+  headInvalid: "head-invalid",
+  headUnavailable: "head-unavailable",
+  numstatInvalid: "numstat-invalid",
+  numstatUnavailable: "numstat-unavailable"
+} as const);
+
+export type MaintenanceReminderMode = "advisory" | "enforcing";
+
+/** 单条维护提醒无法测量时保留在 final data 中的稳定 reason。 */
+export type MaintenanceReminderUnavailableReason =
+  (typeof MAINTENANCE_REMINDER_UNAVAILABLE_REASON)[keyof typeof MAINTENANCE_REMINDER_UNAVAILABLE_REASON];
+
+const MAINTENANCE_REMINDER_UNAVAILABLE_REASONS: readonly MaintenanceReminderUnavailableReason[] =
+  Object.freeze(Object.values(MAINTENANCE_REMINDER_UNAVAILABLE_REASON));
+
+/** 判断 unknown value 是否为维护提醒的稳定局部 ID。 */
+export function isMaintenanceReminderId(value: unknown): value is string {
+  return typeof value === "string" && REMINDER_ID.test(value);
+}
+
+/** 判断 unknown value 是否为 Git 的完整 SHA-1 或 SHA-256 commit ID。 */
+export function isMaintenanceCommitId(value: unknown): value is string {
+  return typeof value === "string" && FULL_COMMIT_ID.test(value);
+}
+
+export type MeasuredMaintenanceReminderAssessment = Readonly<{
+  readonly assessment: "clear" | "due";
+  readonly baseCommit: string;
+  readonly changedLines: number;
+  readonly commitCount: number;
+  readonly exceeded: readonly ("commits" | "changed-lines")[];
+  readonly headCommit: string;
+  readonly id: string;
+  readonly mode: MaintenanceReminderMode;
+}>;
+
+export type UnavailableMaintenanceReminderAssessment = Readonly<{
+  readonly assessment: "unavailable";
+  readonly baseCommit: string;
+  readonly changedLines: null;
+  readonly commitCount: null;
+  readonly exceeded: readonly [];
+  readonly headCommit: string | null;
+  readonly id: string;
+  readonly mode: MaintenanceReminderMode;
+  readonly reason: MaintenanceReminderUnavailableReason;
+}>;
+
+/** 单条维护提醒的 measured 或 unavailable discriminated assessment。 */
+export type MaintenanceReminderAssessment =
+  | MeasuredMaintenanceReminderAssessment
+  | UnavailableMaintenanceReminderAssessment;
+
+/** `maintenance-reminders` 在 passed/failed outcome 中发布的主数据。 */
+export interface MaintenanceRemindersFinalData {
+  readonly entries: readonly MaintenanceReminderAssessment[];
+}
+
+/** 验证 discriminated entry assessments 并脱离 canonical final data。 */
+export function parseMaintenanceRemindersData(data: unknown): MaintenanceRemindersFinalData {
+  const value = exactFinalDataRecord(data, ["entries"], "maintenanceReminders");
+  const entries = finalDataArray(value.entries, "maintenanceReminders");
+  const parsedEntries: MaintenanceReminderAssessment[] = [];
+  const ids = new Set<string>();
+  for (const entry of entries) {
+    const parsed = parseAssessment(entry);
+    if (ids.has(parsed.id)) throw invalidFinalData("maintenanceReminders");
+    ids.add(parsed.id);
+    parsedEntries.push(parsed);
+  }
+  return Object.freeze({ entries: Object.freeze(parsedEntries) });
+}
+
+function parseAssessment(value: unknown): MaintenanceReminderAssessment {
+  const record = assessmentRecord(value);
+  const identity = assessmentIdentity(record);
+  if (record.assessment === "unavailable") {
+    return parseUnavailableAssessment(record, identity);
+  }
+  return parseMeasuredAssessment(record, identity);
+}
+
+function assessmentRecord(value: unknown): Readonly<Record<string, unknown>> {
+  return exactFinalDataRecord(
+    value,
+    valueAssessment(value) === "unavailable"
+      ? unavailableAssessmentKeys()
+      : measuredAssessmentKeys(),
+    "maintenanceReminders"
+  );
+}
+
+function unavailableAssessmentKeys(): readonly string[] {
+  return [
+    "assessment",
+    "baseCommit",
+    "changedLines",
+    "commitCount",
+    "exceeded",
+    "headCommit",
+    "id",
+    "mode",
+    "reason"
+  ];
+}
+
+function measuredAssessmentKeys(): readonly string[] {
+  return [
+    "assessment",
+    "baseCommit",
+    "changedLines",
+    "commitCount",
+    "exceeded",
+    "headCommit",
+    "id",
+    "mode"
+  ];
+}
+
+function assessmentIdentity(record: Readonly<Record<string, unknown>>): Readonly<{
+  readonly baseCommit: string;
+  readonly id: string;
+  readonly mode: MaintenanceReminderMode;
+}> {
+  const id = isMaintenanceReminderId(record.id) ? record.id : undefined;
+  const mode = record.mode === "advisory" || record.mode === "enforcing" ? record.mode : undefined;
+  const baseCommit = isMaintenanceCommitId(record.baseCommit) ? record.baseCommit : undefined;
+  if (id === undefined || mode === undefined || baseCommit === undefined)
+    throw invalidFinalData("maintenanceReminders");
+  return { baseCommit, id, mode };
+}
+
+function parseMeasuredAssessment(
+  record: Readonly<Record<string, unknown>>,
+  identity: Readonly<{
+    readonly baseCommit: string;
+    readonly id: string;
+    readonly mode: MaintenanceReminderMode;
+  }>
+): MeasuredMaintenanceReminderAssessment {
+  if (record.assessment !== "clear" && record.assessment !== "due")
+    throw invalidFinalData("maintenanceReminders");
+  const commitCount = nonNegativeSafeInteger(record.commitCount);
+  const changedLines = nonNegativeSafeInteger(record.changedLines);
+  const headCommit = isMaintenanceCommitId(record.headCommit) ? record.headCommit : undefined;
+  const exceeded = parseExceeded(record.exceeded);
+  if (
+    commitCount === undefined ||
+    changedLines === undefined ||
+    headCommit === undefined ||
+    exceeded === undefined ||
+    (record.assessment === "clear" ? exceeded.length !== 0 : exceeded.length === 0)
+  ) {
+    throw invalidFinalData("maintenanceReminders");
+  }
+  return Object.freeze({
+    assessment: record.assessment,
+    baseCommit: identity.baseCommit,
+    changedLines,
+    commitCount,
+    exceeded,
+    headCommit,
+    id: identity.id,
+    mode: identity.mode
+  });
+}
+
+function parseUnavailableAssessment(
+  record: Readonly<Record<string, unknown>>,
+  identity: Readonly<{
+    readonly baseCommit: string;
+    readonly id: string;
+    readonly mode: MaintenanceReminderMode;
+  }>
+): UnavailableMaintenanceReminderAssessment {
+  const exceeded = finalDataArray(record.exceeded, "maintenanceReminders");
+  const headCommit = record.headCommit;
+  if (
+    record.changedLines !== null ||
+    record.commitCount !== null ||
+    exceeded.length !== 0 ||
+    (headCommit !== null && !isMaintenanceCommitId(headCommit)) ||
+    !isUnavailableReason(record.reason)
+  ) {
+    throw invalidFinalData("maintenanceReminders");
+  }
+  return Object.freeze({
+    assessment: "unavailable",
+    baseCommit: identity.baseCommit,
+    changedLines: null,
+    commitCount: null,
+    exceeded: EMPTY_EXCEEDED,
+    headCommit,
+    id: identity.id,
+    mode: identity.mode,
+    reason: record.reason
+  });
+}
+
+function valueAssessment(value: unknown): unknown {
+  return snapshotClosedRecord(value)?.assessment;
+}
+
+function parseExceeded(value: unknown): readonly ("commits" | "changed-lines")[] | undefined {
+  const entries = finalDataArray(value, "maintenanceReminders");
+  const exceeded: ("commits" | "changed-lines")[] = [];
+  const uniqueEntries = new Set<string>();
+  for (const entry of entries) {
+    if ((entry !== "commits" && entry !== "changed-lines") || uniqueEntries.has(entry)) {
+      return undefined;
+    }
+    uniqueEntries.add(entry);
+    exceeded.push(entry);
+  }
+  return Object.freeze(exceeded);
+}
+
+function isUnavailableReason(value: unknown): value is MaintenanceReminderUnavailableReason {
+  return MAINTENANCE_REMINDER_UNAVAILABLE_REASONS.some((reason) => reason === value);
+}