@anthusai/papyrus 0.0.0 → 1.0.0-next.10

package/lib/newsroom-articles.ts

@@ -0,0 +1,325 @@
+import { generateClient } from "aws-amplify/data";
+import type { Schema } from "../amplify/data/resource";
+import {
+  deriveMarkus,
+  publishItem,
+  saveItemDraft,
+  unpublishItem,
+  type ContentActionError,
+} from "./content-actions-client";
+import { createDemoArticlesBackend } from "./content-actions-demo";
+
+export type ArticleStatus = "draft" | "published";
+export type ArticleType = "article" | "page";
+
+export const ARTICLE_TYPES: ArticleType[] = ["article", "page"];
+
+export type NewsroomArticleRow = {
+  id: string;
+  type: string;
+  slug: string;
+  section: string | null;
+  title: string;
+  status: ArticleStatus;
+  pending: boolean;
+  updatedAt: string;
+};
+
+export type ArticleItemSummary = {
+  id: string;
+  lineageId?: string | null;
+  type: string;
+  slug: string;
+  section?: string | null;
+  title?: string | null;
+  status: string;
+  contentHash?: string | null;
+  updatedAt?: string | null;
+};
+
+export type PublishedItemSummary = {
+  id: string;
+  itemLineageId?: string | null;
+  sourceItemId?: string | null;
+  metadata?: unknown;
+};
+
+export type NewsroomArticleEditorState = {
+  id: string | null;
+  type: string;
+  section: string;
+  slug: string;
+  frontMatterYaml: string;
+  bodyMarkus: string;
+  contentHash: string | null;
+  status: ArticleStatus;
+  versionNumber: number | null;
+  dirty: boolean;
+};
+
+export type EditableArticle = {
+  id: string;
+  type: string;
+  section: string | null;
+  slug: string;
+  frontMatterYaml: string;
+  bodyMarkus: string;
+  contentHash: string | null;
+  status: ArticleStatus;
+  versionNumber: number | null;
+  aliases: string[];
+  everPublished: boolean;
+};
+
+export type ArticlesBackend = {
+  actions: {
+    deriveMarkus: typeof deriveMarkus;
+    saveItemDraft: typeof saveItemDraft;
+    publishItem: typeof publishItem;
+    unpublishItem: typeof unpublishItem;
+  };
+  listRows: () => Promise<NewsroomArticleRow[]>;
+  loadArticle: (id: string) => Promise<EditableArticle>;
+};
+
+export function slugify(value: string): string {
+  return value
+    .normalize("NFKD")
+    .replace(/[^\x00-\x7F]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+export function suggestSlug(frontMatterYaml: string): string {
+  for (const line of frontMatterYaml.split("\n")) {
+    const match = /^title\s*:\s*(.*)$/.exec(line);
+    if (!match) continue;
+    let value = match[1].trim();
+    if (value.length >= 2 && (value[0] === '"' || value[0] === "'") && value.endsWith(value[0])) {
+      value = value.slice(1, -1);
+    }
+    return slugify(value);
+  }
+  return "";
+}
+
+export function errorLine(errors: ContentActionError[]): number | null {
+  for (const error of errors) {
+    if (typeof error.line === "number") return error.line;
+  }
+  return null;
+}
+
+export function sourceLineOffset(frontMatterYaml: string | null): number {
+  const yamlText = (frontMatterYaml ?? "").replace(/^\n+|\n+$/g, "");
+  if (!yamlText.trim()) return 0;
+  return yamlText.split("\n").length + 2;
+}
+
+export type ErrorLocation = { field: "frontMatterYaml" | "bodyMarkus"; line: number | null };
+
+export function locateError(error: ContentActionError, frontMatterYaml: string | null): ErrorLocation {
+  if (error.code === "front-matter") return { field: "frontMatterYaml", line: null };
+  if (error.line === null) return { field: "bodyMarkus", line: null };
+  const bodyLine = error.line - sourceLineOffset(frontMatterYaml);
+  if (bodyLine >= 1) return { field: "bodyMarkus", line: bodyLine };
+  return { field: "frontMatterYaml", line: Math.max(error.line - 1, 1) };
+}
+
+export function emptyArticle(): NewsroomArticleEditorState {
+  return {
+    id: null,
+    type: "article",
+    section: "",
+    slug: "",
+    frontMatterYaml: "title: \n",
+    bodyMarkus: "",
+    contentHash: null,
+    status: "draft",
+    versionNumber: null,
+    dirty: false,
+  };
+}
+
+function parseJsonObject(value: unknown): Record<string, unknown> {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as Record<string, unknown>) : {};
+    } catch {
+      return {};
+    }
+  }
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+export function hasPendingChanges(item: ArticleItemSummary, published: PublishedItemSummary | null): boolean {
+  if (!published) return false;
+  return item.contentHash !== parseJsonObject(published.metadata).sourceContentHash;
+}
+
+export function articleStatusLabel(item: ArticleItemSummary, published: PublishedItemSummary | null): string {
+  if (item.status !== "published") return "Draft";
+  return hasPendingChanges(item, published) ? "Published, unpublished changes" : "Published";
+}
+
+function rowFromItem(item: ArticleItemSummary, published: PublishedItemSummary | null): NewsroomArticleRow {
+  const status: ArticleStatus = item.status === "published" ? "published" : "draft";
+  return {
+    id: item.id,
+    type: item.type,
+    slug: item.slug,
+    section: item.section ?? null,
+    title: item.title || item.slug,
+    status,
+    pending: status === "published" && hasPendingChanges(item, published),
+    updatedAt: item.updatedAt ?? "",
+  };
+}
+
+export function sortRowsByUpdatedAtDescending(rows: NewsroomArticleRow[]): NewsroomArticleRow[] {
+  return [...rows].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+
+export function rowStatusLabel(row: NewsroomArticleRow): string {
+  if (row.status === "draft") return "Draft";
+  return row.pending ? "Published, unpublished changes" : "Published";
+}
+
+type ListPage<T> = { data?: (T | null)[] | null; nextToken?: string | null; errors?: { message?: string }[] | null };
+type ListOptions = { authMode: "userPool"; nextToken?: string | null; limit?: number };
+
+export type ArticlesDataClient = {
+  models: {
+    Item: {
+      listItemsByTypeStatusAndPublishedAt: (
+        input: { typeStatus: string },
+        options: ListOptions,
+      ) => Promise<ListPage<ArticleItemSummary>>;
+      get: (
+        input: { id: string },
+        options: { authMode: "userPool" },
+      ) => Promise<{ data?: Record<string, unknown> | null; errors?: { message?: string }[] | null }>;
+    };
+    PublishedItem: {
+      listPublishedItemsByTypeStatusAndPublishedAt: (
+        input: { typeStatus: string },
+        options: ListOptions,
+      ) => Promise<ListPage<PublishedItemSummary>>;
+    };
+  };
+};
+
+const NEWSROOM_ARTICLE_TYPE_STATUSES = ["article#draft", "article#published", "page#draft", "page#published"];
+const NEWSROOM_PUBLISHED_TYPE_STATUSES = ["article#published", "page#published"];
+
+async function collectPages<T>(
+  fetchPage: (options: ListOptions) => Promise<ListPage<T>>,
+): Promise<T[]> {
+  const collected: T[] = [];
+  let nextToken: string | null | undefined = null;
+  do {
+    const page: ListPage<T> = await fetchPage({ authMode: "userPool", nextToken, limit: 500 });
+    if (page.errors && page.errors.length > 0) {
+      throw new Error(page.errors.map((error) => error.message ?? "GraphQL error").join("; "));
+    }
+    for (const row of page.data ?? []) {
+      if (row) collected.push(row);
+    }
+    nextToken = page.nextToken;
+  } while (nextToken);
+  return collected;
+}
+
+export async function loadArticleRows(client: ArticlesDataClient): Promise<NewsroomArticleRow[]> {
+  const itemGroups = await Promise.all(
+    NEWSROOM_ARTICLE_TYPE_STATUSES.map((typeStatus) =>
+      collectPages((options) => client.models.Item.listItemsByTypeStatusAndPublishedAt({ typeStatus }, options)),
+    ),
+  );
+  const publishedGroups = await Promise.all(
+    NEWSROOM_PUBLISHED_TYPE_STATUSES.map((typeStatus) =>
+      collectPages((options) =>
+        client.models.PublishedItem.listPublishedItemsByTypeStatusAndPublishedAt({ typeStatus }, options),
+      ),
+    ),
+  );
+  const publishedByLineage = new Map<string, PublishedItemSummary>();
+  for (const published of publishedGroups.flat()) {
+    const lineage = published.itemLineageId ?? published.sourceItemId;
+    if (lineage) publishedByLineage.set(lineage, published);
+  }
+  const rows = itemGroups
+    .flat()
+    .map((item) => rowFromItem(item, publishedByLineage.get(item.lineageId ?? item.id) ?? null));
+  return sortRowsByUpdatedAtDescending(rows);
+}
+
+export async function loadEditableArticle(client: ArticlesDataClient, id: string): Promise<EditableArticle> {
+  const response = await client.models.Item.get({ id }, { authMode: "userPool" });
+  if (response.errors && response.errors.length > 0) {
+    throw new Error(response.errors.map((error) => error.message ?? "GraphQL error").join("; "));
+  }
+  const record = response.data;
+  if (!record) throw new Error("That article was not found.");
+  const metadata = parseJsonObject(record.metadata);
+  const status: ArticleStatus = record.status === "published" ? "published" : "draft";
+  return {
+    id: String(record.id),
+    type: String(record.type),
+    section: typeof record.section === "string" ? record.section : null,
+    slug: String(record.slug),
+    frontMatterYaml: typeof metadata.frontMatterYaml === "string" ? metadata.frontMatterYaml : "",
+    bodyMarkus: typeof record.bodyMarkus === "string" ? record.bodyMarkus : "",
+    contentHash: typeof record.contentHash === "string" ? record.contentHash : null,
+    status,
+    versionNumber: typeof record.versionNumber === "number" ? record.versionNumber : null,
+    aliases: Array.isArray(record.aliases) ? record.aliases.map(String) : [],
+    everPublished: status === "published",
+  };
+}
+
+export function createLiveArticlesBackend(): ArticlesBackend {
+  let client: ArticlesDataClient | null = null;
+  const dataClient = () => {
+    if (!client) client = generateClient<Schema>() as unknown as ArticlesDataClient;
+    return client;
+  };
+  return {
+    actions: { deriveMarkus, saveItemDraft, publishItem, unpublishItem },
+    listRows: () => loadArticleRows(dataClient()),
+    loadArticle: (id) => loadEditableArticle(dataClient(), id),
+  };
+}
+
+let liveBackend: ArticlesBackend | null = null;
+let demoBackend: ArticlesBackend | null = null;
+
+export function resolveArticlesBackend(demo: boolean): ArticlesBackend {
+  if (demo) {
+    demoBackend ??= createDemoArticlesBackend();
+    return demoBackend;
+  }
+  liveBackend ??= createLiveArticlesBackend();
+  return liveBackend;
+}
+
+export function stagingPreviewUrl(
+  stagingBaseUrl: string | undefined,
+  type: string,
+  slug: string,
+  staticSite: boolean,
+): string | null {
+  if (!stagingBaseUrl || !slug || type !== "article") return null;
+  const base = stagingBaseUrl.replace(/\/+$/, "");
+  return staticSite ? `${base}/articles/${slug}.html` : `${base}/articles/${slug}`;
+}
+
+export function uniqueSections(rows: NewsroomArticleRow[]): string[] {
+  const sections = new Set<string>();
+  for (const row of rows) {
+    if (row.section) sections.add(row.section);
+  }
+  return [...sections].sort();
+}

package/lib/newsroom-assignments.ts

@@ -0,0 +1,173 @@
+import type { AssignmentRecord, NewsroomSummaryRecord } from "./category-repository";
+
+export type AssignmentStatusFilter = "all" | "open" | "claimed" | "completed" | "canceled";
+
+export type AssignmentAction = "claim" | "release" | "complete" | "cancel" | "reopen" | "retry";
+
+export type AssignmentTypeOption = {
+  key: string;
+  label: string;
+  count: number;
+};
+
+export type AssignmentMetrics = {
+  total: number;
+  open: number;
+  claimed: number;
+  completed: number;
+  canceled: number;
+};
+
+export function assignmentTypeKeyForFilter(assignment: AssignmentRecord): string {
+  return assignment.assignmentTypeKey?.trim() || "unknown";
+}
+
+export function formatAssignmentTypeLabel(typeKey: string | null | undefined): string {
+  const key = typeKey?.trim();
+  if (!key) return "Uncategorized";
+  if (key === "analysis.reindex") return "Analysis re-index";
+  if (key === "newsroom.research" || key === "research") return "Research";
+  if (key === "curation.reference-intake") return "Reference intake";
+  if (key === "reporting.edition-candidate") return "Reporting candidate";
+  return key
+    .split(/[.:_-]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+export function getAssignmentTypeOptions(
+  assignments: AssignmentRecord[],
+  summary?: NewsroomSummaryRecord | null,
+): AssignmentTypeOption[] {
+  const summaryCounts = summary?.facets?.assignments?.byType ?? summary?.assignmentTypeCounts;
+  const countByType = summaryCounts && Object.keys(summaryCounts).length
+    ? new Map(Object.entries(summaryCounts))
+    : new Map<string, number>();
+  if (!countByType.size) {
+    for (const assignment of assignments) {
+      const typeKey = assignmentTypeKeyForFilter(assignment);
+      countByType.set(typeKey, (countByType.get(typeKey) ?? 0) + 1);
+    }
+  }
+  return Array.from(countByType.entries())
+    .map(([key, count]) => ({
+      key,
+      label: formatAssignmentTypeLabel(key),
+      count,
+    }))
+    .sort((left, right) => {
+      const countDiff = right.count - left.count;
+      if (countDiff !== 0) return countDiff;
+      return left.label.localeCompare(right.label);
+    });
+}
+
+export function getAssignmentMetrics(
+  assignments: AssignmentRecord[],
+  summary?: NewsroomSummaryRecord | null,
+  typeFilter?: string,
+): AssignmentMetrics {
+  const statusCounts = typeFilter
+    ? summary?.facets?.assignments?.statusByType?.[typeFilter]
+    : summary?.facets?.assignments?.byStatus ?? summary?.assignmentStatusCounts;
+  if (statusCounts && Object.keys(statusCounts).length) {
+    return {
+      total: Object.values(statusCounts).reduce((sum, count) => sum + count, 0),
+      open: statusCounts.open ?? 0,
+      claimed: statusCounts.claimed ?? 0,
+      completed: statusCounts.completed ?? 0,
+      canceled: statusCounts.canceled ?? 0,
+    };
+  }
+  return {
+    total: assignments.length,
+    open: assignments.filter((assignment) => assignment.status === "open").length,
+    claimed: assignments.filter((assignment) => assignment.status === "claimed").length,
+    completed: assignments.filter((assignment) => assignment.status === "completed").length,
+    canceled: assignments.filter((assignment) => assignment.status === "canceled").length,
+  };
+}
+
+function assignmentStatusRank(status: string): number {
+  if (status === "open") return 0;
+  if (status === "claimed") return 1;
+  if (status === "completed") return 6;
+  if (status === "canceled") return 8;
+  return 5;
+}
+
+export function compareAssignments(left: AssignmentRecord, right: AssignmentRecord): number {
+  const leftStatus = assignmentStatusRank(left.status);
+  const rightStatus = assignmentStatusRank(right.status);
+  if (leftStatus !== rightStatus) return leftStatus - rightStatus;
+  const priorityDiff = (left.priority ?? 999999) - (right.priority ?? 999999);
+  if (priorityDiff !== 0) return priorityDiff;
+  return left.createdAt.localeCompare(right.createdAt);
+}
+
+export function countAssignmentsByStatus(assignments: AssignmentRecord[]): Record<string, number> {
+  const counts: Record<string, number> = {};
+  for (const assignment of assignments) {
+    const status = assignment.status?.trim().toLowerCase() || "unknown";
+    counts[status] = (counts[status] ?? 0) + 1;
+  }
+  return counts;
+}
+
+export function filterAssignmentsByStatus(
+  assignments: AssignmentRecord[],
+  statusFilter: AssignmentStatusFilter,
+): AssignmentRecord[] {
+  const sorted = [...assignments].sort(compareAssignments);
+  if (statusFilter === "all") return sorted;
+  return sorted.filter((assignment) => assignment.status === statusFilter);
+}
+
+export function formatAssignmentListDate(assignment: AssignmentRecord): string {
+  const value = assignment.updatedAt ?? assignment.createdAt ?? "";
+  if (!value) return "Undated";
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) return value;
+  return new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    timeZone: "UTC",
+  }).format(new Date(timestamp));
+}
+
+export function assignmentStatusLabel(status: string): string {
+  const normalized = status?.trim().toLowerCase() ?? "";
+  if (normalized === "open") return "Open";
+  if (normalized === "claimed") return "Claimed";
+  if (normalized === "completed") return "Completed";
+  if (normalized === "canceled") return "Canceled";
+  return status || "Unknown";
+}
+
+export function assignmentStatusBadgeVariant(
+  status: string,
+): "default" | "secondary" | "outline" | "muted" {
+  const normalized = status?.trim().toLowerCase() ?? "";
+  if (normalized === "open") return "default";
+  if (normalized === "claimed") return "secondary";
+  if (normalized === "completed") return "outline";
+  if (normalized === "canceled") return "outline";
+  return "muted";
+}
+
+export function assignmentListSubtitle(assignment: AssignmentRecord): string {
+  const typeLabel = formatAssignmentTypeLabel(assignment.assignmentTypeKey);
+  const section = assignment.sectionKey?.trim() || assignment.sectionId?.trim();
+  if (section) return `${typeLabel} · ${section}`;
+  return typeLabel;
+}
+
+export function selectedAssignmentById(
+  assignments: AssignmentRecord[],
+  assignmentId: string | null | undefined,
+): AssignmentRecord | null {
+  if (!assignmentId) return null;
+  return assignments.find((assignment) => assignment.id === assignmentId) ?? null;
+}

package/lib/newsroom-base-path.ts

@@ -0,0 +1,48 @@
+import { SITE_BRAND } from "./site-brand";
+
+const DEFAULT_NEWSROOM_BASE_PATH = "/newsroom";
+
+/** Internal Next.js route prefix (always `/newsroom/...`). */
+export function getInternalNewsroomBasePath(): string {
+  return DEFAULT_NEWSROOM_BASE_PATH;
+}
+
+/** Public browser path prefix (`""` on a CMS-only newsroom subdomain). */
+export function getPublicNewsroomBasePath(): string {
+  return SITE_BRAND.newsroomBasePath ?? DEFAULT_NEWSROOM_BASE_PATH;
+}
+
+export function usesNewsroomRootPaths(): boolean {
+  return getPublicNewsroomBasePath() === "";
+}
+
+export function toPublicNewsroomPath(internalPath: string): string {
+  const publicBase = getPublicNewsroomBasePath();
+  if (publicBase !== "") return internalPath;
+  if (internalPath === "/newsroom" || internalPath === "/newsroom/") return "/";
+  if (internalPath.startsWith("/newsroom/")) {
+    return internalPath.slice("/newsroom".length) || "/";
+  }
+  return internalPath;
+}
+
+export function toInternalNewsroomPath(publicPath: string): string {
+  const publicBase = getPublicNewsroomBasePath();
+  const normalized = publicPath.startsWith("/") ? publicPath : `/${publicPath}`;
+  if (publicBase !== "") {
+    if (normalized === publicBase || normalized === `${publicBase}/`) return "/newsroom";
+    if (normalized.startsWith(`${publicBase}/`)) return normalized;
+    if (normalized.startsWith("/newsroom")) return normalized;
+    return `/newsroom${normalized === "/" ? "" : normalized}`;
+  }
+  if (normalized === "/" || normalized === "") return "/newsroom";
+  if (normalized.startsWith("/newsroom")) return normalized;
+  return `/newsroom${normalized}`;
+}
+
+export function newsroomHref(...segments: string[]): string {
+  const suffix = segments.filter(Boolean).join("/");
+  const publicBase = getPublicNewsroomBasePath();
+  if (!suffix) return publicBase || "/";
+  return publicBase ? `${publicBase}/${suffix}` : `/${suffix}`;
+}

package/lib/newsroom-card-layout.ts

@@ -0,0 +1,102 @@
+export type NewsroomCardSpan = "1x1" | "2x1" | "1x2" | "2x2" | "3x1" | "3x2";
+
+export type NewsroomCardTemplateRole = "lead" | "priority" | "secondary" | "tall" | "wide" | "wideFeature" | "standard";
+
+type NewsroomCardTemplateInput = {
+  mode: "desk" | "overview";
+  index: number;
+  bodyLength?: number;
+  isUrgent?: boolean;
+  qualityRating?: number | null;
+  sectionKey?: "assignments" | "messages" | "references" | string;
+  title?: string | null;
+  updatedAt?: string | null;
+};
+
+type NewsroomCardTemplate = {
+  role: NewsroomCardTemplateRole;
+  span: NewsroomCardSpan;
+};
+
+export function resolveNewsroomCardTemplate({
+  bodyLength = 0,
+  index,
+  isUrgent = false,
+  mode,
+  qualityRating,
+  sectionKey,
+  title,
+}: NewsroomCardTemplateInput): NewsroomCardTemplate {
+  if (mode === "overview") {
+    if (index === 0) return { role: "lead", span: "2x2" };
+    if (index === 3) return { role: "secondary", span: "2x1" };
+    return { role: "standard", span: "1x1" };
+  }
+  if (sectionKey === "references") {
+    return resolveReferenceDeskTemplate({
+      bodyLength,
+      index,
+      isUrgent,
+      qualityRating,
+      title: title ?? "",
+    });
+  }
+  if (index === 0 || isUrgent && index < 3) return { role: "priority", span: "2x1" };
+  if (bodyLength > 180 || index > 0 && index % 7 === 0) return { role: "tall", span: "1x2" };
+  if (index > 0 && index % 11 === 0) return { role: "secondary", span: "2x1" };
+  return { role: "standard", span: "1x1" };
+}
+
+function resolveReferenceDeskTemplate({
+  bodyLength,
+  index,
+  isUrgent,
+  qualityRating,
+  title,
+}: {
+  bodyLength: number;
+  index: number;
+  isUrgent: boolean;
+  qualityRating?: number | null;
+  title: string;
+}): NewsroomCardTemplate {
+  if (isLowQualityRating(qualityRating)) return { role: "standard", span: "1x1" };
+
+  const pressure = headlinePressure(title);
+  const bandSlot = index % 12;
+  const isBandLead = bandSlot === 0;
+  const isBandSecondary = bandSlot === 4 || bandSlot === 8;
+
+  if (pressure === "severe") {
+    return isBandLead
+      ? { role: "wideFeature", span: "3x2" }
+      : { role: "wide", span: "3x1" };
+  }
+  if (pressure === "high") {
+    return isBandLead || isBandSecondary
+      ? { role: "wide", span: "3x1" }
+      : { role: "secondary", span: "2x1" };
+  }
+  if (pressure === "medium" && (bandSlot === 1 || bandSlot === 5 || bandSlot === 9)) {
+    return { role: "secondary", span: "2x1" };
+  }
+  if (bodyLength > 340 && bandSlot === 7) return { role: "tall", span: "2x2" };
+  if (bodyLength > 220 && (bandSlot === 2 || bandSlot === 7 || bandSlot === 10)) return { role: "tall", span: "1x2" };
+  if (index === 0 || isUrgent && index < 3) return { role: "priority", span: "2x1" };
+  if (index > 0 && index % 11 === 0) return { role: "secondary", span: "2x1" };
+  return { role: "standard", span: "1x1" };
+}
+
+function headlinePressure(title: string): "low" | "medium" | "high" | "severe" {
+  const words = title.trim().split(/\s+/).filter(Boolean);
+  const characterCount = words.join(" ").length;
+  const longestWord = words.reduce((max, word) => Math.max(max, word.length), 0);
+  if (characterCount >= 96 || longestWord >= 24) return "severe";
+  if (characterCount >= 72 || longestWord >= 18) return "high";
+  if (characterCount >= 52 || longestWord >= 14) return "medium";
+  return "low";
+}
+
+function isLowQualityRating(value: number | null | undefined): boolean {
+  return typeof value === "number" && Number.isFinite(value) && value < 3;
+}