@beyondwork/docx-react-component 1.0.0 → 1.0.1

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

@@ -1,796 +0,0 @@
-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,
-    },
-  };
-}