@beyondwork/docx-react-component 1.0.0

package/services/react-word-editor/lib/certification-bundle.ts

@@ -0,0 +1,796 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  listManualCertifications,
+  type CertificationOutcome,
+  type CertificationSurface,
+  type CertificationTargetType,
+  type ManualCertificationRecord,
+} from "./certification-store.ts";
+
+type Wave10Manifest = {
+  manifestVersion: "docx-certification/1";
+  wave: 10;
+  bundleRoot: ".tmp/wave-10-certification";
+  releaseGateFixtures: string[];
+  representativeScenarios: string[];
+  manualReviewFixtures: string[];
+  manualReviewScenarios: string[];
+  expectedBlockedScenarios?: string[];
+  requiredArtifacts: string[];
+};
+
+type RepoFreshnessState = {
+  repoCommitSha?: string;
+  workingTreeDirty: boolean;
+  gitAvailable: boolean;
+};
+
+type BundleSignoffArtifactStatus = {
+  relativePath: string;
+  exists: boolean;
+  status: "passed" | "pending" | "issues-found" | "missing";
+};
+
+type Wave10RegressionReport = {
+  generatedAt: string;
+  overallStatus: "ready" | "blocked";
+  repoState: RepoFreshnessState;
+  blockingReasons: string[];
+  summary: {
+    releaseGateFixturesPassed: number;
+    releaseGateFixturesTotal: number;
+    representativeScenariosPassed: number;
+    representativeScenariosTotal: number;
+    requiredArtifactsPassed: number;
+    requiredArtifactsTotal: number;
+    requiredManualSurfacesPassed: number;
+    requiredManualSurfacesTotal: number;
+  };
+};
+
+type Wave10FreshnessReport = {
+  generatedAt: string;
+  overallStatus: "ready" | "blocked";
+  repoState: RepoFreshnessState;
+  blockingReasons: string[];
+  requiredArtifacts: BundleSignoffArtifactStatus[];
+};
+
+type Wave10ExecutionOutcome =
+  | {
+      state: "exported-and-validated";
+    }
+  | {
+      state: "blocked-before-export";
+      reason: string;
+    };
+
+type Wave10CompatibilitySummary = {
+  featureClassFocus?: "supported-roundtrip" | "preserve-only" | "unsupported-fatal";
+  readOnly: boolean;
+  blockExport: boolean;
+  blockExportReasons: string[];
+  warningCount: number;
+  errorCount: number;
+  supportedFeatureCount: number;
+  preserveOnlyFeatureCount: number;
+  unsupportedFatalFeatureCount: number;
+};
+
+type Wave10SourceArtifact = {
+  sourceKey: string;
+  sourceKind: "fixture" | "scenario";
+  generatedAt: string;
+  proofContext: {
+    proofWave: 10;
+    bundleId: string;
+  };
+  runStory: {
+    runId: string;
+    createdAt: string;
+  };
+  source: {
+    sourceId: string;
+    sourceLabel: string;
+    fileName: string;
+    featureClassFocus?: "supported-roundtrip" | "preserve-only" | "unsupported-fatal";
+    wordExpectation?: string;
+  };
+  executionOutcome: Wave10ExecutionOutcome;
+  compatibilitySummary?: Wave10CompatibilitySummary;
+  exportRecord?: {
+    exportId: string;
+    fileName: string;
+    byteLength: number;
+    createdAt: string;
+  };
+  validationRun?: {
+    runId: string;
+    summary: {
+      isValid: boolean;
+      packageFindingCount: number;
+      sdkFindingCount: number;
+    };
+    createdAt: string;
+  };
+  validationDeltaFromSource?: {
+    packageFindingDelta: number;
+    sdkFindingDelta: number;
+  };
+};
+
+type BundleTone = "neutral" | "success" | "warning" | "danger";
+
+export type CertificationBundleManualReview = {
+  surface: CertificationSurface;
+  required: boolean;
+  outcome: CertificationOutcome;
+  label: string;
+  tone: BundleTone;
+  certificationId?: string;
+  operator?: string;
+  observedAt?: string;
+  summary?: string;
+  notes?: string;
+  targetType?: CertificationTargetType;
+  targetId?: string;
+};
+
+export type CertificationBundleEntry = {
+  sourceKey: string;
+  sourceLabel: string;
+  sourceKind: "fixture" | "scenario";
+  fileName: string;
+  classification:
+    | "supported-roundtrip"
+    | "preserve-only"
+    | "unsupported-fatal"
+    | "representative-scenario";
+  classificationLabel: string;
+  classificationDetail: string;
+  requiredManualReview: boolean;
+  runId: string;
+  validationRunId?: string;
+  exportId?: string;
+  createdAt: string;
+  generatedAt: string;
+  wordExpectation?: string;
+  executionOutcome: Wave10ExecutionOutcome;
+  compatibilitySummary?: Wave10CompatibilitySummary;
+  validator: {
+    present: boolean;
+    isValid?: boolean;
+    packageFindingCount?: number;
+    sdkFindingCount?: number;
+    packageFindingDelta?: number;
+    sdkFindingDelta?: number;
+    detail: string;
+  };
+  judgement: {
+    state: "passed" | "blocked" | "failed";
+    label: string;
+    tone: BundleTone;
+    detail: string;
+  };
+  manualReviews: {
+    wordDesktop: CertificationBundleManualReview;
+    wordWeb: CertificationBundleManualReview;
+  };
+};
+
+export type CertificationBundleNote = {
+  relativePath: string;
+  exists: boolean;
+  status: "passed" | "pending" | "issues-found" | "missing";
+  body?: string;
+};
+
+export type CertificationBundleValidatorReport = {
+  path: string;
+  report?: {
+    validatedAtUtc?: string;
+    summary?: {
+      isValid: boolean;
+      packageFindingCount: number;
+      sdkFindingCount: number;
+    };
+    sdk?: {
+      findings?: Array<{
+        code?: string;
+        message?: string;
+        partUri?: string;
+      }>;
+    };
+  };
+};
+
+export type CertificationBundleModel = {
+  bundleId: string;
+  anchorRunId: string;
+  anchorSourceKey: string;
+  generatedAt: string;
+  overallStatus: "ready" | "blocked";
+  repoState: RepoFreshnessState;
+  regression: Wave10RegressionReport;
+  freshness: Wave10FreshnessReport;
+  releaseGateFixtures: CertificationBundleEntry[];
+  representativeScenarios: CertificationBundleEntry[];
+  manualReviewEntries: CertificationBundleEntry[];
+  anchorEntry: CertificationBundleEntry;
+  desktopNote: CertificationBundleNote;
+  webNote: CertificationBundleNote;
+  representativeExportValidator: CertificationBundleValidatorReport;
+  summary: {
+    releaseGateFixturesPassed: number;
+    releaseGateFixturesTotal: number;
+    representativeScenariosPassed: number;
+    representativeScenariosTotal: number;
+    requiredArtifactsPassed: number;
+    requiredArtifactsTotal: number;
+    manualReviewSurfacesPassed: number;
+    manualReviewSurfacesTotal: number;
+    pendingManualReviewEntries: number;
+  };
+};
+
+const moduleDirPath = path.dirname(fileURLToPath(import.meta.url));
+const serviceRootDir = path.resolve(moduleDirPath, "..");
+const repoRootDir = path.resolve(serviceRootDir, "../..");
+const wave10BundleRootDir = path.join(repoRootDir, ".tmp/wave-10-certification");
+const manifestPath = path.join(repoRootDir, "test/fixtures/docx/certification-manifest.json");
+const regressionReportPath = path.join(wave10BundleRootDir, "regression-report.json");
+const freshnessPath = path.join(wave10BundleRootDir, "certification-freshness.json");
+const representativeValidatorPath = path.join(
+  wave10BundleRootDir,
+  "representative-export-validator.json",
+);
+
+async function readJsonFile<T>(filePath: string): Promise<T | undefined> {
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw) as T;
+  } catch {
+    return undefined;
+  }
+}
+
+async function readTextFile(filePath: string): Promise<string | undefined> {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
+function getArtifactPath(relativePath: string): string {
+  return path.join(wave10BundleRootDir, relativePath);
+}
+
+function getClassification(
+  artifact: Wave10SourceArtifact,
+): CertificationBundleEntry["classification"] {
+  if (artifact.sourceKind === "scenario") {
+    return "representative-scenario";
+  }
+
+  return (
+    artifact.source.featureClassFocus ||
+    artifact.compatibilitySummary?.featureClassFocus ||
+    "supported-roundtrip"
+  );
+}
+
+function describeClassification(
+  classification: CertificationBundleEntry["classification"],
+): Pick<CertificationBundleEntry, "classificationLabel" | "classificationDetail"> {
+  if (classification === "supported-roundtrip") {
+    return {
+      classificationLabel: "Supported round-trip",
+      classificationDetail:
+        "Semantic support is claimed here. Word certification must confirm browser edits reopen cleanly and remain editable in Word.",
+    };
+  }
+
+  if (classification === "preserve-only") {
+    return {
+      classificationLabel: "Preserve-only",
+      classificationDetail:
+        "This is a survival proof, not a full semantic edit guarantee. Word certification should confirm reopen without damage while unsupported OOXML remains intact.",
+    };
+  }
+
+  if (classification === "unsupported-fatal") {
+    return {
+      classificationLabel: "Unsupported fatal",
+      classificationDetail:
+        "The correct outcome is fail-closed behavior before export. A pass here means the harness refused unsafe export rather than flattening content.",
+    };
+  }
+
+  return {
+    classificationLabel: "Representative scenario",
+    classificationDetail:
+      "Scenario artifacts preserve real-world structure. A pass means export stayed validator-delta-neutral or blocked safely; it does not widen the supported editing contract.",
+  };
+}
+
+function describeManualReview(
+  outcome: CertificationOutcome,
+): Pick<CertificationBundleManualReview, "label" | "tone"> {
+  if (outcome === "passed") {
+    return {
+      label: "Reviewed and passed",
+      tone: "success",
+    };
+  }
+
+  if (outcome === "issues-found") {
+    return {
+      label: "Issues found",
+      tone: "warning",
+    };
+  }
+
+  return {
+    label: "Not yet reviewed",
+    tone: "neutral",
+  };
+}
+
+function getLatestManualReview(
+  records: ManualCertificationRecord[],
+  artifact: Wave10SourceArtifact,
+  surface: CertificationSurface,
+  required: boolean,
+): CertificationBundleManualReview {
+  const latest = records
+    .filter((record) => {
+      if (record.surface !== surface) {
+        return false;
+      }
+
+      return (
+        record.runId === artifact.runStory.runId ||
+        record.exportId === artifact.exportRecord?.exportId ||
+        record.targetId === artifact.validationRun?.runId ||
+        record.targetId === artifact.exportRecord?.exportId
+      );
+    })
+    .sort((left, right) => right.observedAt.localeCompare(left.observedAt))[0];
+
+  if (!latest) {
+    const pending = describeManualReview("not-reviewed");
+    return {
+      surface,
+      required,
+      outcome: "not-reviewed",
+      ...pending,
+    };
+  }
+
+  return {
+    surface,
+    required,
+    outcome: latest.outcome,
+    ...describeManualReview(latest.outcome),
+    certificationId: latest.certificationId,
+    operator: latest.operator,
+    observedAt: latest.observedAt,
+    summary: latest.summary,
+    notes: latest.notes,
+    targetType: latest.targetType,
+    targetId: latest.targetId,
+  };
+}
+
+function getValidatorDetail(artifact: Wave10SourceArtifact): CertificationBundleEntry["validator"] {
+  const validationRun = artifact.validationRun;
+
+  if (!validationRun) {
+    return {
+      present: false,
+      detail: "No validator report was emitted for this artifact.",
+    };
+  }
+
+  if (artifact.sourceKind === "scenario") {
+    const packageDelta = artifact.validationDeltaFromSource?.packageFindingDelta;
+    const sdkDelta = artifact.validationDeltaFromSource?.sdkFindingDelta;
+    const deltaDetail =
+      typeof packageDelta === "number" && typeof sdkDelta === "number"
+        ? `delta ${packageDelta}/${sdkDelta} vs source`
+        : "source delta not recorded";
+
+    return {
+      present: true,
+      isValid: validationRun.summary.isValid,
+      packageFindingCount: validationRun.summary.packageFindingCount,
+      sdkFindingCount: validationRun.summary.sdkFindingCount,
+      packageFindingDelta: packageDelta,
+      sdkFindingDelta: sdkDelta,
+      detail: `${validationRun.summary.packageFindingCount} package / ${validationRun.summary.sdkFindingCount} SDK findings, ${deltaDetail}`,
+    };
+  }
+
+  return {
+    present: true,
+    isValid: validationRun.summary.isValid,
+    packageFindingCount: validationRun.summary.packageFindingCount,
+    sdkFindingCount: validationRun.summary.sdkFindingCount,
+    detail: validationRun.summary.isValid
+      ? "Validator clean"
+      : `${validationRun.summary.packageFindingCount + validationRun.summary.sdkFindingCount} validator findings recorded`,
+  };
+}
+
+function getJudgement(input: {
+  artifact: Wave10SourceArtifact;
+  classification: CertificationBundleEntry["classification"];
+  requiredManualReview: boolean;
+  expectedBlockedBeforeExport: boolean;
+  manualReviews: CertificationBundleEntry["manualReviews"];
+  validator: CertificationBundleEntry["validator"];
+}): CertificationBundleEntry["judgement"] {
+  const {
+    artifact,
+    classification,
+    requiredManualReview,
+    expectedBlockedBeforeExport,
+    manualReviews,
+    validator,
+  } = input;
+
+  if (classification === "unsupported-fatal") {
+    if (artifact.executionOutcome.state === "blocked-before-export") {
+      return {
+        state: "passed",
+        label: "Fail-closed behaved correctly",
+        tone: "success",
+        detail: artifact.executionOutcome.reason,
+      };
+    }
+
+    return {
+      state: "failed",
+      label: "Unsafe export path detected",
+      tone: "danger",
+      detail: "Unsupported-fatal content should have blocked export instead of producing a package.",
+    };
+  }
+
+  if (artifact.executionOutcome.state === "blocked-before-export") {
+    if (expectedBlockedBeforeExport) {
+      return {
+        state: "passed",
+        label: "Fail-closed export guard behaved correctly",
+        tone: "success",
+        detail:
+          "This representative scenario intentionally blocks export when a review action would require unsafe preserve-only anchor remapping. The block is the proof, not a missing export.",
+      };
+    }
+
+    return {
+      state: "blocked",
+      label: "Blocked before export",
+      tone: "warning",
+      detail: artifact.executionOutcome.reason,
+    };
+  }
+
+  if (!validator.present) {
+    return {
+      state: "failed",
+      label: "Validator artifact missing",
+      tone: "danger",
+      detail: "The run exported a document but did not persist a validator report.",
+    };
+  }
+
+  if (classification === "supported-roundtrip" && validator.isValid === false) {
+    return {
+      state: "failed",
+      label: "Supported round-trip regressed",
+      tone: "danger",
+      detail: "Supported-roundtrip content exported with validator findings, so semantic compatibility is not proved.",
+    };
+  }
+
+  if (
+    classification === "representative-scenario" &&
+    ((validator.packageFindingDelta ?? 0) > 0 || (validator.sdkFindingDelta ?? 0) > 0)
+  ) {
+    return {
+      state: "failed",
+      label: "Scenario validator delta regressed",
+      tone: "danger",
+      detail: "Scenario export introduced new validator findings beyond the recorded source baseline.",
+    };
+  }
+
+  if (
+    requiredManualReview &&
+    (manualReviews.wordDesktop.outcome !== "passed" || manualReviews.wordWeb.outcome !== "passed")
+  ) {
+    return {
+      state: "blocked",
+      label: "Waiting for human Word certification",
+      tone: "warning",
+      detail:
+        classification === "preserve-only"
+          ? "Machine evidence is present, but preserve-only survival still needs explicit Word desktop and Word web reopen checks."
+          : classification === "representative-scenario"
+            ? "Scenario artifact is machine-backed, but manual Word review is still required to distinguish survival from support."
+            : "Machine evidence is present, but supported-roundtrip behavior still needs explicit Word desktop and Word web confirmation.",
+    };
+  }
+
+  if (classification === "preserve-only") {
+    return {
+      state: "passed",
+      label: "Preserve-only survival candidate",
+      tone: "success",
+      detail:
+        "Validator evidence is clean. Treat this as reopen-survival proof only, not as editable semantic support for the preserved surface.",
+    };
+  }
+
+  if (classification === "representative-scenario") {
+    return {
+      state: "passed",
+      label: "Scenario stayed delta-neutral",
+      tone: "success",
+      detail:
+        "Representative export did not add validator findings beyond the source baseline. This is scenario stability proof, not a broader support claim.",
+    };
+  }
+
+  return {
+    state: "passed",
+    label: "Supported semantic round-trip candidate",
+    tone: "success",
+    detail:
+      "Validator evidence is clean for a supported-roundtrip surface. Human Word review remains the release gate for the final certification claim.",
+  };
+}
+
+function createEntry(input: {
+  artifact: Wave10SourceArtifact;
+  requiredManualReview: boolean;
+  expectedBlockedBeforeExport?: boolean;
+  manualReviewRecords: ManualCertificationRecord[];
+}): CertificationBundleEntry {
+  const classification = getClassification(input.artifact);
+  const manualReviews = {
+    wordDesktop: getLatestManualReview(
+      input.manualReviewRecords,
+      input.artifact,
+      "word-desktop",
+      input.requiredManualReview,
+    ),
+    wordWeb: getLatestManualReview(
+      input.manualReviewRecords,
+      input.artifact,
+      "word-web",
+      input.requiredManualReview,
+    ),
+  };
+  const validator = getValidatorDetail(input.artifact);
+  const judgement = getJudgement({
+    artifact: input.artifact,
+    classification,
+    requiredManualReview: input.requiredManualReview,
+    expectedBlockedBeforeExport: input.expectedBlockedBeforeExport ?? false,
+    manualReviews,
+    validator,
+  });
+
+  return {
+    sourceKey: input.artifact.sourceKey,
+    sourceLabel: input.artifact.source.sourceLabel,
+    sourceKind: input.artifact.sourceKind,
+    fileName: input.artifact.source.fileName,
+    classification,
+    ...describeClassification(classification),
+    requiredManualReview: input.requiredManualReview,
+    runId: input.artifact.runStory.runId,
+    validationRunId: input.artifact.validationRun?.runId,
+    exportId: input.artifact.exportRecord?.exportId,
+    createdAt: input.artifact.runStory.createdAt,
+    generatedAt: input.artifact.generatedAt,
+    wordExpectation: input.artifact.source.wordExpectation,
+    executionOutcome: input.artifact.executionOutcome,
+    compatibilitySummary: input.artifact.compatibilitySummary,
+    validator,
+    judgement,
+    manualReviews,
+  };
+}
+
+function parseNoteStatus(raw: string | undefined): CertificationBundleNote["status"] {
+  if (!raw) {
+    return "missing";
+  }
+
+  const match = /^status:\s*(passed|pending|issues-found)$/im.exec(raw);
+  return match ? (match[1] as CertificationBundleNote["status"]) : "pending";
+}
+
+async function readNote(relativePath: string): Promise<CertificationBundleNote> {
+  const body = await readTextFile(getArtifactPath(relativePath));
+
+  return {
+    relativePath,
+    exists: typeof body === "string",
+    status: parseNoteStatus(body),
+    body,
+  };
+}
+
+async function loadManifest(): Promise<Wave10Manifest> {
+  const manifest = await readJsonFile<Wave10Manifest>(manifestPath);
+
+  if (!manifest) {
+    throw new Error("Wave 10 certification manifest is missing.");
+  }
+
+  return manifest;
+}
+
+async function loadRegression(): Promise<Wave10RegressionReport> {
+  const regression = await readJsonFile<Wave10RegressionReport>(regressionReportPath);
+
+  if (!regression) {
+    throw new Error("Wave 10 regression report is missing.");
+  }
+
+  return regression;
+}
+
+async function loadFreshness(): Promise<Wave10FreshnessReport> {
+  const freshness = await readJsonFile<Wave10FreshnessReport>(freshnessPath);
+
+  if (!freshness) {
+    throw new Error("Wave 10 certification freshness report is missing.");
+  }
+
+  return freshness;
+}
+
+async function loadSourceArtifact(sourceKey: string): Promise<Wave10SourceArtifact> {
+  const artifact = await readJsonFile<Wave10SourceArtifact>(
+    getArtifactPath(`${sourceKey.toLowerCase()}-run.json`),
+  );
+
+  if (!artifact) {
+    throw new Error(`Wave 10 source artifact ${sourceKey} is missing.`);
+  }
+
+  return artifact;
+}
+
+function countManualSurfacePasses(entries: CertificationBundleEntry[]): number {
+  return entries.reduce((count, entry) => {
+    const desktopPassed = entry.manualReviews.wordDesktop.required
+      ? entry.manualReviews.wordDesktop.outcome === "passed"
+      : false;
+    const webPassed = entry.manualReviews.wordWeb.required
+      ? entry.manualReviews.wordWeb.outcome === "passed"
+      : false;
+
+    return count + Number(desktopPassed) + Number(webPassed);
+  }, 0);
+}
+
+function countRequiredManualSurfaces(entries: CertificationBundleEntry[]): number {
+  return entries.reduce((count, entry) => {
+    if (!entry.requiredManualReview) {
+      return count;
+    }
+
+    return count + 2;
+  }, 0);
+}
+
+function findAnchorEntry(entries: CertificationBundleEntry[], runId: string): CertificationBundleEntry | undefined {
+  return entries.find(
+    (entry) => entry.runId === runId || entry.validationRunId === runId,
+  );
+}
+
+export async function getCertificationBundleModel(
+  runId: string,
+): Promise<CertificationBundleModel | undefined> {
+  const [manifest, regression, freshness, manualReviewRecords, desktopNote, webNote, representativeExportValidator] =
+    await Promise.all([
+      loadManifest(),
+      loadRegression(),
+      loadFreshness(),
+      listManualCertifications(),
+      readNote("word-desktop-certification.md"),
+      readNote("word-web-certification.md"),
+      readJsonFile<CertificationBundleValidatorReport["report"]>(representativeValidatorPath),
+    ]);
+
+  const [releaseGateArtifacts, scenarioArtifacts] = await Promise.all([
+    Promise.all(manifest.releaseGateFixtures.map((sourceKey) => loadSourceArtifact(sourceKey))),
+    Promise.all(manifest.representativeScenarios.map((sourceKey) => loadSourceArtifact(sourceKey))),
+  ]);
+
+  const manualReviewKeys = new Set([
+    ...manifest.manualReviewFixtures,
+    ...manifest.manualReviewScenarios,
+  ]);
+
+  const releaseGateFixtures = releaseGateArtifacts.map((artifact) =>
+    createEntry({
+      artifact,
+      requiredManualReview: manualReviewKeys.has(artifact.sourceKey),
+      expectedBlockedBeforeExport: false,
+      manualReviewRecords,
+    }),
+  );
+  const representativeScenarios = scenarioArtifacts.map((artifact) =>
+    createEntry({
+      artifact,
+      requiredManualReview: manualReviewKeys.has(artifact.sourceKey),
+      expectedBlockedBeforeExport:
+        manifest.expectedBlockedScenarios?.includes(artifact.sourceKey) ?? false,
+      manualReviewRecords,
+    }),
+  );
+  const allEntries = [...releaseGateFixtures, ...representativeScenarios];
+  const anchorEntry = findAnchorEntry(allEntries, runId);
+
+  if (!anchorEntry) {
+    return undefined;
+  }
+
+  const anchorArtifact =
+    releaseGateArtifacts.find((artifact) => artifact.sourceKey === anchorEntry.sourceKey) ||
+    scenarioArtifacts.find((artifact) => artifact.sourceKey === anchorEntry.sourceKey);
+
+  if (!anchorArtifact) {
+    return undefined;
+  }
+
+  const manualReviewEntries = allEntries.filter((entry) => entry.requiredManualReview);
+
+  return {
+    bundleId: anchorArtifact.proofContext.bundleId,
+    anchorRunId: runId,
+    anchorSourceKey: anchorEntry.sourceKey,
+    generatedAt: regression.generatedAt,
+    overallStatus: regression.overallStatus,
+    repoState: freshness.repoState,
+    regression,
+    freshness,
+    releaseGateFixtures,
+    representativeScenarios,
+    manualReviewEntries,
+    anchorEntry,
+    desktopNote,
+    webNote,
+    representativeExportValidator: {
+      path: representativeValidatorPath,
+      report: representativeExportValidator,
+    },
+    summary: {
+      releaseGateFixturesPassed: regression.summary.releaseGateFixturesPassed,
+      releaseGateFixturesTotal: regression.summary.releaseGateFixturesTotal,
+      representativeScenariosPassed: regression.summary.representativeScenariosPassed,
+      representativeScenariosTotal: regression.summary.representativeScenariosTotal,
+      requiredArtifactsPassed: regression.summary.requiredArtifactsPassed,
+      requiredArtifactsTotal: regression.summary.requiredArtifactsTotal,
+      manualReviewSurfacesPassed: countManualSurfacePasses(manualReviewEntries),
+      manualReviewSurfacesTotal: countRequiredManualSurfaces(manualReviewEntries),
+      pendingManualReviewEntries: manualReviewEntries.filter(
+        (entry) =>
+          entry.manualReviews.wordDesktop.outcome !== "passed" ||
+          entry.manualReviews.wordWeb.outcome !== "passed",
+      ).length,
+    },
+  };
+}