@anthusai/papyrus 1.2.0 → 1.4.0-next.1

package/lib/newsroom-board.ts

@@ -1,14 +1,15 @@
 import type { KanbanConfig, KanbanIssue } from "@kanbus/ui";
-import type { AssignmentRecord, ReferenceRecord } from "./category-repository";
+import type { AssignmentRecord } from "./category-repository";
 import {
-  CONTENT_ITEM_STAGES,
+  contentItemStageKeys,
   contentItemStageLabel,
   latestVersionPerContentItem,
   type ContentItemVersionRecord,
 } from "./content-item-lifecycle";
-import { getContentItemName } from "./site-brand";
+import { assignmentStatusLabel } from "./newsroom-assignments";
+import { getContentItemName, getContentItemStageDefinitions } from "./site-brand";
 
-export type NativeBoardKind = "contentItem" | "reference" | "assignment";
+export type NativeBoardKind = "contentItem" | "assignment";
 export interface NativeBoardIssue extends KanbanIssue {
   kind: NativeBoardKind;
   nativeId: string;
@@ -20,18 +21,14 @@ export function contentItemBoardType(): string {
   return getContentItemName().singular.toLowerCase();
 }
 
-function boardTypeForKind(kind: NativeBoardKind): string {
-  return kind === "contentItem" ? contentItemBoardType() : kind;
-}
+export const ASSIGNMENT_BOARD_TYPE = "assignment";
+
+const ASSIGNMENT_STATUSES_BEFORE_OTHERS = ["open", "claimed"];
+const ASSIGNMENT_STATUSES_AFTER_OTHERS = ["completed", "canceled"];
 
-/**
- * One card per content item, in the column for its lifecycle stage. Assignments that are work on a content item
- * are counted on that item's card rather than shown as separate cards. References and other work keep their own
- * identity and native status.
- */
-export function projectNewsroomBoard(records: {
-  contentItemVersions?: readonly ContentItemVersionRecord[];
-  references?: readonly ReferenceRecord[];
+/** One card per content item, in the column for its lifecycle stage; its assignments are counted on the card. */
+export function projectContentItemBoard(records: {
+  contentItemVersions: readonly ContentItemVersionRecord[];
   assignments?: readonly AssignmentRecord[];
 }): NativeBoardIssue[] {
   const assignmentCountByContentItem = new Map<string, number>();
@@ -41,62 +38,66 @@ export function projectNewsroomBoard(records: {
     }
   }
   const contentItemType = contentItemBoardType();
-  return [
-    ...latestVersionPerContentItem(records.contentItemVersions ?? []).map(version => {
-      const stage = version.stage ?? "idea";
-      const workCount = assignmentCountByContentItem.get(version.lineageId) ?? 0;
-      return {
-        id: `contentItem:${version.lineageId}`, nativeId: version.lineageId, kind: "contentItem" as const, type: contentItemType,
-        title: version.headline || version.title || version.slug, nativeStatus: stage, status: `${contentItemType}/${stage}`,
-        priority: 2, description: workCount ? `${workCount} assignment${workCount === 1 ? "" : "s"} on this ${contentItemType}.` : undefined,
-        updated_at: version.updatedAt ?? undefined, href: `/newsroom/articles/${encodeURIComponent(version.id)}`,
-      };
-    }),
-    ...(records.references ?? []).filter(row => !row.versionState || row.versionState === "current").map(row => ({
-      id: `reference:${row.id}`, nativeId: row.id, kind: "reference" as const, type: "reference",
-      title: row.title || row.externalItemId || row.id,
-      nativeStatus: row.curationStatus || "pending", status: `reference/${row.curationStatus || "pending"}`,
-      priority: 2, description: row.curationStatusReason || undefined,
-      updated_at: row.updatedAt || row.importedAt || undefined,
-      href: `/newsroom/references/${encodeURIComponent(row.lineageId || row.id)}`,
-    })),
-    ...(records.assignments ?? []).filter(row => !row.itemLineageId).map(row => ({
-      id: `assignment:${row.id}`, nativeId: row.id, kind: "assignment" as const, type: "assignment",
-      title: row.title, nativeStatus: row.status, status: `assignment/${row.status}`,
-      priority: row.priority ?? 2, assignee: row.assigneeId || undefined,
-      description: row.summary || row.brief || undefined,
-      created_at: row.createdAt, updated_at: row.updatedAt,
-      href: `/newsroom/assignments/${encodeURIComponent(row.id)}`,
-    })),
-  ];
+  return latestVersionPerContentItem(records.contentItemVersions).map(version => {
+    const stage = version.stage ?? "idea";
+    const workCount = assignmentCountByContentItem.get(version.lineageId) ?? 0;
+    return {
+      id: `contentItem:${version.lineageId}`, nativeId: version.lineageId, kind: "contentItem" as const, type: contentItemType,
+      title: version.headline || version.title || version.slug, nativeStatus: stage, status: `${contentItemType}/${stage}`,
+      priority: 2, description: workCount ? `${workCount} assignment${workCount === 1 ? "" : "s"} on this ${contentItemType}.` : undefined,
+      updated_at: version.updatedAt ?? undefined, href: `/newsroom/articles/${encodeURIComponent(version.id)}`,
+    };
+  });
 }
 
-export function contentItemColumnOrder(stagesPresentOnBoard: readonly string[]): string[] {
-  const lastStage = CONTENT_ITEM_STAGES[CONTENT_ITEM_STAGES.length - 1];
-  const unrecognizedStages = [...new Set(stagesPresentOnBoard)].filter(stage => !(CONTENT_ITEM_STAGES as readonly string[]).includes(stage));
-  return [...CONTENT_ITEM_STAGES.filter(stage => stage !== lastStage), ...unrecognizedStages, lastStage];
+/** One card per assignment, in the column for its status. */
+export function projectAssignmentBoard(assignments: readonly AssignmentRecord[]): NativeBoardIssue[] {
+  return assignments.map(row => ({
+    id: `assignment:${row.id}`, nativeId: row.id, kind: "assignment" as const, type: ASSIGNMENT_BOARD_TYPE,
+    title: row.title, nativeStatus: row.status, status: `${ASSIGNMENT_BOARD_TYPE}/${row.status}`,
+    priority: row.priority ?? 2, assignee: row.assigneeId || undefined,
+    description: row.summary || row.brief || undefined,
+    created_at: row.createdAt, updated_at: row.updatedAt,
+    href: `/newsroom/assignments/${encodeURIComponent(row.id)}`,
+  }));
 }
 
-/** Content items read left to right through the lifecycle with the final stage last; other record kinds follow it. */
-export function newsroomBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConfig {
-  const contentItemType = contentItemBoardType();
-  const kinds: NativeBoardKind[] = ["contentItem", "reference", "assignment"];
-  const contentItemStatuses = contentItemColumnOrder(issues.filter(issue => issue.kind === "contentItem").map(issue => issue.nativeStatus))
-    .map(stage => ({ key: `${contentItemType}/${stage}`, name: contentItemStageLabel(stage), category: "native" }));
-  const otherStatuses = [...new Set(issues.filter(issue => issue.kind !== "contentItem").map(issue => issue.status))]
-    .map(key => ({ key, name: key.replace("/", " · "), category: "native" }));
-  const statuses = [...contentItemStatuses, ...otherStatuses];
+export function contentItemColumnOrder(
+  stagesPresentOnBoard: readonly string[],
+  stageKeys: readonly string[] = contentItemStageKeys(getContentItemStageDefinitions()),
+): string[] {
+  const lastStage = stageKeys[stageKeys.length - 1];
+  const unrecognizedStages = [...new Set(stagesPresentOnBoard)].filter(stage => !stageKeys.includes(stage));
+  return [...stageKeys.filter(stage => stage !== lastStage), ...unrecognizedStages, lastStage];
+}
+
+export function assignmentColumnOrder(statusesPresentOnBoard: readonly string[]): string[] {
+  const knownStatuses = [...ASSIGNMENT_STATUSES_BEFORE_OTHERS, ...ASSIGNMENT_STATUSES_AFTER_OTHERS];
+  const otherStatuses = [...new Set(statusesPresentOnBoard)].filter(status => !knownStatuses.includes(status));
+  return [...ASSIGNMENT_STATUSES_BEFORE_OTHERS, ...otherStatuses, ...ASSIGNMENT_STATUSES_AFTER_OTHERS];
+}
+
+function boardConfigForType(type: string, columns: readonly { key: string; name: string }[]): KanbanConfig {
+  const statuses = columns.map(column => ({ ...column, category: "native" }));
   return {
-    hierarchy: [], types: kinds.map(boardTypeForKind),
-    statuses,
+    hierarchy: [], types: [type], statuses,
     categories: [{ name: "native" }], priorities: {}, type_colors: {},
-    workflows: Object.fromEntries(kinds.map(kind => {
-      const type = boardTypeForKind(kind);
-      return [type, Object.fromEntries(statuses.filter(status => status.key.startsWith(`${type}/`)).map(status => [status.key, []]))];
-    })),
+    workflows: { [type]: Object.fromEntries(statuses.map(status => [status.key, []])) },
   };
 }
 
+/** Content items read left to right through the lifecycle with the final stage last. */
+export function contentItemBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConfig {
+  const contentItemType = contentItemBoardType();
+  return boardConfigForType(contentItemType, contentItemColumnOrder(issues.map(issue => issue.nativeStatus))
+    .map(stage => ({ key: `${contentItemType}/${stage}`, name: contentItemStageLabel(stage, getContentItemStageDefinitions()) })));
+}
+
+export function assignmentBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConfig {
+  return boardConfigForType(ASSIGNMENT_BOARD_TYPE, assignmentColumnOrder(issues.map(issue => issue.nativeStatus))
+    .map(status => ({ key: `${ASSIGNMENT_BOARD_TYPE}/${status}`, name: assignmentStatusLabel(status) })));
+}
+
 export function canReadNewsroomBoard(phase: string | undefined): boolean {
   return phase === "ready";
 }

package/lib/newsroom-organizer-nav.ts

@@ -8,9 +8,8 @@ export type OrganizerDestination = {
 export const ORGANIZER_NAV_GROUPS: readonly { title: string; items: readonly OrganizerDestination[] }[] = [
   { title: "Editorial work", items: [
     { key: "overview", label: "Overview", description: "See the desk and choose where to begin.", path: "/newsroom", primary: true },
-    { key: "board", label: "Board", description: `Follow ${contentItemPluralLowercase}, sources and assignments across their stages.`, path: "/newsroom/work", primary: true },
-    { key: "articles", label: getContentItemName().plural, description: "Write, revise and prepare copy for publication.", path: "/newsroom/articles" },
-    { key: "assignments", label: "Assignments", description: "Claim work and follow research and reporting progress.", path: "/newsroom/assignments" },
+    { key: "articles", label: getContentItemName().plural, description: `Follow ${contentItemPluralLowercase} across their stages and open one to write or revise it.`, path: "/newsroom/articles", primary: true },
+    { key: "assignments", label: "Assignments", description: "Follow research and reporting work across its statuses and claim it.", path: "/newsroom/assignments" },
     { key: "messages", label: "Messages", description: "Read and reply to newsroom conversations.", path: "/newsroom/messages", primary: true },
     { key: "insights", label: "Insights", description: "Discuss findings and research threads.", path: "/newsroom/insights" },
   ] },
@@ -30,7 +29,7 @@ export const ORGANIZER_NAV_GROUPS: readonly { title: string; items: readonly Org
   ] },
 ];
 const all = ORGANIZER_NAV_GROUPS.flatMap(group => group.items);
-export const ORGANIZER_PRIMARY_NAV = ["overview", "board", "references", "messages"].map(key => all.find(item => item.key === key)!);
+export const ORGANIZER_PRIMARY_NAV = ["overview", "articles", "references", "messages"].map(key => all.find(item => item.key === key)!);
 
 export const ORGANIZER_SETTINGS_DESTINATION = {
   label: "Settings", path: "/newsroom/settings", description: "Theme, motion and interface preferences.",

package/lib/pretext-layout.ts

@@ -9,6 +9,27 @@ import {
 
 export { layoutNextLine, prepareWithSegments, type LayoutCursor, type PreparedTextWithSegments };
 
+const preparedTextCache = new Map<string, PreparedTextWithSegments>();
+let preparedTextCacheMissCount = 0;
+
+export function getPreparedTextCacheMissCount(): number {
+  return preparedTextCacheMissCount;
+}
+
+export function prepareWithSegmentsCached(
+  text: string,
+  font: string,
+  options?: { whiteSpace?: "normal" | "pre-wrap" },
+): PreparedTextWithSegments {
+  const key = `${options?.whiteSpace ?? "normal"}\u0000${font}\u0000${text}`;
+  const cached = preparedTextCache.get(key);
+  if (cached) return cached;
+  preparedTextCacheMissCount += 1;
+  const prepared = prepareWithSegments(text, font, options);
+  preparedTextCache.set(key, prepared);
+  return prepared;
+}
+
 export type TextLine = {
   text: string;
   width: number;
@@ -184,5 +205,6 @@ function clamp(value: number, min: number, max: number): number {
 }
 
 export function clearPretextMeasurementCache(): void {
+  preparedTextCache.clear();
   clearCache();
 }

package/lib/relevance-status.ts

@@ -61,3 +61,76 @@ export const DEMO_CYCLOTRON_STATUS: CyclotronStatus = {
   lastChange: null,
   pending: { decisionsAwaitingReview: 1, staleSince: null },
 };
+
+/**
+ * What the Newsroom assumes until a decision names the cyclotron: the defaults
+ * of the steering config's relevanceCyclotron block (src/papyrus_content/relevance_cyclotron.py).
+ */
+export const DEFAULT_RELEVANCE_CYCLOTRON = { id: "papyrus-relevance", labels: ["include", "exclude"] } as const;
+
+/** The payload kind of a priming request; the sweep lists the cyclotron's payloads and filters on it. */
+export const PRIMING_REQUEST_KIND = "cyclotron-priming-request";
+
+/** The attachment role the sweep writes a request's outcome under. */
+export const PRIMING_OUTCOME_ROLE = "priming_outcome";
+
+/** The KnowledgeRawPayload an editor writes to ask the next sweep to prime the cyclotron with one URL. */
+export function primingRequestPayloadId(cyclotronId: string, requestId: string): string {
+  return `knowledge-raw-payload-cyclotron-priming-request-${safeId(cyclotronId)}-${safeId(requestId)}`;
+}
+
+export type PrimingRequest = {
+  requestId: string;
+  url: string;
+  label: string;
+  explanation: string;
+  requestedBy: string;
+  requestedAt: string;
+};
+
+export type PrimingOutcome =
+  | { state: "applied"; version: number; at: string; itemId?: string }
+  | { state: "failed"; message: string; at: string };
+
+/** A saved request with the sweep's outcome, once there is one. */
+export type PrimingRequestView = { request: PrimingRequest; outcome: PrimingOutcome | null };
+
+export function buildPrimingRequest(
+  input: { url: string; label: string; explanation?: string },
+  requestedBy: string,
+  labels: readonly string[],
+  now: Date = new Date(),
+  requestId: string = `${now.getTime().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+): PrimingRequest {
+  let parsed: URL | null = null;
+  try {
+    parsed = new URL(input.url.trim());
+  } catch {
+    parsed = null;
+  }
+  if (!parsed || parsed.protocol !== "https:") throw new Error("Paste an https URL.");
+  if (!labels.includes(input.label)) throw new Error(`Choose a label: ${labels.join(" or ")}.`);
+  return {
+    requestId,
+    url: parsed.toString(),
+    label: input.label,
+    explanation: (input.explanation ?? "").trim(),
+    requestedBy,
+    requestedAt: now.toISOString(),
+  };
+}
+
+export function isPrimingOutcome(value: unknown): value is PrimingOutcome {
+  if (!value || typeof value !== "object") return false;
+  const outcome = value as Record<string, unknown>;
+  return (outcome.state === "applied" && typeof outcome.version === "number")
+    || (outcome.state === "failed" && typeof outcome.message === "string");
+}
+
+/** In words: waiting for the next sweep, applied as version N, or failed with the reason. */
+export function primingStateText(view: PrimingRequestView): string {
+  if (!view.outcome) return "Waiting for the next sweep";
+  return view.outcome.state === "applied"
+    ? `Applied as version ${view.outcome.version}`
+    : `Failed: ${view.outcome.message}`;
+}

package/lib/site-brand.ts

@@ -1,3 +1,4 @@
+import { isLocalPreviewEnabled } from "./local-preview";
 import type { ComponentType } from "react";
 import type { EditionPresentationFormat } from "./content-types";
 import type { Article, ArticleVideoAsset } from "./articles";
@@ -5,6 +6,7 @@ import type { BlogPageBackgroundProps } from "../components/blog-page-background
 import type { SiteBrandFont } from "./brand-fonts";
 import type { PictogramFigureProps } from "../components/pictogram-figure";
 import papyrusSite from "papyrus-site";
+import { DEFAULT_CONTENT_ITEM_STAGE_DEFINITIONS, type ContentItemStageDefinition } from "./content-item-lifecycle";
 import {
   DEFAULT_THEME_PACK_TOKENS,
   type HostingConfig,
@@ -92,6 +94,8 @@ export type SiteBrand = {
   articleTitleSuffix: string;
   /** Defaults to Story / Stories, the newsroom term. */
   contentItemName?: ContentItemName;
+  /** The lifecycle stages in board order, last one being publication. Defaults to the standard newsroom lifecycle. */
+  contentItemStages?: readonly ContentItemStageDefinition[];
   placeholderByline: string;
   defaultPresentation: EditionPresentationFormat;
   forcedPresentation?: EditionPresentationFormat;
@@ -181,11 +185,17 @@ const REFERENCE_SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
  * The Papyrus reference brand plus whatever the publication registered in its
  * own `papyrus.config.ts` (resolved through the `papyrus-site` alias).
  */
-const SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
+const REGISTERED_SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
   ...REFERENCE_SITE_BRANDS,
   ...Object.fromEntries((papyrusSite.brands ?? []).map((brand) => [brand.id, brand])),
 };
 
+const SITE_BRANDS: Record<SiteBrandId, SiteBrand> = isLocalPreviewEnabled()
+  ? Object.fromEntries(
+      Object.entries(REGISTERED_SITE_BRANDS).map(([id, brand]) => [id, { ...brand, newsroomLayout: "organizer" as const }]),
+    )
+  : REGISTERED_SITE_BRANDS;
+
 export function normalizeSiteBrandId(value: string | undefined | null): SiteBrandId | null {
   if (!value) return null;
   const trimmed = value.trim();
@@ -223,6 +233,10 @@ export function getContentItemName(brand: SiteBrand = SITE_BRAND): ContentItemNa
   return brand.contentItemName ?? DEFAULT_CONTENT_ITEM_NAME;
 }
 
+export function getContentItemStageDefinitions(brand: SiteBrand = SITE_BRAND): readonly ContentItemStageDefinition[] {
+  return brand.contentItemStages?.length ? brand.contentItemStages : DEFAULT_CONTENT_ITEM_STAGE_DEFINITIONS;
+}
+
 /** Root-route config for a brand, defaulting to `{ kind: "reader" }`. */
 export function getRootRoute(brand: SiteBrand = SITE_BRAND): RootRouteConfig {
   return brand.rootRoute ?? { kind: "reader" };

package/lib/text-columns.ts

@@ -0,0 +1,251 @@
+import { type ArticlePublicationItem, getPublicationItemText } from "./publication-items";
+import {
+  type LayoutCursor,
+  layoutTextLines,
+  type PreparedTextWithSegments,
+  prepareWithSegmentsCached,
+  type TextLine,
+  type TextObstacle,
+} from "./pretext-layout";
+import { reserveRhythmRows, type VerticalRhythm } from "./blog-rhythm";
+import {
+  type FurnitureSufficiencyReport,
+  type LayoutConfig,
+  type SolvedChromeBox,
+  type SolvedFurniture,
+} from "./layout-types";
+import { SERIF_TEXT_FONT, clamp, getSpanWidth } from "./layout-config";
+import { rectsOverlap } from "./furniture";
+
+export function layoutTextColumns({
+  item,
+  cursor,
+  columnCount,
+  textHeight,
+  maximumTextHeightByColumn = [],
+  localConfig,
+  furniture,
+  chromeBoxes = [],
+  furnitureObstacleOffsetY = 0,
+  furnitureObstacleMarginBottom = 0,
+  minimumLineStartYByColumn = [],
+}: {
+  item: ArticlePublicationItem;
+  cursor: LayoutCursor;
+  columnCount: number;
+  textHeight: number;
+  maximumTextHeightByColumn?: number[];
+  localConfig: LayoutConfig;
+  furniture: SolvedFurniture[];
+  chromeBoxes?: SolvedChromeBox[];
+  furnitureObstacleOffsetY?: number;
+  furnitureObstacleMarginBottom?: number;
+  minimumLineStartYByColumn?: number[];
+}): { columns: TextLine[][]; cursor: LayoutCursor; hasMore: boolean } {
+  const columns: TextLine[][] = [];
+  const preparedText = getPrepared(item, localConfig.bodyFont);
+  const columnWidth = getSpanWidth(localConfig, 1);
+  let current = { ...cursor };
+  let hasMore = true;
+
+  for (let columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
+    const result = layoutTextLines({
+      prepared: preparedText,
+      cursor: current,
+      maxHeight: maximumTextHeightByColumn[columnIndex] ?? textHeight,
+      maxWidth: columnWidth,
+      lineHeight: localConfig.lineHeight,
+      linePaintHeight: localConfig.linePaintHeight,
+      fontSize: localConfig.bodyFontSize,
+      fontFamily: SERIF_TEXT_FONT,
+      obstacles: getColumnTextObstacles(
+        furniture,
+        columnIndex,
+        chromeBoxes,
+        furnitureObstacleOffsetY,
+        furnitureObstacleMarginBottom,
+        minimumLineStartYByColumn[columnIndex] ?? 0,
+      ),
+    });
+    columns.push(result.lines);
+    current = result.cursor;
+    hasMore = result.hasMore;
+    if (!hasMore) {
+      while (columns.length < columnCount) columns.push([]);
+      break;
+    }
+  }
+
+  return { columns, cursor: current, hasMore };
+}
+
+export function getPrepared(article: ArticlePublicationItem, font: string): PreparedTextWithSegments {
+  return prepareWithSegmentsCached(getPublicationItemText(article), font, { whiteSpace: "pre-wrap" });
+}
+
+export function getLineLimitHeight(maxLines: number, lineHeight: number, linePaintHeight: number, rhythm: VerticalRhythm): number {
+  if (maxLines <= 0) return 0;
+  return reserveRhythmRows((maxLines - 1) * lineHeight + linePaintHeight, rhythm);
+}
+
+function getColumnTextObstacles(
+  furniture: SolvedFurniture[],
+  columnIndex: number,
+  chromeBoxes: SolvedChromeBox[] = [],
+  furnitureOffsetY = 0,
+  furnitureMarginBottom = 0,
+  minimumLineStartY = 0,
+): TextObstacle[] {
+  const topObstacle: TextObstacle[] = minimumLineStartY > 0
+    ? [{ x: 0, y: 0, width: Number.POSITIVE_INFINITY, height: minimumLineStartY }]
+    : [];
+  const furnitureObstacles = furniture
+    .filter((item) => item.wrapsText && columnIndex >= item.columnStart && columnIndex < item.columnStart + item.columnSpan)
+    .map((item) => ({
+      x: 0,
+      y: item.y + furnitureOffsetY,
+      width: Number.POSITIVE_INFINITY,
+      height: item.height + getFurnitureObstacleMarginBottom(item, furnitureMarginBottom),
+    }));
+  const imageClearanceObstacles = furniture
+    .filter((item) => (
+      item.kind === "image" &&
+      item.wrapsText &&
+      furnitureMarginBottom > 0 &&
+      columnIndex >= item.columnStart &&
+      columnIndex < item.columnStart + item.columnSpan
+    ))
+    .map((item) => ({
+      x: 0,
+      y: item.y + furnitureOffsetY + item.height,
+      width: Number.POSITIVE_INFINITY,
+      height: furnitureMarginBottom,
+    }));
+  const chromeObstacles = chromeBoxes
+    .filter((box) => columnIndex >= box.columnStart && columnIndex < box.columnStart + box.columnSpan)
+    .map((box) => ({
+      x: 0,
+      y: box.y,
+      width: Number.POSITIVE_INFINITY,
+      height: box.height,
+    }));
+  return [...topObstacle, ...furnitureObstacles, ...imageClearanceObstacles, ...chromeObstacles];
+}
+
+function getFurnitureObstacleMarginBottom(item: SolvedFurniture, marginBottom: number): number {
+  return item.kind === "image" || item.kind === "pullQuote" ? marginBottom : 0;
+}
+
+export function getColumnWhitespace(columns: TextLine[][], textHeight: number, furniture: SolvedFurniture[]): number {
+  return columns.reduce(
+    (total, column, columnIndex) =>
+      total + Math.max(0, textHeight - getLinesHeight(column) - getColumnObstacleHeight(furniture, columnIndex, textHeight)),
+    0,
+  );
+}
+
+export function getFurnitureSufficiencyReport({
+  columns,
+  textHeight,
+  furniture,
+  hasMore,
+  config,
+}: {
+  columns: TextLine[][];
+  textHeight: number;
+  furniture: SolvedFurniture[];
+  hasMore: boolean;
+  config: LayoutConfig;
+}): FurnitureSufficiencyReport {
+  const visibleRows = columns.reduce((total, column) => total + column.length, 0);
+  const furnitureRows = furniture.reduce(
+    (total, item) => total + getFurnitureRowBurden(item, config.rhythm.rowHeight),
+    0,
+  );
+  const accepted = (reason?: string): FurnitureSufficiencyReport => ({
+    accepted: !reason,
+    reason,
+    visibleRows,
+    furnitureRows,
+  });
+
+  if (furniture.length === 0 || furnitureRows === 0) return accepted();
+  const overlapReason = getFurnitureOverlapReason(furniture);
+  if (overlapReason) return accepted(overlapReason);
+  const minimumReadableRows = columns.length * (furniture.some((item) => item.kind === "pullQuote") ? 6 : 3);
+  if (visibleRows * 4 < furnitureRows) {
+    return accepted("visible-copy-far-below-furniture-burden");
+  }
+  if (visibleRows < furnitureRows && visibleRows < minimumReadableRows) {
+    return accepted("visible-copy-below-furniture-burden");
+  }
+
+  const finalTextColumnIndex = columns.reduce((lastIndex, column, columnIndex) => (
+    column.length > 0 ? columnIndex : lastIndex
+  ), -1);
+  const exhausted = !hasMore;
+  for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
+    const visibleColumnRows = columns[columnIndex].length;
+    const obstacleRows = Math.ceil(getColumnObstacleHeight(furniture, columnIndex, textHeight) / config.rhythm.rowHeight);
+    const availableRows = Math.floor(textHeight / config.rhythm.rowHeight) - obstacleRows;
+    const hasSubstantialFurniture = obstacleRows >= 6;
+    const isAfterExhaustedText = exhausted && columnIndex > finalTextColumnIndex;
+    if (!hasSubstantialFurniture && !isAfterExhaustedText && availableRows >= 3 && visibleColumnRows < 3) {
+      return accepted("open-column-below-minimum-copy");
+    }
+    if (!hasSubstantialFurniture && visibleColumnRows === 1 && columnIndex < finalTextColumnIndex) {
+      return accepted("non-final-column-single-copy-row");
+    }
+  }
+
+  return accepted();
+}
+
+function getFurnitureRowBurden(item: SolvedFurniture, rowHeight: number): number {
+  if (item.kind !== "image" && item.kind !== "pullQuote") return 0;
+  return Math.ceil(item.height / rowHeight) * item.columnSpan;
+}
+
+function getFurnitureOverlapReason(furniture: SolvedFurniture[]): string | undefined {
+  for (let firstIndex = 0; firstIndex < furniture.length; firstIndex += 1) {
+    for (let secondIndex = firstIndex + 1; secondIndex < furniture.length; secondIndex += 1) {
+      if (rectsOverlap(furniture[firstIndex], furniture[secondIndex])) return "furniture-overlap";
+    }
+  }
+  return undefined;
+}
+
+function getColumnObstacleHeight(furniture: SolvedFurniture[], columnIndex: number, textHeight: number): number {
+  const intervals = furniture
+    .filter((item) => item.wrapsText && columnIndex >= item.columnStart && columnIndex < item.columnStart + item.columnSpan)
+    .map((item) => ({
+      start: clamp(item.y, 0, textHeight),
+      end: clamp(item.y + item.height, 0, textHeight),
+    }))
+    .filter((interval) => interval.end > interval.start)
+    .sort((a, b) => a.start - b.start);
+
+  const merged: Array<{ start: number; end: number }> = [];
+  for (const interval of intervals) {
+    const previous = merged[merged.length - 1];
+    if (previous && interval.start <= previous.end) previous.end = Math.max(previous.end, interval.end);
+    else merged.push({ ...interval });
+  }
+  return merged.reduce((total, interval) => total + interval.end - interval.start, 0);
+}
+
+export function getDeadColumnCount(columns: TextLine[][], textHeight: number, furniture: SolvedFurniture[]): number {
+  return columns.reduce((count, column, columnIndex) => {
+    if (column.length > 0) return count;
+    const obstacleHeight = getColumnObstacleHeight(furniture, columnIndex, textHeight);
+    return obstacleHeight >= Math.min(96, textHeight * 0.18) ? count : count + 1;
+  }, 0);
+}
+
+export function getLinesHeight(lines: TextLine[]): number {
+  return lines.length === 0 ? 0 : Math.max(...lines.map((line) => line.y + line.paintHeight));
+}
+
+export function getFurnitureBottom(furniture: SolvedFurniture[]): number {
+  return furniture.reduce((bottom, item) => Math.max(bottom, item.y + item.height), 0);
+}