@anthusai/papyrus 1.0.0-next.4 → 1.0.0-next.6

package/lib/content-actions-demo.ts

@@ -0,0 +1,172 @@
+import { ContentActionFailure } from "./content-actions-client";
+import type {
+  DeriveMarkusInput,
+  DeriveMarkusResult,
+  PublishItemResult,
+  SaveItemDraftInput,
+  SaveItemDraftResult,
+  UnpublishItemResult,
+} from "./content-actions-client";
+import {
+  createDemoArticleRecords,
+  demoContentHash,
+  type DemoArticleRecord,
+} from "./newsroom-demo-articles";
+import { sourceLineOffset, type ArticlesBackend, type EditableArticle, type NewsroomArticleRow } from "./newsroom-articles";
+
+function titleFromYaml(frontMatterYaml: string | null, fallback: string): string {
+  for (const line of (frontMatterYaml ?? "").split("\n")) {
+    const match = /^title\s*:\s*(.*)$/.exec(line);
+    if (match && match[1].trim()) return match[1].trim().replace(/^["']|["']$/g, "");
+  }
+  return fallback;
+}
+
+function demoEnvelope(bodyMarkus: string) {
+  const children = bodyMarkus
+    .split(/\n{2,}/)
+    .map((block) => block.trim())
+    .filter(Boolean)
+    .map((block) => {
+      const heading = /^(#{1,6})\s+(.*)$/.exec(block);
+      if (heading) {
+        return { type: "heading", level: heading[1].length, inline: [{ type: "text", text: heading[2] }], line: null };
+      }
+      return { type: "paragraph", inline: [{ type: "text", text: block }], line: null };
+    });
+  return {
+    schemaVersion: 1,
+    markus: { version: "demo", irSchemaVersion: 1 },
+    document: { type: "document", schema_version: 1, front_matter: {}, children },
+    papyrus: { images: {}, citations: {}, citationLists: {}, entries: {}, bibliography: [] },
+  };
+}
+
+export function createDemoArticlesBackend(): ArticlesBackend {
+  const records = new Map<string, DemoArticleRecord>(createDemoArticleRecords().map((record) => [record.id, record]));
+  let created = 0;
+
+  const requireRecord = (id: string): DemoArticleRecord => {
+    const record = records.get(id);
+    if (!record) throw new ContentActionFailure([{ code: "not-found", message: "That article was not found.", line: null }]);
+    return record;
+  };
+
+  return {
+    actions: {
+      async deriveMarkus(input: DeriveMarkusInput): Promise<DeriveMarkusResult> {
+        const lines = input.bodyMarkus.split("\n");
+        const invalidIndex = lines.findIndex((line) => line.includes(":::nope"));
+        if (invalidIndex >= 0) {
+          throw new ContentActionFailure([
+            { code: "markus-validation", message: 'Unknown directive "nope".', line: invalidIndex + 1 + sourceLineOffset(input.frontMatterYaml) },
+          ]);
+        }
+        const envelope = demoEnvelope(input.bodyMarkus);
+        return {
+          ok: true,
+          bodyIrBytes: JSON.stringify(envelope).length,
+          ...(input.includeIr ? { bodyIr: envelope } : {}),
+          errors: [],
+        };
+      },
+      async saveItemDraft(input: SaveItemDraftInput): Promise<SaveItemDraftResult> {
+        const existing = input.id ? requireRecord(input.id) : null;
+        if (existing && input.expectedContentHash !== null && input.expectedContentHash !== existing.contentHash) {
+          throw new ContentActionFailure([
+            { code: "conflict", message: "The item changed since it was loaded.", line: null },
+          ]);
+        }
+        if (existing && existing.everPublished && existing.slug !== input.slug) {
+          throw new ContentActionFailure([
+            { code: "slug-locked", message: "The slug cannot change once the item has been published.", line: null },
+          ]);
+        }
+        const id = existing?.id ?? `demo-article-new-${(created += 1)}`;
+        const title = titleFromYaml(input.frontMatterYaml, input.slug);
+        const frontMatterYaml = input.frontMatterYaml ?? "";
+        const record: DemoArticleRecord = {
+          id,
+          type: input.type,
+          slug: input.slug,
+          section: input.section,
+          title,
+          status: existing?.status ?? "draft",
+          frontMatterYaml,
+          bodyMarkus: input.bodyMarkus,
+          contentHash: demoContentHash(frontMatterYaml, input.bodyMarkus),
+          publishedContentHash: existing?.publishedContentHash ?? null,
+          versionNumber: existing?.versionNumber ?? null,
+          everPublished: existing?.everPublished ?? false,
+          updatedAt: new Date().toISOString(),
+        };
+        records.set(id, record);
+        return {
+          ok: true,
+          item: {
+            id,
+            contentHash: record.contentHash,
+            status: record.status,
+            slug: record.slug,
+            versionNumber: record.versionNumber,
+          },
+        };
+      },
+      async publishItem(id: string): Promise<PublishItemResult> {
+        const record = requireRecord(id);
+        const changed = record.status !== "published" || record.publishedContentHash !== record.contentHash;
+        const versionNumber = changed ? (record.versionNumber ?? 0) + 1 : record.versionNumber;
+        records.set(id, {
+          ...record,
+          status: "published",
+          everPublished: true,
+          publishedContentHash: record.contentHash,
+          versionNumber,
+          updatedAt: new Date().toISOString(),
+        });
+        return { ok: true, changed, publishedId: `published-${id}`, versionNumber };
+      },
+      async unpublishItem(id: string): Promise<UnpublishItemResult> {
+        const record = requireRecord(id);
+        const changed = record.status === "published";
+        records.set(id, {
+          ...record,
+          status: "draft",
+          publishedContentHash: null,
+          updatedAt: new Date().toISOString(),
+        });
+        return { ok: true, changed };
+      },
+    },
+    async listRows(): Promise<NewsroomArticleRow[]> {
+      return [...records.values()]
+        .map((record) => ({
+          id: record.id,
+          type: record.type,
+          slug: record.slug,
+          section: record.section,
+          title: record.title || record.slug,
+          status: record.status,
+          pending: record.status === "published" && record.publishedContentHash !== record.contentHash,
+          updatedAt: record.updatedAt,
+        }))
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    },
+    async loadArticle(id: string): Promise<EditableArticle> {
+      const record = requireRecord(id);
+      return {
+        id: record.id,
+        type: record.type,
+        section: record.section,
+        slug: record.slug,
+        frontMatterYaml: record.frontMatterYaml,
+        bodyMarkus: record.bodyMarkus,
+        contentHash: record.contentHash,
+        status: record.status,
+        versionNumber: record.versionNumber,
+        aliases: [],
+        everPublished: record.everPublished,
+      };
+    },
+  };
+}

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-demo-articles.ts

@@ -0,0 +1,90 @@
+export type DemoArticleRecord = {
+  id: string;
+  type: string;
+  slug: string;
+  section: string | null;
+  title: string;
+  status: "draft" | "published";
+  frontMatterYaml: string;
+  bodyMarkus: string;
+  contentHash: string;
+  publishedContentHash: string | null;
+  versionNumber: number | null;
+  everPublished: boolean;
+  updatedAt: string;
+};
+
+export function demoContentHash(frontMatterYaml: string, bodyMarkus: string): string {
+  let hash = 5381;
+  const text = `${frontMatterYaml}\u0000${bodyMarkus}`;
+  for (let index = 0; index < text.length; index += 1) {
+    hash = ((hash << 5) + hash + text.charCodeAt(index)) >>> 0;
+  }
+  return `demo:${hash.toString(16)}`;
+}
+
+function demoRecord(
+  fields: Pick<DemoArticleRecord, "id" | "slug" | "section" | "title" | "bodyMarkus" | "updatedAt"> & {
+    type?: string;
+    status: "draft" | "published";
+    publishedBody?: string;
+    versionNumber: number | null;
+  },
+): DemoArticleRecord {
+  const frontMatterYaml = `title: ${fields.title}\n`;
+  const contentHash = demoContentHash(frontMatterYaml, fields.bodyMarkus);
+  const publishedContentHash = fields.status === "published"
+    ? demoContentHash(frontMatterYaml, fields.publishedBody ?? fields.bodyMarkus)
+    : null;
+  return {
+    id: fields.id,
+    type: fields.type ?? "article",
+    slug: fields.slug,
+    section: fields.section,
+    title: fields.title,
+    status: fields.status,
+    frontMatterYaml,
+    bodyMarkus: fields.bodyMarkus,
+    contentHash,
+    publishedContentHash,
+    versionNumber: fields.versionNumber,
+    everPublished: fields.status === "published",
+    updatedAt: fields.updatedAt,
+  };
+}
+
+export function createDemoArticleRecords(): DemoArticleRecord[] {
+  return [
+    demoRecord({
+      id: "demo-article-changed",
+      slug: "forty-billion-dollars",
+      section: "business",
+      title: "Forty Billion Dollars",
+      bodyMarkus: "The raise doubled again this quarter.\n\nAnalysts expect the pace to slow.\n",
+      publishedBody: "The raise doubled this quarter.\n",
+      status: "published",
+      versionNumber: 2,
+      updatedAt: "2026-10-05T16:00:00.000Z",
+    }),
+    demoRecord({
+      id: "demo-article-published",
+      slug: "harbor-cranes-return",
+      section: "local",
+      title: "Harbor Cranes Return",
+      bodyMarkus: "# Harbor Cranes Return\n\nThe cranes were lifted back into place on Monday.\n",
+      status: "published",
+      versionNumber: 1,
+      updatedAt: "2026-10-04T12:00:00.000Z",
+    }),
+    demoRecord({
+      id: "demo-article-draft",
+      slug: "council-budget-notes",
+      section: "politics",
+      title: "Council Budget Notes",
+      bodyMarkus: "Notes from the budget session.\n",
+      status: "draft",
+      versionNumber: null,
+      updatedAt: "2026-10-03T09:00:00.000Z",
+    }),
+  ];
+}

package/lib/newsroom-nav.ts

@@ -2,6 +2,7 @@ import { newsroomHref, toPublicNewsroomPath } from "./newsroom-base-path";
 
 export type NewsroomNavTabId =
   | "overview"
+  | "articles"
   | "messages"
   | "insights"
   | "assignments"
@@ -22,6 +23,7 @@ export type NewsroomNavItem = {
 
 export const NEWSROOM_OPS_NAV: NewsroomNavItem[] = [
   { id: "overview", label: "Overview", detail: "Desk home", href: newsroomHref(), mobilePrimary: true },
+  { id: "articles", label: "Articles", detail: "Drafts & published", href: newsroomHref("articles"), mobilePrimary: true },
   { id: "assignments", label: "Assignments", detail: "Work queue", href: newsroomHref("assignments"), mobilePrimary: true },
   { id: "references", label: "References", detail: "Knowledge base", href: newsroomHref("references"), mobilePrimary: true },
   { id: "messages", label: "Messages", detail: "Forum", href: newsroomHref("messages") },

package/lib/site-brand.ts

@@ -34,6 +34,18 @@ export type SiteBrandDemoEdition = {
   editionVideo?: ArticleVideoAsset;
 };
 
+/**
+ * Video slot: how a publication supplies its own VideoML scene components.
+ * Paths are relative to the publication root.
+ */
+export type SiteBrandVideo = {
+  /** TSX module that registers the brand's `@videoml` scene components via `window.Babulus.registerComponent`. */
+  bundleEntry: string;
+  /** DSL element aliases for the browser preview, e.g. `{ "quote-card": "acme-quote-card" }`. */
+  sceneComponents?: Record<string, string>;
+  rhythm?: Record<string, unknown>;
+};
+
 export type SiteBrand = {
   id: SiteBrandId;
   appTitle: string;
@@ -76,6 +88,7 @@ export type SiteBrand = {
   publicationName: string;
   components?: SiteBrandComponents;
   demoEdition?: SiteBrandDemoEdition;
+  video?: SiteBrandVideo;
 };
 
 const SERIF_TEXT_FONT = 'Georgia, "Times New Roman", serif';