@anthusai/papyrus 2.0.3 → 3.1.0

package/lib/editorial-checks.ts

@@ -0,0 +1,178 @@
+/**
+ * Editorial checks: the Limatus result shapes the newsroom uses, and pure helpers
+ * over them. Limatus counts offsets in UTF-16 code units, which is exactly how
+ * JavaScript indexes strings, so spans apply to the body text as they are.
+ */
+import { pluginSettings, type PluginOutputs } from "./plugin-settings";
+
+export const EDITORIAL_CHECKS_PLUGIN = "editorial-checks";
+
+export type Span = { start: number; end: number };
+export type Severity = "info" | "warn" | "error";
+
+export type EditorialFinding = {
+  id: string;
+  policyId: string;
+  policyVersion: number;
+  detectorId: string;
+  lane: "rules" | "classifier";
+  severity: Severity;
+  status: "violation" | "review";
+  segmentId: string;
+  span: Span;
+  excerpt: string;
+  /** The excerpt as a reader sees it (inline markup removed). */
+  excerptText?: string;
+  message: string;
+  probability?: number;
+  rawProbability?: number;
+  replacement?: string;
+};
+
+export type EditorialSegment = {
+  id: string;
+  kind: "document" | "paragraph" | "sentence";
+  block?: "paragraph" | "heading" | "listItem";
+  parentId?: string;
+  start: number;
+  end: number;
+  textHash: string;
+  /** Plain prose of a paragraph or sentence segment. */
+  text?: string;
+};
+
+export type LaneStatus = { status: "ran" | "disabled" | "unavailable" | "failed" | "partial"; reason?: string; detectors?: number };
+
+export type EditorialCheckResult = {
+  schemaVersion: 1;
+  offsetUnit: "utf16";
+  document: { hash: string; length: number };
+  pack: { packId: string; version: string };
+  segments: EditorialSegment[];
+  protected: { kind: string; start: number; end: number }[];
+  findings: EditorialFinding[];
+  coverage: unknown[];
+  lanes: { rules: LaneStatus; classifier: LaneStatus };
+  usage?: Record<string, number>;
+};
+
+export type RewriteOption = {
+  id: string;
+  span: Span;
+  replacement: string;
+  rationale: string;
+  factVerificationRequired: boolean;
+  unresolvedQuestions: string[];
+};
+
+export type RewriteResult = {
+  target: { findingId?: string; span: Span; excerpt: string };
+  model: string;
+  options: RewriteOption[];
+  dropped?: { replacement: string; reason: string }[];
+};
+
+export type FeedbackDecision = "accepted" | "fixed" | "dismissed";
+
+export type EditorialFeedbackInput = {
+  itemId: string;
+  findingId: string;
+  policyId: string;
+  detectorId: string;
+  lane: EditorialFinding["lane"];
+  probability: number | null;
+  decision: FeedbackDecision;
+  reason: string | null;
+  text: string | null;
+};
+
+/** Decisions on an article that has never been saved are kept under this id. */
+export const UNSAVED_ITEM_ID = "unsaved";
+
+const SEVERITY_ORDER: Record<Severity, number> = { error: 0, warn: 1, info: 2 };
+
+export function editorialChecksEnabled(outputs: PluginOutputs | null | undefined): boolean {
+  return pluginSettings(outputs, EDITORIAL_CHECKS_PLUGIN) !== null;
+}
+
+/** Findings worth showing: not dismissed, not covering the whole document, most severe first, then in reading order. */
+export function visibleFindings(findings: EditorialFinding[], dismissed: ReadonlySet<string>): EditorialFinding[] {
+  return findings
+    .filter((finding) => !dismissed.has(finding.id))
+    .sort(
+      (a, b) =>
+        SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] ||
+        a.span.start - b.span.start ||
+        a.policyId.localeCompare(b.policyId),
+    );
+}
+
+/** Findings that can be marked in the text (document-level ones have no excerpt). */
+export function inlineFindings(findings: EditorialFinding[]): EditorialFinding[] {
+  return findings.filter((finding) => finding.excerpt.length > 0 && finding.span.end > finding.span.start);
+}
+
+export type FindingGroup = { policyId: string; severity: Severity; findings: EditorialFinding[] };
+
+export function groupByPolicy(findings: EditorialFinding[]): FindingGroup[] {
+  const groups = new Map<string, FindingGroup>();
+  for (const finding of findings) {
+    const group = groups.get(finding.policyId) ?? { policyId: finding.policyId, severity: finding.severity, findings: [] };
+    group.findings.push(finding);
+    if (SEVERITY_ORDER[finding.severity] < SEVERITY_ORDER[group.severity]) group.severity = finding.severity;
+    groups.set(finding.policyId, group);
+  }
+  return [...groups.values()].sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] || a.policyId.localeCompare(b.policyId));
+}
+
+/** Open findings that should make an editor pause before publishing (never a block). */
+export function publishWarnings(findings: EditorialFinding[], dismissed: ReadonlySet<string>): EditorialFinding[] {
+  return visibleFindings(findings, dismissed).filter((finding) => finding.severity !== "info" && finding.status === "violation");
+}
+
+/** The text of the segment a finding sits in, which becomes a few-shot example for the classifier. */
+export function findingSegmentText(result: EditorialCheckResult, body: string, finding: EditorialFinding): string | null {
+  const segment = result.segments.find((candidate) => candidate.id === finding.segmentId);
+  if (!segment || segment.kind === "document") return null;
+  return body.slice(segment.start, segment.end);
+}
+
+export function feedbackFor(
+  result: EditorialCheckResult,
+  body: string,
+  finding: EditorialFinding,
+  decision: FeedbackDecision,
+  itemId: string | null,
+  reason: string | null = null,
+): EditorialFeedbackInput {
+  return {
+    itemId: itemId ?? UNSAVED_ITEM_ID,
+    findingId: finding.id,
+    policyId: finding.policyId,
+    detectorId: finding.detectorId,
+    lane: finding.lane,
+    probability: finding.rawProbability ?? finding.probability ?? null,
+    decision,
+    reason: reason?.trim() ? reason.trim() : null,
+    text: finding.lane === "classifier" ? findingSegmentText(result, body, finding) : null,
+  };
+}
+
+/** Replace one span of the body; the span must still hold the text it was computed for. */
+export function applyReplacement(body: string, span: Span, expected: string, replacement: string): string | null {
+  if (body.slice(span.start, span.end) !== expected) return null;
+  return body.slice(0, span.start) + replacement + body.slice(span.end);
+}
+
+export function describeProbability(finding: EditorialFinding): string | null {
+  if (finding.probability === undefined) return null;
+  return `${Math.round(finding.probability * 100)}% sure`;
+}
+
+export function laneNotice(result: EditorialCheckResult): string | null {
+  const classifier = result.lanes.classifier;
+  if (classifier.status === "partial") return `Some sentences were not judged: ${classifier.reason ?? "the check ran out of time"}.`;
+  if (classifier.status === "failed") return `The judgment checks failed: ${classifier.reason ?? "unknown error"}. Rule checks still ran.`;
+  if (classifier.status === "unavailable" && (classifier.detectors ?? 0) === 0 && classifier.reason) return `Judgment checks are not configured: ${classifier.reason}.`;
+  return null;
+}

package/lib/editorial-preview.ts

@@ -0,0 +1,228 @@
+/**
+ * Places Limatus findings on the rendered Markus preview.
+ *
+ * Limatus reports spans in the markup; the preview renders an IR tree with no
+ * character offsets. Both sides agree on the words a reader sees, so findings
+ * are placed by text: each Limatus paragraph is matched, in document order, to
+ * the rendered prose block with the same words, and each finding's plain
+ * excerpt is located inside that block. Whitespace is ignored while matching,
+ * because rendering and Limatus collapse it differently (citations, breaks).
+ *
+ * "Rendered text" is defined by `inlineLeaves`, which the preview renderer also
+ * uses, so offsets computed here are offsets the renderer can split on.
+ */
+import type { EditorialCheckResult, EditorialFinding, Severity, Span } from "./editorial-checks";
+import type { MarkusBlock, MarkusDocument, MarkusInline, MarkusNode } from "./markus-ir";
+
+export const CITATION_TOKEN = /PAPYRUSMARKUP\d{5}END/g;
+
+export type InlineLeaf =
+  | { kind: "text"; node: MarkusInline & { type: "text" }; start: number; pieces: { raw: string; start: number; isToken: boolean }[] }
+  | { kind: "code"; node: MarkusInline & { type: "code_span" }; start: number; text: string }
+  | { kind: "break"; start: number; text: string }
+  | { kind: "opaque"; start: number };
+
+/** The reader-visible text of a run of inlines; citation tokens and images take no width. */
+export function inlineLeaves(inlines: MarkusInline[], offset = 0): { leaves: InlineLeaf[]; text: string } {
+  const leaves: InlineLeaf[] = [];
+  let text = "";
+  const walk = (nodes: MarkusInline[]) => {
+    for (const node of nodes) {
+      const start = offset + text.length;
+      switch (node.type) {
+        case "text": {
+          const pieces: { raw: string; start: number; isToken: boolean }[] = [];
+          let cursor = 0;
+          let plainLength = 0;
+          for (const match of node.text.matchAll(CITATION_TOKEN)) {
+            const index = match.index ?? 0;
+            if (index > cursor) {
+              pieces.push({ raw: node.text.slice(cursor, index), start: start + plainLength, isToken: false });
+              plainLength += index - cursor;
+            }
+            pieces.push({ raw: match[0], start: start + plainLength, isToken: true });
+            cursor = index + match[0].length;
+          }
+          if (cursor < node.text.length) {
+            pieces.push({ raw: node.text.slice(cursor), start: start + plainLength, isToken: false });
+            plainLength += node.text.length - cursor;
+          }
+          leaves.push({ kind: "text", node, start, pieces });
+          text += pieces.filter((piece) => !piece.isToken).map((piece) => piece.raw).join("");
+          break;
+        }
+        case "code_span":
+          leaves.push({ kind: "code", node, start, text: node.code });
+          text += node.code;
+          break;
+        case "soft_break":
+        case "hard_break":
+          leaves.push({ kind: "break", start, text: " " });
+          text += " ";
+          break;
+        case "emphasis":
+        case "strong":
+        case "strikethrough":
+        case "link":
+          walk(node.children);
+          break;
+        default:
+          leaves.push({ kind: "opaque", start });
+      }
+    }
+  };
+  walk(inlines);
+  return { leaves, text };
+}
+
+/** Prose blocks (paragraphs and headings, including those inside lists, quotes and directives) in reading order. */
+export function proseBlocks(document: MarkusDocument): (MarkusBlock & { inline: MarkusInline[] })[] {
+  const blocks: (MarkusBlock & { inline: MarkusInline[] })[] = [];
+  const visit = (nodes: MarkusNode[]) => {
+    for (const node of nodes) {
+      if (node.type === "directive") visit(node.children);
+      else if (node.type === "paragraph" || node.type === "heading") blocks.push(node);
+      else if (node.type === "list") for (const item of node.items) visit(item.children);
+      else if (node.type === "blockquote") visit(node.children);
+    }
+  };
+  visit(document.children);
+  return blocks;
+}
+
+export type PreviewMark = Span & { findingIds: string[]; severity: Severity; status: EditorialFinding["status"] };
+export type PreviewSentence = Span & { segmentId: string; source: Span };
+
+/** What the preview needs for one rendered block, in that block's rendered-text offsets. */
+export type BlockAnnotation = { marks: PreviewMark[]; sentences: PreviewSentence[] };
+
+export type PreviewPlan = WeakMap<object, BlockAnnotation>;
+
+const SEVERITY_RANK: Record<Severity, number> = { error: 0, warn: 1, info: 2 };
+
+/** Text without whitespace, with a map from each kept character back to its index in the original. */
+function compact(text: string): { value: string; index: number[] } {
+  let value = "";
+  const index: number[] = [];
+  for (let i = 0; i < text.length; i += 1) {
+    if (!/\s/.test(text[i])) {
+      value += text[i];
+      index.push(i);
+    }
+  }
+  return { value, index };
+}
+
+/** Locate `needle` in `haystack` ignoring whitespace; the occurrence nearest `near` (a 0..1 position) wins. */
+export function locate(haystack: string, needle: string, near = 0): Span | null {
+  const hay = compact(haystack);
+  const want = compact(needle).value;
+  if (!want) return null;
+  let best: number | null = null;
+  for (let at = hay.value.indexOf(want); at !== -1; at = hay.value.indexOf(want, at + 1)) {
+    if (best === null || Math.abs(at / Math.max(hay.value.length, 1) - near) < Math.abs(best / Math.max(hay.value.length, 1) - near)) best = at;
+  }
+  if (best === null) return null;
+  return { start: hay.index[best], end: hay.index[best + want.length - 1] + 1 };
+}
+
+/** The identity of a block's words: no whitespace, no stray emphasis or code markers. */
+function blockKey(text: string): string {
+  return compact(text).value.replace(/[*_`~]/g, "");
+}
+
+/** Match every Limatus paragraph to a rendered block and place its findings and sentences there. */
+export function planPreview(
+  document: MarkusDocument,
+  result: EditorialCheckResult,
+  findings: EditorialFinding[],
+): PreviewPlan {
+  const plan: PreviewPlan = new WeakMap();
+  const blocks = proseBlocks(document).map((block) => ({ block, text: inlineLeaves(block.inline).text }));
+  const paragraphs = result.segments.filter((segment) => segment.kind === "paragraph" && segment.text);
+  let cursor = 0;
+  for (const paragraph of paragraphs) {
+    const wanted = blockKey(paragraph.text ?? "");
+    let matched = -1;
+    for (let candidate = cursor; candidate < blocks.length; candidate += 1) {
+      if (blockKey(blocks[candidate].text) === wanted) {
+        matched = candidate;
+        break;
+      }
+    }
+    if (matched === -1) continue;
+    cursor = matched + 1;
+    const { block, text } = blocks[matched];
+    const sentences: PreviewSentence[] = [];
+    for (const sentence of result.segments.filter((s) => s.kind === "sentence" && s.parentId === paragraph.id)) {
+      const near = (sentence.start - paragraph.start) / Math.max(paragraph.end - paragraph.start, 1);
+      const span = locate(text, sentence.text ?? "", near);
+      if (span) sentences.push({ ...span, segmentId: sentence.id, source: { start: sentence.start, end: sentence.end } });
+    }
+    const ranges: (Span & { finding: EditorialFinding })[] = [];
+    for (const finding of findings) {
+      const inParagraph =
+        finding.segmentId === paragraph.id ||
+        result.segments.some((s) => s.id === finding.segmentId && s.parentId === paragraph.id);
+      if (!inParagraph || !finding.excerptText) continue;
+      const near = (finding.span.start - paragraph.start) / Math.max(paragraph.end - paragraph.start, 1);
+      const span = locate(text, finding.excerptText, near);
+      if (span) ranges.push({ ...span, finding });
+    }
+    plan.set(block, { marks: flatten(ranges), sentences });
+  }
+  return plan;
+}
+
+/** Overlapping finding ranges become non-overlapping marks, each listing every finding it belongs to. */
+function flatten(ranges: (Span & { finding: EditorialFinding })[]): PreviewMark[] {
+  const cuts = [...new Set(ranges.flatMap((range) => [range.start, range.end]))].sort((a, b) => a - b);
+  const marks: PreviewMark[] = [];
+  for (let i = 0; i < cuts.length - 1; i += 1) {
+    const start = cuts[i];
+    const end = cuts[i + 1];
+    const covering = ranges.filter((range) => range.start <= start && end <= range.end).map((range) => range.finding);
+    if (covering.length === 0) continue;
+    const strongest = [...covering].sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity])[0];
+    const previous = marks[marks.length - 1];
+    const ids = covering.map((finding) => finding.id).sort();
+    if (previous && previous.end === start && previous.findingIds.join() === ids.join()) {
+      previous.end = end;
+      continue;
+    }
+    marks.push({
+      start,
+      end,
+      findingIds: ids,
+      severity: strongest.severity,
+      status: covering.every((finding) => finding.status === "review") ? "review" : "violation",
+    });
+  }
+  return marks;
+}
+
+/** A selection on the preview, as the source span of the whole sentences it touches. */
+export function selectionToSource(annotation: BlockAnnotation | undefined, selection: Span): Span | null {
+  if (!annotation) return null;
+  const touched = annotation.sentences.filter((sentence) => sentence.start < selection.end && selection.start < sentence.end);
+  if (touched.length === 0) return null;
+  return {
+    start: Math.min(...touched.map((sentence) => sentence.source.start)),
+    end: Math.max(...touched.map((sentence) => sentence.source.end)),
+  };
+}
+
+/** Split [start, end) of rendered text at mark boundaries; each piece says which mark (if any) covers it. */
+export function splitByMarks(start: number, end: number, marks: PreviewMark[]): { start: number; end: number; mark: PreviewMark | null }[] {
+  const pieces: { start: number; end: number; mark: PreviewMark | null }[] = [];
+  let cursor = start;
+  for (const mark of marks) {
+    if (mark.end <= cursor || mark.start >= end) continue;
+    if (mark.start > cursor) pieces.push({ start: cursor, end: mark.start, mark: null });
+    const pieceEnd = Math.min(mark.end, end);
+    pieces.push({ start: Math.max(mark.start, cursor), end: pieceEnd, mark });
+    cursor = pieceEnd;
+  }
+  if (cursor < end) pieces.push({ start: cursor, end, mark: null });
+  return pieces;
+}

package/lib/newsroom-board.ts

@@ -21,6 +21,31 @@ export interface NativeBoardIssue extends KanbanIssue {
   href: string;
   /** A few lines to show under the headline: the blurb, else the subtitle. */
   excerpt?: string;
+  /** The quiet path shown where a board would print the ID, e.g. `articles/my-slug` or `assignments/write-it`. */
+  displayId: string;
+}
+
+function slugify(text: string): string {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+/** Section and slug for a content item, falling back to the publication's board path segment. */
+export function contentItemDisplayId(version: { section?: string | null; slug?: string | null; lineageId: string }): string {
+  const section = slugify(version.section ?? "") || contentItemBoardPathSegment();
+  return `${section}/${slugify(version.slug ?? "") || version.lineageId.slice(0, 8)}`;
+}
+
+/** Assignments have no slug: use the title as one, else a short id. */
+export function assignmentDisplayId(assignment: { id: string; title?: string | null }): string {
+  const titleSlug = slugify(assignment.title ?? "").slice(0, 48).replace(/-+$/g, "");
+  return `assignments/${titleSlug || assignment.id.slice(0, 8)}`;
+}
+
+/** `formatIssueId` for the Kanbus UI: the host-provided path, never the raw `kind:id` prefix. */
+export function formatNativeIssueId(issue: KanbanIssue): string {
+  const displayId = (issue as Partial<NativeBoardIssue>).displayId;
+  if (displayId) return displayId;
+  return issue.id.replace(/^[A-Za-z]+:/, "").slice(0, 12);
 }
 
 export function contentItemBoardPathSegment(): string {
@@ -60,7 +85,7 @@ export function projectContentItemBoard(records: {
       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)}`,
-      excerpt: contentItemExcerpt(version),
+      excerpt: contentItemExcerpt(version), displayId: contentItemDisplayId(version),
     };
   });
 }
@@ -73,7 +98,7 @@ export function projectAssignmentBoard(assignments: readonly AssignmentRecord[])
     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)}`,
+    href: `/newsroom/assignments/${encodeURIComponent(row.id)}`, displayId: assignmentDisplayId(row),
   }));
 }
 

package/lib/site-brand.ts

@@ -3,6 +3,7 @@ import type { ComponentType } from "react";
 import type { EditionPresentationFormat } from "./content-types";
 import type { Article, ArticleVideoAsset } from "./articles";
 import type { BlogPageBackgroundProps } from "../components/blog-page-background";
+import type { KanbusThemeId } from "@kanbus/ui";
 import type { SiteBrandFont } from "./brand-fonts";
 import type { PictogramFigureProps } from "../components/pictogram-figure";
 import papyrusSite from "papyrus-site";
@@ -118,6 +119,13 @@ export type SiteBrand = {
   defaultVideoCredit?: string;
   themePack: ThemePackId;
   themeTokens: ThemePackTokens;
+  /**
+   * The Kanbus editorial theme the whole newsroom (sidebar, toolbar, boards,
+   * detail panel) renders in. Hard-coded per publication: editors cannot
+   * change it. Per-publication tweaks are `--kb-theme-*` overrides in the
+   * publication's `theme.css`, scoped to `[data-kanbus-theme]`.
+   */
+  kanbusTheme: KanbusThemeId;
   renderer: RendererConfig;
   hosting: HostingConfig;
   /** Static reader app when it is not co-hosted with this Papyrus checkout. */
@@ -182,6 +190,7 @@ const REFERENCE_SITE_BRANDS: Record<SiteBrandId, SiteBrand> = {
     sectionLinkStrategy: "route",
     themePack: "papyrus",
     themeTokens: DEFAULT_THEME_PACK_TOKENS,
+    kanbusTheme: "broadsheet-green",
     renderer: { kind: "pretext" },
     hosting: { kind: "amplify-ssr" },
     opsChrome: "app",
@@ -237,6 +246,14 @@ export function getSiteBrand(id: SiteBrandId = resolveSiteBrandId()): SiteBrand
 
 export const SITE_BRAND = getSiteBrand();
 
+/** Mirrors `DEFAULT_KANBUS_THEME` from `@kanbus/ui` (a test keeps the two equal) without a runtime import. */
+export const FALLBACK_KANBUS_THEME: KanbusThemeId = "newspaper-gothic";
+
+/** The newsroom theme for a brand; a brand that predates the field falls back to the default theme. */
+export function getKanbusTheme(brand: Pick<SiteBrand, "kanbusTheme"> = SITE_BRAND): KanbusThemeId {
+  return brand.kanbusTheme ?? FALLBACK_KANBUS_THEME;
+}
+
 export function getContentItemName(brand: SiteBrand = SITE_BRAND): ContentItemName {
   return brand.contentItemName ?? DEFAULT_CONTENT_ITEM_NAME;
 }

package/package.json

@@ -78,7 +78,12 @@
     "./components/blog-page-background": "./components/blog-page-background.tsx",
     "./components/curation-delegation-client": "./components/curation-delegation-client.ts",
     "./components/dev-sandbox-editor-sign-in": "./components/dev-sandbox-editor-sign-in.tsx",
+    "./components/editorial-checks-admin-panel": "./components/editorial-checks-admin-panel.tsx",
+    "./components/editorial-finding-card": "./components/editorial-finding-card.tsx",
+    "./components/editorial-findings-panel": "./components/editorial-findings-panel.tsx",
+    "./components/editorial-preview-popover": "./components/editorial-preview-popover.tsx",
     "./components/item-stream-view": "./components/item-stream-view.tsx",
+    "./components/markus-body-editor": "./components/markus-body-editor.tsx",
     "./components/markus-ir-preview": "./components/markus-ir-preview.tsx",
     "./components/news-desk-client-provider": "./components/news-desk-client-provider.tsx",
     "./components/news-desk-page": "./components/news-desk-page.tsx",
@@ -95,6 +100,11 @@
     "./components/newsroom-ops-overview": "./components/newsroom-ops-overview.tsx",
     "./components/newsroom-ops-shell": "./components/newsroom-ops-shell.tsx",
     "./components/newsroom-references-view": "./components/newsroom-references-view.tsx",
+    "./components/newsroom-theme-fonts/broadsheet-green": "./components/newsroom-theme-fonts/broadsheet-green.tsx",
+    "./components/newsroom-theme-fonts/newspaper-gothic": "./components/newsroom-theme-fonts/newspaper-gothic.tsx",
+    "./components/newsroom-theme-fonts/night-desk": "./components/newsroom-theme-fonts/night-desk.tsx",
+    "./components/newsroom-theme-fonts/refined-newsprint": "./components/newsroom-theme-fonts/refined-newsprint.tsx",
+    "./components/newsroom-theme": "./components/newsroom-theme.tsx",
     "./components/newsroom-topics-view": "./components/newsroom-topics-view.tsx",
     "./components/papyrus-console-shell": "./components/papyrus-console-shell.tsx",
     "./components/pictogram-figure": "./components/pictogram-figure.tsx",
@@ -143,6 +153,7 @@
     "./components/ui/tooltip": "./components/ui/tooltip.tsx",
     "./components/use-blog-header-obstacles": "./components/use-blog-header-obstacles.ts",
     "./components/use-brand-fonts-ready": "./components/use-brand-fonts-ready.ts",
+    "./components/use-editorial-checks": "./components/use-editorial-checks.ts",
     "./components/use-near-viewport": "./components/use-near-viewport.ts",
     "./components/use-paged-content-item-versions": "./components/use-paged-content-item-versions.ts",
     "./components/use-resolved-papyrus-theme": "./components/use-resolved-papyrus-theme.ts",
@@ -184,6 +195,12 @@
     "./lib/doctrine": "./lib/doctrine.ts",
     "./lib/edition-routes": "./lib/edition-routes.ts",
     "./lib/edition-sections": "./lib/edition-sections.ts",
+    "./lib/editorial-checks-backend": "./lib/editorial-checks-backend.ts",
+    "./lib/editorial-checks-client": "./lib/editorial-checks-client.ts",
+    "./lib/editorial-checks-demo": "./lib/editorial-checks-demo.ts",
+    "./lib/editorial-checks-settings": "./lib/editorial-checks-settings.ts",
+    "./lib/editorial-checks": "./lib/editorial-checks.ts",
+    "./lib/editorial-preview": "./lib/editorial-preview.ts",
     "./lib/empty-edition-layout-plan": "./lib/empty-edition-layout-plan.ts",
     "./lib/excerpts": "./lib/excerpts.ts",
     "./lib/front-matter-fields": "./lib/front-matter-fields.ts",
@@ -378,7 +395,7 @@
       "optional": true
     }
   },
-  "version": "2.0.3",
+  "version": "3.1.0",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",
@@ -391,7 +408,22 @@
     "@aws-sdk/s3-request-presigner": "^3.1045.0",
     "@base-ui/react": "^1.5.0",
     "@chenglou/pretext": "^0.0.7",
-    "@kanbus/ui": "https://github.com/AnthusAI/Kanbus/releases/download/ui-v0.3.1/kanbus-ui-0.3.1.tgz",
+    "@codemirror/commands": "^6.11.1",
+    "@codemirror/lang-markdown": "^6.5.2",
+    "@codemirror/language": "^6.13.1",
+    "@codemirror/state": "^6.7.6",
+    "@codemirror/view": "^6.43.15",
+    "@fontsource-variable/hanken-grotesk": "5.3.0",
+    "@fontsource-variable/jetbrains-mono": "5.3.0",
+    "@fontsource-variable/libre-franklin": "5.3.0",
+    "@fontsource-variable/literata": "5.3.0",
+    "@fontsource-variable/newsreader": "5.3.0",
+    "@fontsource-variable/public-sans": "5.3.0",
+    "@fontsource-variable/source-serif-4": "5.3.1",
+    "@fontsource/ibm-plex-mono": "5.3.0",
+    "@fontsource/ibm-plex-sans": "5.3.0",
+    "@kanbus/ui": "https://github.com/AnthusAI/Kanbus/releases/download/ui-v0.4.1/kanbus-ui-0.4.1.tgz",
+    "@lezer/highlight": "^1.2.5",
     "@radix-ui/colors": "3.0.0",
     "@smithy/protocol-http": "5.4.1",
     "@smithy/signature-v4": "5.7.4",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.3",
+  "version": "3.1.0",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",