@beyondwork/docx-react-component 1.0.0 → 1.0.2

package/services/react-word-editor/lib/run-history.ts

@@ -1,755 +0,0 @@
-import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  listManualCertifications,
-  type CertificationOutcome,
-  type CertificationSurface,
-  type ManualCertificationRecord,
-} from "./certification-store";
-import { getHarnessValidationRunModel } from "./harness-client";
-import type {
-  Wave10CertificationFreshnessManifest,
-  Wave10CoverageEntry,
-  Wave10FixtureCoverageManifest,
-  Wave10RegressionReport,
-  Wave10SignoffArtifactStatus,
-  Wave10SourceRunArtifact,
-} from "./regression-report";
-
-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 dashboardSummaryPath = path.join(wave10BundleRootDir, "dashboard-summary.json");
-const runHistoryCheckPath = path.join(wave10BundleRootDir, "run-history-check.json");
-const fixtureCoveragePath = path.join(wave10BundleRootDir, "fixture-coverage.json");
-const certificationFreshnessPath = path.join(wave10BundleRootDir, "certification-freshness.json");
-const regressionReportPath = path.join(wave10BundleRootDir, "regression-report.json");
-
-type DashboardTone = "neutral" | "success" | "warning" | "danger";
-type CoverageStatus = Wave10CoverageEntry["status"];
-
-type MarkdownSignoffMetadata = {
-  status: "passed" | "pending" | "issues-found" | "missing";
-  wave?: string;
-  bundleId?: string;
-  commit?: string;
-  generatedAt?: string;
-};
-
-export type DashboardArtifactStatus = Wave10SignoffArtifactStatus & {
-  label: string;
-  tone: DashboardTone;
-  metadata?: MarkdownSignoffMetadata;
-};
-
-export type DashboardManualSurfaceState = {
-  required: boolean;
-  outcome: CertificationOutcome;
-  label: string;
-  tone: DashboardTone;
-  observedAt?: string;
-  operator?: string;
-  summary?: string;
-};
-
-export type DashboardCoverageItem = Wave10CoverageEntry & {
-  tone: DashboardTone;
-  validatorLabel: string;
-  validatorTone: DashboardTone;
-  runRoute?: string;
-  apiRoute?: string;
-  validationRunId?: string;
-  manualStatus: {
-    desktop: DashboardManualSurfaceState;
-    web: DashboardManualSurfaceState;
-  };
-};
-
-export type Wave10RunHistoryCheckEntry = {
-  sourceKey: string;
-  sourceKind: Wave10CoverageEntry["sourceKind"];
-  runId?: string;
-  validationRunId?: string;
-  routePath?: string;
-  apiPath?: string;
-  state: "ok" | "gap";
-  detail: string;
-  executionOutcome?: string;
-  coverageStatus: CoverageStatus;
-  manualCertificationState: "pending" | "attached" | "missing";
-};
-
-export type Wave10RunHistoryCheck = {
-  schemaVersion: "wave-10-run-history-check/1";
-  generatedAt: string;
-  bundleRoot: string;
-  summary: {
-    entries: number;
-    ok: number;
-    gaps: number;
-    blockedBeforeExport: number;
-    validatedRuns: number;
-  };
-  runs: Wave10RunHistoryCheckEntry[];
-};
-
-export type Wave10DashboardSummaryArtifact = {
-  schemaVersion: "wave-10-dashboard-summary/1";
-  generatedAt: string;
-  bundleRoot: string;
-  overallStatus: Wave10RegressionReport["overallStatus"];
-  repoState: Wave10RegressionReport["repoState"];
-  summary: {
-    releaseGateFixturesPassed: number;
-    releaseGateFixturesTotal: number;
-    representativeScenariosPassed: number;
-    representativeScenariosTotal: number;
-    requiredArtifactsPassed: number;
-    requiredArtifactsTotal: number;
-    requiredManualSurfacesPassed: number;
-    requiredManualSurfacesTotal: number;
-    runHistoryGaps: number;
-  };
-  signoffs: Array<{
-    relativePath: string;
-    status: Wave10SignoffArtifactStatus["status"];
-  }>;
-  attentionQueue: Array<{
-    sourceKey: string;
-    status: CoverageStatus;
-    detail: string;
-    featureClassFocus?: string;
-    validationRunId?: string;
-  }>;
-  blockingReasons: string[];
-};
-
-export type Wave10DashboardModel = {
-  generatedAt: string;
-  bundleRoot: string;
-  regression: Wave10RegressionReport;
-  freshness: Wave10CertificationFreshnessManifest;
-  artifacts: DashboardArtifactStatus[];
-  releaseGateFixtures: DashboardCoverageItem[];
-  representativeScenarios: DashboardCoverageItem[];
-  attentionQueue: DashboardCoverageItem[];
-  runHistory: Wave10RunHistoryCheck;
-  manualCertification: {
-    requiredSurfaces: number;
-    reviewedSurfaces: number;
-    pendingSurfaces: number;
-    issuesFoundSurfaces: number;
-  };
-  proofArtifacts: {
-    dashboardSummaryPath: string;
-    runHistoryCheckPath: string;
-  };
-  recentManualCertifications: ManualCertificationRecord[];
-};
-
-export type Wave10RunDiagnostics = {
-  runId: string;
-  sourceKey?: string;
-  coverage?: DashboardCoverageItem;
-  runHistory?: Wave10RunHistoryCheckEntry;
-  runStory?: Wave10SourceRunArtifact["runStory"];
-  manualCertification: {
-    validationRun: ManualCertificationRecord[];
-    exportArtifact: ManualCertificationRecord[];
-  };
-  freshness: {
-    overallStatus: Wave10CertificationFreshnessManifest["overallStatus"];
-    blockingReasons: string[];
-  };
-};
-
-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 writeJsonAtomic(filePath: string, value: unknown): Promise<void> {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile(tempPath, JSON.stringify(value, null, 2));
-  await rename(tempPath, filePath);
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await stat(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function parseMarkdownMetadata(raw: string): MarkdownSignoffMetadata {
-  const getField = (field: string) => {
-    const match = new RegExp(`^${field}:\\s*(.+)$`, "im").exec(raw);
-    return match ? match[1].trim() : undefined;
-  };
-  const status = getField("status");
-
-  return {
-    status:
-      status === "passed" || status === "issues-found" || status === "pending"
-        ? status
-        : "missing",
-    wave: getField("wave"),
-    bundleId: getField("bundleId"),
-    commit: getField("commit"),
-    generatedAt: getField("generatedAt"),
-  };
-}
-
-function getArtifactTone(status: Wave10SignoffArtifactStatus["status"]): DashboardTone {
-  if (status === "passed") {
-    return "success";
-  }
-
-  if (status === "missing") {
-    return "danger";
-  }
-
-  if (status === "issues-found") {
-    return "warning";
-  }
-
-  return "warning";
-}
-
-function getCoverageTone(status: CoverageStatus): DashboardTone {
-  if (status === "passed") {
-    return "success";
-  }
-
-  if (status === "failed") {
-    return "danger";
-  }
-
-  if (status === "missing") {
-    return "warning";
-  }
-
-  return "warning";
-}
-
-function formatArtifactLabel(relativePath: string): string {
-  return relativePath
-    .replace(/\.md$|\.json$/g, "")
-    .split(/[-_/]/g)
-    .map((part) => (part.length > 0 ? `${part.slice(0, 1).toUpperCase()}${part.slice(1)}` : part))
-    .join(" ");
-}
-
-function getValidatorSummary(entry: Wave10CoverageEntry): {
-  label: string;
-  tone: DashboardTone;
-} {
-  if (!entry.validator.present) {
-    return {
-      label: "No validator snapshot",
-      tone: "warning",
-    };
-  }
-
-  if (entry.validator.isValid) {
-    if (
-      typeof entry.validator.packageFindingDelta === "number" ||
-      typeof entry.validator.sdkFindingDelta === "number"
-    ) {
-      const packageDelta = entry.validator.packageFindingDelta ?? 0;
-      const sdkDelta = entry.validator.sdkFindingDelta ?? 0;
-      return {
-        label: `Validator delta package ${packageDelta}, SDK ${sdkDelta}`,
-        tone: packageDelta > 0 || sdkDelta > 0 ? "warning" : "success",
-      };
-    }
-
-    return {
-      label: "Validator clean",
-      tone: "success",
-    };
-  }
-
-  const findingCount =
-    (entry.validator.packageFindingCount ?? 0) + (entry.validator.sdkFindingCount ?? 0);
-
-  return {
-    label: `${findingCount} validator finding${findingCount === 1 ? "" : "s"}`,
-    tone: "danger",
-  };
-}
-
-function createPendingSurfaceState(required: boolean): DashboardManualSurfaceState {
-  return {
-    required,
-    outcome: "not-reviewed",
-    label: required ? "Pending" : "Not required",
-    tone: required ? "warning" : "neutral",
-  };
-}
-
-function summarizeManualSurface(
-  required: boolean,
-  record: ManualCertificationRecord | undefined,
-): DashboardManualSurfaceState {
-  if (!record) {
-    return createPendingSurfaceState(required);
-  }
-
-  if (record.outcome === "passed") {
-    return {
-      required,
-      outcome: record.outcome,
-      label: "Passed",
-      tone: "success",
-      observedAt: record.observedAt,
-      operator: record.operator,
-      summary: record.summary,
-    };
-  }
-
-  if (record.outcome === "issues-found") {
-    return {
-      required,
-      outcome: record.outcome,
-      label: "Issues found",
-      tone: "danger",
-      observedAt: record.observedAt,
-      operator: record.operator,
-      summary: record.summary,
-    };
-  }
-
-  return {
-    required,
-    outcome: record.outcome,
-    label: "Pending",
-    tone: required ? "warning" : "neutral",
-    observedAt: record.observedAt,
-    operator: record.operator,
-    summary: record.summary,
-  };
-}
-
-function createManualRecordMap(
-  records: ManualCertificationRecord[],
-): Map<string, ManualCertificationRecord> {
-  const map = new Map<string, ManualCertificationRecord>();
-
-  for (const record of records) {
-    const key = `${record.sourceId ?? "unknown"}:${record.surface}`;
-    const existing = map.get(key);
-
-    if (!existing || record.observedAt >= existing.observedAt) {
-      map.set(key, record);
-    }
-  }
-
-  return map;
-}
-
-async function readSignoffArtifacts(
-  freshness: Wave10CertificationFreshnessManifest,
-): Promise<DashboardArtifactStatus[]> {
-  return Promise.all(
-    freshness.requiredArtifacts.map(async (artifact) => {
-      const absolutePath = path.join(wave10BundleRootDir, artifact.relativePath);
-      const metadata =
-        artifact.relativePath.endsWith(".md") && (await fileExists(absolutePath))
-          ? parseMarkdownMetadata(await readFile(absolutePath, "utf8"))
-          : undefined;
-      const status = metadata?.status && metadata.status !== "missing" ? metadata.status : artifact.status;
-
-      return {
-        ...artifact,
-        status,
-        label: formatArtifactLabel(artifact.relativePath),
-        tone: getArtifactTone(status),
-        metadata,
-      };
-    }),
-  );
-}
-
-async function readSourceRunArtifact(
-  relativePath: string,
-): Promise<Wave10SourceRunArtifact | undefined> {
-  return readJsonFile<Wave10SourceRunArtifact>(path.join(wave10BundleRootDir, relativePath));
-}
-
-async function buildCoverageItems(
-  entries: Wave10CoverageEntry[],
-  manualRecordMap: Map<string, ManualCertificationRecord>,
-): Promise<DashboardCoverageItem[]> {
-  return Promise.all(
-    entries.map(async (entry) => {
-      const sourceRun = await readSourceRunArtifact(entry.artifactRelativePath);
-      const desktopRecord = manualRecordMap.get(`${entry.sourceId}:word-desktop`);
-      const webRecord = manualRecordMap.get(`${entry.sourceId}:word-web`);
-      const validator = getValidatorSummary(entry);
-      const validationRunId = sourceRun?.validationRun?.runId;
-
-      return {
-        ...entry,
-        tone: getCoverageTone(entry.status),
-        validatorLabel: validator.label,
-        validatorTone: validator.tone,
-        validationRunId,
-        runRoute: validationRunId ? `/runs/${validationRunId}` : undefined,
-        apiRoute: validationRunId ? `/api/runs/${validationRunId}` : undefined,
-        manualStatus: {
-          desktop: summarizeManualSurface(entry.manualReviews.wordDesktop.required, desktopRecord),
-          web: summarizeManualSurface(entry.manualReviews.wordWeb.required, webRecord),
-        },
-      };
-    }),
-  );
-}
-
-function sortAttentionQueue(items: DashboardCoverageItem[]): DashboardCoverageItem[] {
-  const severityRank: Record<CoverageStatus, number> = {
-    failed: 0,
-    blocked: 1,
-    missing: 2,
-    passed: 3,
-  };
-
-  return items
-    .slice()
-    .sort((left, right) => {
-      const severity = severityRank[left.status] - severityRank[right.status];
-      if (severity !== 0) {
-        return severity;
-      }
-
-      const leftPreserveOnly = left.compatibility?.preserveOnlyFeatureCount ?? 0;
-      const rightPreserveOnly = right.compatibility?.preserveOnlyFeatureCount ?? 0;
-      if (leftPreserveOnly !== rightPreserveOnly) {
-        return rightPreserveOnly - leftPreserveOnly;
-      }
-
-      return left.sourceKey.localeCompare(right.sourceKey);
-    });
-}
-
-async function buildRunHistoryCheck(
-  entries: DashboardCoverageItem[],
-): Promise<Wave10RunHistoryCheck> {
-  const runs = await Promise.all(
-    entries.map(async (entry) => {
-      const sourceRun = await readSourceRunArtifact(entry.artifactRelativePath);
-      const validationRunId = sourceRun?.validationRun?.runId;
-      const validationModel = validationRunId
-        ? await getHarnessValidationRunModel(validationRunId)
-        : undefined;
-      const expectedState = sourceRun?.executionOutcome?.state;
-      const manualState = sourceRun?.runStory.manualCertification.state ?? "missing";
-
-      let state: "ok" | "gap" = "ok";
-      let detail = "Stored run artifacts map cleanly to a harness validation route.";
-
-      if (!sourceRun) {
-        state = "gap";
-        detail = "Source run artifact is missing from the Wave 10 bundle.";
-      } else if (entry.runId && sourceRun.runStory.runId !== entry.runId) {
-        state = "gap";
-        detail = "Coverage entry and stored run story disagree on the run id.";
-      } else if (
-        expectedState === "exported-and-validated" &&
-        (!validationRunId || !sourceRun.validationRun)
-      ) {
-        state = "gap";
-        detail = "Validated run is missing its stored validator snapshot.";
-      } else if (validationRunId && !validationModel) {
-        state = "gap";
-        detail = "Run history points at a validator run that the harness API cannot resolve.";
-      } else if (
-        expectedState === "blocked-before-export" &&
-        (sourceRun.validationRun || validationRunId)
-      ) {
-        state = "gap";
-        detail = "Blocked-before-export run should not carry a validator snapshot.";
-      } else if (manualState === "missing") {
-        state = "gap";
-        detail = "Run story is missing its reserved manual certification slot.";
-      } else if (expectedState === "blocked-before-export") {
-        detail = "Run is intentionally blocked before export; no validator route is expected.";
-      }
-
-      return {
-        sourceKey: entry.sourceKey,
-        sourceKind: entry.sourceKind,
-        runId: sourceRun?.runStory.runId ?? entry.runId,
-        validationRunId,
-        routePath: validationRunId ? `/runs/${validationRunId}` : undefined,
-        apiPath: validationRunId ? `/api/runs/${validationRunId}` : undefined,
-        state,
-        detail,
-        executionOutcome: expectedState,
-        coverageStatus: entry.status,
-        manualCertificationState: manualState,
-      } satisfies Wave10RunHistoryCheckEntry;
-    }),
-  );
-
-  return {
-    schemaVersion: "wave-10-run-history-check/1",
-    generatedAt: new Date().toISOString(),
-    bundleRoot: wave10BundleRootDir,
-    summary: {
-      entries: runs.length,
-      ok: runs.filter((entry) => entry.state === "ok").length,
-      gaps: runs.filter((entry) => entry.state === "gap").length,
-      blockedBeforeExport: runs.filter(
-        (entry) => entry.executionOutcome === "blocked-before-export",
-      ).length,
-      validatedRuns: runs.filter((entry) => Boolean(entry.validationRunId)).length,
-    },
-    runs,
-  };
-}
-
-function buildDashboardSummaryArtifact(input: {
-  regression: Wave10RegressionReport;
-  artifacts: DashboardArtifactStatus[];
-  attentionQueue: DashboardCoverageItem[];
-  runHistory: Wave10RunHistoryCheck;
-}): Wave10DashboardSummaryArtifact {
-  return {
-    schemaVersion: "wave-10-dashboard-summary/1",
-    generatedAt: new Date().toISOString(),
-    bundleRoot: wave10BundleRootDir,
-    overallStatus: input.regression.overallStatus,
-    repoState: input.regression.repoState,
-    summary: {
-      ...input.regression.summary,
-      runHistoryGaps: input.runHistory.summary.gaps,
-    },
-    signoffs: input.artifacts.map((artifact) => ({
-      relativePath: artifact.relativePath,
-      status: artifact.status,
-    })),
-    attentionQueue: input.attentionQueue.slice(0, 12).map((entry) => ({
-      sourceKey: entry.sourceKey,
-      status: entry.status,
-      detail: entry.detail,
-      featureClassFocus: entry.featureClassFocus,
-      validationRunId: entry.validationRunId,
-    })),
-    blockingReasons: input.regression.blockingReasons,
-  };
-}
-
-async function loadWave10BaseArtifacts() {
-  const [regression, freshness, coverage, recentManualCertifications] = await Promise.all([
-    readJsonFile<Wave10RegressionReport>(regressionReportPath),
-    readJsonFile<Wave10CertificationFreshnessManifest>(certificationFreshnessPath),
-    readJsonFile<Wave10FixtureCoverageManifest>(fixtureCoveragePath),
-    listManualCertifications(),
-  ]);
-
-  if (!regression || !freshness || !coverage) {
-    throw new Error("Wave 10 dashboard artifacts are incomplete. Expected regression, freshness, and coverage manifests.");
-  }
-
-  return {
-    regression,
-    freshness,
-    coverage,
-    recentManualCertifications,
-  };
-}
-
-async function computeWave10DashboardModel(): Promise<Wave10DashboardModel> {
-  const { regression, freshness, coverage, recentManualCertifications } =
-    await loadWave10BaseArtifacts();
-  const manualRecordMap = createManualRecordMap(recentManualCertifications);
-  const artifacts = await readSignoffArtifacts(freshness);
-  const [releaseGateFixtures, representativeScenarios] = await Promise.all([
-    buildCoverageItems(coverage.releaseGateFixtures, manualRecordMap),
-    buildCoverageItems(coverage.representativeScenarios, manualRecordMap),
-  ]);
-  const attentionQueue = sortAttentionQueue(
-    [...releaseGateFixtures, ...representativeScenarios].filter(
-      (entry) =>
-        entry.status !== "passed" ||
-        (entry.compatibility?.preserveOnlyFeatureCount ?? 0) > 0 ||
-        entry.manualStatus.desktop.outcome === "issues-found" ||
-        entry.manualStatus.web.outcome === "issues-found",
-    ),
-  );
-  const runHistory = await buildRunHistoryCheck([
-    ...releaseGateFixtures,
-    ...representativeScenarios,
-  ]);
-  const allCoverageItems = [...releaseGateFixtures, ...representativeScenarios];
-  const requiredSurfaces = allCoverageItems.reduce(
-    (count, item) =>
-      count +
-      (item.manualStatus.desktop.required ? 1 : 0) +
-      (item.manualStatus.web.required ? 1 : 0),
-    0,
-  );
-  const reviewedSurfaces = allCoverageItems.reduce(
-    (count, item) =>
-      count +
-      (item.manualStatus.desktop.required && item.manualStatus.desktop.outcome !== "not-reviewed"
-        ? 1
-        : 0) +
-      (item.manualStatus.web.required && item.manualStatus.web.outcome !== "not-reviewed" ? 1 : 0),
-    0,
-  );
-  const issuesFoundSurfaces = allCoverageItems.reduce(
-    (count, item) =>
-      count +
-      (item.manualStatus.desktop.outcome === "issues-found" ? 1 : 0) +
-      (item.manualStatus.web.outcome === "issues-found" ? 1 : 0),
-    0,
-  );
-
-  return {
-    generatedAt: new Date().toISOString(),
-    bundleRoot: wave10BundleRootDir,
-    regression,
-    freshness,
-    artifacts,
-    releaseGateFixtures,
-    representativeScenarios,
-    attentionQueue,
-    runHistory,
-    manualCertification: {
-      requiredSurfaces,
-      reviewedSurfaces,
-      pendingSurfaces: Math.max(requiredSurfaces - reviewedSurfaces, 0),
-      issuesFoundSurfaces,
-    },
-    proofArtifacts: {
-      dashboardSummaryPath,
-      runHistoryCheckPath,
-    },
-    recentManualCertifications: recentManualCertifications.slice(0, 12),
-  };
-}
-
-async function syncWave10DashboardArtifacts(
-  model: Wave10DashboardModel,
-): Promise<void> {
-  const summaryArtifact = buildDashboardSummaryArtifact({
-    regression: model.regression,
-    artifacts: model.artifacts,
-    attentionQueue: model.attentionQueue,
-    runHistory: model.runHistory,
-  });
-
-  await Promise.all([
-    writeJsonAtomic(dashboardSummaryPath, summaryArtifact),
-    writeJsonAtomic(runHistoryCheckPath, model.runHistory),
-  ]);
-}
-
-export async function getWave10DashboardModel(): Promise<Wave10DashboardModel> {
-  const model = await computeWave10DashboardModel();
-  await syncWave10DashboardArtifacts(model);
-  return model;
-}
-
-export async function getWave10RunDiagnostics(
-  validationRunId: string,
-): Promise<Wave10RunDiagnostics | undefined> {
-  const [validationModel, dashboard, manualCertifications] = await Promise.all([
-    getHarnessValidationRunModel(validationRunId),
-    getWave10DashboardModel(),
-    listManualCertifications(),
-  ]);
-
-  if (!validationModel) {
-    return undefined;
-  }
-
-  const coverage =
-    [...dashboard.releaseGateFixtures, ...dashboard.representativeScenarios].find(
-      (entry) => entry.validationRunId === validationRunId,
-    );
-  const runHistory = dashboard.runHistory.runs.find(
-    (entry) => entry.validationRunId === validationRunId,
-  );
-  const sourceRun = coverage
-    ? await readSourceRunArtifact(coverage.artifactRelativePath)
-    : undefined;
-  const relatedManual = manualCertifications.filter(
-    (record) =>
-      record.runId === validationRunId ||
-      (validationModel.exportRecord?.exportId &&
-        record.exportId === validationModel.exportRecord.exportId),
-  );
-
-  return {
-    runId: validationRunId,
-    sourceKey: coverage?.sourceKey,
-    coverage,
-    runHistory,
-    runStory: sourceRun?.runStory,
-    manualCertification: {
-      validationRun: relatedManual.filter((record) => record.runId === validationRunId),
-      exportArtifact: validationModel.exportRecord?.exportId
-        ? relatedManual.filter(
-            (record) => record.exportId === validationModel.exportRecord?.exportId,
-          )
-        : [],
-    },
-    freshness: {
-      overallStatus: dashboard.freshness.overallStatus,
-      blockingReasons: dashboard.freshness.blockingReasons,
-    },
-  };
-}
-
-export function getDashboardToneClasses(tone: DashboardTone): string {
-  if (tone === "success") {
-    return "bg-green-100 text-green-900";
-  }
-
-  if (tone === "warning") {
-    return "bg-amber-100 text-amber-900";
-  }
-
-  if (tone === "danger") {
-    return "bg-red-100 text-red-900";
-  }
-
-  return "bg-black/[0.05] text-black/65";
-}
-
-export function formatDashboardTimestamp(value: string | undefined): string {
-  if (!value) {
-    return "Not recorded";
-  }
-
-  return new Intl.DateTimeFormat("en-US", {
-    dateStyle: "medium",
-    timeStyle: "short",
-    timeZone: "UTC",
-  }).format(new Date(value));
-}
-
-export function getManualSurfaceSummary(surface: DashboardManualSurfaceState): string {
-  if (!surface.required && surface.outcome === "not-reviewed") {
-    return "Not required for this source.";
-  }
-
-  if (!surface.summary) {
-    return surface.required ? "Manual certification still pending." : "No stored certification note.";
-  }
-
-  return surface.summary;
-}