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

package/lib/graphql-content-repository.ts

@@ -1,3 +1,4 @@
+import { generateServerClientUsingCookies } from "@aws-amplify/adapter-nextjs/api";
 import { generateClient } from "aws-amplify/data";
 import type { Schema } from "../amplify/data/resource";
 import type { Article, ArticleImage, ArticleImageAsset, ArticleImageLayout, ArticleImageThemeVariants, ArticleVideoAsset, ArticleVideoThemeVariants } from "./articles";
@@ -17,7 +18,9 @@ import {
 } from "./publication-items";
 import { BodyIrError, matchBodyImages, projectBodyIr, type BodyProjection, type BodyProjectionImage } from "./markus-body";
 import { SITE_BRAND } from "./site-brand";
-import { currentContentSource, runWithContentSource } from "./content-source-context";
+import { shouldFetchVideoScripts } from "./video-mode";
+import { collectVideoScriptTargets, parseVideoScriptRef, videomlItemSlug, type VideoScriptRef } from "./video-script";
+import { currentContentSource, currentRequestClient, runWithContentSource } from "./content-source-context";
 import { getContentSource } from "./site-env";
 
 const DEFAULT_EDITION_SLUG = "current";
@@ -143,12 +146,19 @@ function isVisibleItemStatus(status: string): boolean {
 }
 
 async function withReaderGraphQLContext<T>(operation: () => Promise<T>): Promise<T> {
-  const { runWithAmplifyServerContext } = getAmplifyServerRuntime();
+  const { runWithAmplifyServerContext, config } = getAmplifyServerRuntime();
   const source = getContentSource();
-  const nextServerContext = source === "drafts" ? { cookies: (await import("next/headers")).cookies } : null;
+  if (source === "drafts") {
+    // Drafts are read as the signed-in visitor: the client reads the session from the request cookies, and it is
+    // kept in the request's async context (never a module global) so one visitor's session cannot serve another.
+    const { cookies } = await import("next/headers");
+    await cookies();
+    const client = generateServerClientUsingCookies<Schema>({ config, cookies, authMode: "userPool" });
+    return runWithContentSource(source, operation, client);
+  }
   return runWithContentSource(source, () =>
     runWithAmplifyServerContext({
-      nextServerContext,
+      nextServerContext: null,
       operation: async () => {
         readerContextClient = generateClient<Schema>({ authMode: authMode() });
         try {
@@ -229,6 +239,10 @@ export const graphqlContentRepository: ContentRepository = {
     return withReaderGraphQLContext(() => loadEditionItem(editionDate, itemSlug));
   },
 
+  loadVideoScript(targetSlug) {
+    return withReaderGraphQLContext(() => loadVideoScriptForTarget(targetSlug));
+  },
+
   listArticleSlugs() {
     return withReaderGraphQLContext(async () => {
       const items = await listItemsByTypeStatus(`${ARTICLE_TYPE}#${PUBLISHED_STATUS}`);
@@ -241,6 +255,8 @@ export const graphqlContentRepository: ContentRepository = {
 };
 
 function getClient(): DataClient {
+  const requestClient = currentRequestClient<DataClient>();
+  if (requestClient) return requestClient;
   if (readerContextClient) return readerContextClient;
 
   if (!buildTimeClient) {
@@ -370,6 +386,9 @@ async function loadEditionContentFromEdition(edition: GraphQLEdition): Promise<E
   const sanitizedLayoutPlan = pruneLayoutPlanUnavailableItems(layoutPlan, availableItemSlugs, edition.id);
   validateEditionLayoutPlanForItems(sanitizedLayoutPlan, items, `PublishedEdition(${edition.id}).layoutPlan`);
 
+  const editionVideo = await normalizeEditionVideoAsset(editionMetadata?.editionVideo);
+  const videoScripts = await loadEditionVideoScripts(items, editionVideo);
+
   return {
     id: edition.id,
     source: "graphql",
@@ -380,10 +399,38 @@ async function loadEditionContentFromEdition(edition: GraphQLEdition): Promise<E
     items,
     sections: createEditionSectionPlan(items, edition.metadata),
     suppressNewsDeskAppendix: editionMetadata?.suppressNewsDeskAppendix === true,
-    editionVideo: await normalizeEditionVideoAsset(editionMetadata?.editionVideo),
+    editionVideo,
+    videoScripts,
   };
 }
 
+function videoScriptsEnabled(): boolean {
+  return Boolean(SITE_BRAND.videoPlayer) && shouldFetchVideoScripts();
+}
+
+async function loadVideoScriptForTarget(targetSlug: string): Promise<VideoScriptRef | null> {
+  if (!videoScriptsEnabled()) return null;
+  const item = await getItemBySlug(videomlItemSlug(targetSlug));
+  if (!item || item.type !== "videoml" || !isVisibleItemStatus(item.status)) return null;
+  return parseVideoScriptRef(item);
+}
+
+async function loadEditionVideoScripts(
+  items: PublicationItem[],
+  editionVideo: ArticleVideoAsset | null,
+): Promise<Record<string, VideoScriptRef> | undefined> {
+  if (!videoScriptsEnabled()) return undefined;
+  const targets = collectVideoScriptTargets(items, editionVideo !== null);
+  const entries = await Promise.all(
+    targets.map(async (targetSlug) => {
+      const script = await loadVideoScriptForTarget(targetSlug);
+      return script ? ([targetSlug, script] as const) : null;
+    }),
+  );
+  const videoScripts = Object.fromEntries(entries.filter((entry): entry is [string, VideoScriptRef] => entry !== null));
+  return Object.keys(videoScripts).length > 0 ? videoScripts : undefined;
+}
+
 async function normalizeEditionVideoAsset(value: unknown): Promise<ArticleVideoAsset | null> {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const record = value as Record<string, unknown>;
@@ -808,7 +855,7 @@ async function normalizeArticle(item: GraphQLItem, mediaAssets: GraphQLMediaAsse
 
 function projectPublishedItemBody(item: GraphQLItem): BodyProjection {
   if (item.bodyIr === null || item.bodyIr === undefined || item.bodyIr === "") {
-    throw new BodyIrError(`PublishedItem ${item.slug} has no bodyIr; run: papyrus content convert-bodies`);
+    throw new BodyIrError(`PublishedItem ${item.slug} has no bodyIr; run: papyrus ops content convert-bodies`);
   }
   return projectBodyIr(item.bodyIr);
 }
@@ -930,15 +977,20 @@ function parseAttachmentPointer(value: unknown): ContentAttachmentPointer | null
   };
 }
 
-function readInlineExcerpt(editorial: unknown): string | null {
+export function readInlineExcerpt(editorial: unknown): string | null {
   const parsed = parseObjectMetadata(editorial);
   if (!parsed) return null;
   const direct = parsed.excerpt;
   if (typeof direct === "string" && direct.trim()) return direct.trim();
+  const custom = parsed.customExcerpt;
+  if (typeof custom === "string" && custom.trim()) return custom.trim();
   const newsroom = parsed.newsroom;
   if (!newsroom || typeof newsroom !== "object" || Array.isArray(newsroom)) return null;
-  const nestedExcerpt = (newsroom as Record<string, unknown>).excerpt;
-  return typeof nestedExcerpt === "string" && nestedExcerpt.trim() ? nestedExcerpt.trim() : null;
+  const newsroomRecord = newsroom as Record<string, unknown>;
+  const nestedExcerpt = newsroomRecord.excerpt;
+  if (typeof nestedExcerpt === "string" && nestedExcerpt.trim()) return nestedExcerpt.trim();
+  const nestedCustom = newsroomRecord.customExcerpt;
+  return typeof nestedCustom === "string" && nestedCustom.trim() ? nestedCustom.trim() : null;
 }
 
 function normalizePublicationItemType(value: string): Exclude<PublicationItemType, "article"> | null {

package/lib/media-route-response.ts

@@ -0,0 +1,45 @@
+const PROXIED_IMAGE_EXTENSIONS = new Set(["jpg", "jpeg", "png", "gif", "webp", "avif", "svg"]);
+
+export type MediaRouteDependencies = {
+  signStorageUrl: (storagePath: string) => Promise<string>;
+  fetchUpstream: (signedUrl: string) => Promise<Response>;
+};
+
+export function isProxiedImagePath(storagePath: string): boolean {
+  const lastSegment = storagePath.split("/").pop() ?? "";
+  const dotIndex = lastSegment.lastIndexOf(".");
+  if (dotIndex < 0) {
+    return false;
+  }
+  return PROXIED_IMAGE_EXTENSIONS.has(lastSegment.slice(dotIndex + 1).toLowerCase());
+}
+
+export async function buildMediaRouteResponse(
+  storagePath: string,
+  dependencies: MediaRouteDependencies,
+): Promise<Response> {
+  const signedUrl = await dependencies.signStorageUrl(storagePath);
+
+  if (!isProxiedImagePath(storagePath)) {
+    return new Response(null, {
+      status: 307,
+      headers: { location: signedUrl, "cache-control": "private, max-age=300" },
+    });
+  }
+
+  const upstream = await dependencies.fetchUpstream(signedUrl);
+  if (!upstream.ok) {
+    return Response.json(
+      { error: `Upstream media fetch failed (${upstream.status}).` },
+      { status: upstream.status === 404 ? 404 : 502 },
+    );
+  }
+
+  const headers = new Headers();
+  const contentType = upstream.headers.get("content-type");
+  if (contentType) {
+    headers.set("content-type", contentType);
+  }
+  headers.set("cache-control", "public, max-age=3600, stale-while-revalidate=86400");
+  return new Response(upstream.body, { status: 200, headers });
+}

package/lib/newspaper-layout.ts

@@ -1,3 +1,4 @@
+import { toPublicReaderPath } from "./reader-base-path";
 import type { ArticleImageAsset, ArticleImageThemeVariants } from "./articles";
 import {
   type ArticleFrameBlockSpec,
@@ -896,9 +897,9 @@ function solveFrontFooter(blocks: SolvedBlock[], config: LayoutConfig, pageNumbe
     : Math.min(entries.length, Math.max(1, config.columnCount <= 1 ? 1 : config.columnCount <= 3 ? 2 : 4));
   const sectionRows = entries.length === 0 ? 0 : Math.ceil(entries.length / sectionColumns);
   const utilityEntries: SolvedFrontFooterUtilityEntry[] = [
-    { id: "archive", label: "Archive", href: "/archive", disabled: false },
+    { id: "archive", label: "Archive", href: toPublicReaderPath("/archive"), disabled: false },
     { id: "newsDesk", label: "Newsroom", href: "/newsroom", disabled: false },
-    { id: "settings", label: "Settings", href: "/settings", disabled: false },
+    { id: "settings", label: "Settings", href: toPublicReaderPath("/settings"), disabled: false },
     { id: "login", label: "LOGIN", disabled: true },
   ];
   const rowCount = 1 + Math.max(sectionRows, utilityEntries.length);

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-base-path.ts

@@ -19,13 +19,22 @@ export function usesNewsroomRootPaths(): boolean {
 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) || "/";
+  const suffixStart = internalPath.search(/[?#]/);
+  const pathOnly = suffixStart === -1 ? internalPath : internalPath.slice(0, suffixStart);
+  const suffix = suffixStart === -1 ? "" : internalPath.slice(suffixStart);
+  if (pathOnly === "/newsroom" || pathOnly === "/newsroom/") return `/${suffix}`;
+  if (pathOnly.startsWith("/newsroom/")) {
+    return `${pathOnly.slice("/newsroom".length) || "/"}${suffix}`;
   }
   return internalPath;
 }
 
+/** Maps a browser pathname to the internal `/newsroom/...` form on CMS-only hosts; identity elsewhere. */
+export function browserPathToInternalNewsroomPath(browserPath: string): string {
+  if (!usesNewsroomRootPaths()) return browserPath;
+  return toInternalNewsroomPath(browserPath);
+}
+
 export function toInternalNewsroomPath(publicPath: string): string {
   const publicBase = getPublicNewsroomBasePath();
   const normalized = publicPath.startsWith("/") ? publicPath : `/${publicPath}`;

package/lib/newsroom-category-drilldown.ts

@@ -1,3 +1,4 @@
+import { toPublicNewsroomPath } from "./newsroom-base-path";
 import type {
   CategorySteeringCategory,
   SemanticRelationRecord,
@@ -93,11 +94,11 @@ export function uniqueNeighborGroupsForCategoryContext(graph: CategoryGraph, con
 export function topicHref(rootCategoryKey: string, selectedCategoryKey?: string | null): string {
   const encodedRoot = encodeURIComponent(rootCategoryKey);
   const encodedSelected = selectedCategoryKey && selectedCategoryKey !== rootCategoryKey ? `/${encodeURIComponent(selectedCategoryKey)}` : "";
-  return `/newsroom/topics/${encodedRoot}${encodedSelected}`;
+  return toPublicNewsroomPath(`/newsroom/topics/${encodedRoot}${encodedSelected}`);
 }
 
 export function categoryDrilldownHref(section: "references" | "concepts", categoryKey: string): string {
-  return `/newsroom/${section}/${encodeURIComponent(categoryKey)}`;
+  return toPublicNewsroomPath(`/newsroom/${section}/${encodeURIComponent(categoryKey)}`);
 }
 
 function matchesCategorySelection(category: CategorySteeringCategory, selection: string): boolean {

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",
+    }),
+  ];
+}