@anthusai/papyrus 0.0.0 → 1.0.0-next.10

package/app/layout.tsx

@@ -0,0 +1,142 @@
+import type { Metadata } from "next";
+import { Playfair_Display, Plus_Jakarta_Sans } from "next/font/google";
+import Script from "next/script";
+import { AmplifyClientProvider } from "../components/amplify-client-provider";
+import { PapyrusConsoleShell } from "../components/papyrus-console-shell";
+import { TooltipProvider } from "../components/ui/tooltip";
+import { getPresentationChoices, getSiteBrand } from "../lib/site-brand";
+import { getSiteStack } from "../lib/site-stack";
+import { isIndexable, showStagingBanner } from "../lib/site-env";
+import { StagingBanner } from "../components/staging-banner";
+import "./tailwind.css";
+import "./globals.css";
+import "papyrus-site-theme";
+
+const playfairDisplay = Playfair_Display({
+  subsets: ["latin"],
+  variable: "--font-serif",
+});
+
+const plusJakartaSans = Plus_Jakarta_Sans({
+  subsets: ["latin"],
+  variable: "--font-sans",
+});
+
+const faviconVersion = "20260517-1";
+const defaultTheme = "system";
+export async function generateMetadata(): Promise<Metadata> {
+  const siteBrand = getSiteBrand();
+  return {
+    title: siteBrand.appTitle,
+    description: siteBrand.appDescription,
+    ...(isIndexable() ? {} : { robots: { index: false, follow: false } }),
+    icons: {
+      icon: [
+        { url: `/icon-light.png?v=${faviconVersion}`, type: "image/png" },
+        { url: `/icon.png?v=${faviconVersion}`, type: "image/png" },
+      ],
+    },
+  };
+}
+
+export default async function RootLayout({ children }: Readonly<{ children: React.ReactNode }>) {
+  const siteBrand = getSiteBrand();
+  const presentationChoices = getPresentationChoices(siteBrand);
+  const siteStack = getSiteStack(siteBrand);
+
+  return (
+    <html
+      lang="en"
+      className="light light-theme"
+      data-papyrus-theme={defaultTheme}
+      data-site-brand={siteBrand.id}
+      data-theme-pack={siteStack.ops.themePack}
+      data-ops-chrome={siteStack.ops.chrome}
+      data-renderer={siteStack.publication.renderer.kind}
+      data-default-presentation={siteBrand.defaultPresentation}
+      data-presentation-choices={presentationChoices.join(",")}
+      {...(siteBrand.forcedPresentation ? { "data-forced-presentation": siteBrand.forcedPresentation } : {})}
+      suppressHydrationWarning
+    >
+      <body className={`${playfairDisplay.variable} ${plusJakartaSans.variable}`}>
+        <Script id="papyrus-favicon-color-scheme" strategy="beforeInteractive">
+          {`(() => {
+  const version = "${faviconVersion}";
+  const lightHref = "/icon-light.png?v=" + version;
+  const darkHref = "/icon-dark.png?v=" + version;
+  const settingsStorageKey = "papyrus:reader-settings";
+  const defaultTheme = "${defaultTheme}";
+
+  const getLink = () => {
+    const existingTagged = document.querySelector('link[rel="icon"][data-papyrus-theme-icon="true"]');
+    if (existingTagged) return existingTagged;
+
+    const existingPng = document.querySelector('link[rel="icon"][type="image/png"]');
+    if (existingPng) {
+      existingPng.setAttribute("data-papyrus-theme-icon", "true");
+      return existingPng;
+    }
+
+    const link = document.createElement("link");
+    link.rel = "icon";
+    link.type = "image/png";
+    link.setAttribute("data-papyrus-theme-icon", "true");
+    document.head.appendChild(link);
+    return link;
+  };
+
+  const iconLink = getLink();
+  const readTheme = () => {
+    try {
+      const stored = window.localStorage.getItem(settingsStorageKey);
+      const parsed = stored ? JSON.parse(stored) : null;
+      return parsed && (parsed.theme === "light" || parsed.theme === "dark" || parsed.theme === "system")
+        ? parsed.theme
+        : defaultTheme;
+    } catch {
+      return defaultTheme;
+    }
+  };
+  const isDarkTheme = (theme) => theme === "dark" || (theme === "system" && media.matches);
+  const applyThemeClass = (theme) => {
+    const isDark = isDarkTheme(theme);
+    document.documentElement.classList.toggle("dark", isDark);
+    document.documentElement.classList.toggle("dark-theme", isDark);
+    document.documentElement.classList.toggle("light", !isDark);
+    document.documentElement.classList.toggle("light-theme", !isDark);
+    return isDark;
+  };
+  const apply = () => {
+    const theme = readTheme();
+    document.documentElement.dataset.papyrusTheme = theme;
+    const isDark = applyThemeClass(theme);
+    const nextHref = isDark ? darkHref : lightHref;
+    if (iconLink.getAttribute("href") !== nextHref) {
+      iconLink.setAttribute("href", nextHref);
+    }
+  };
+
+  const media = window.matchMedia("(prefers-color-scheme: dark)");
+  apply();
+
+  if (typeof media.addEventListener === "function") {
+    media.addEventListener("change", apply);
+  } else if (typeof media.addListener === "function") {
+    media.addListener(apply);
+  }
+  window.addEventListener("storage", (event) => {
+    if (event.key === settingsStorageKey) apply();
+  });
+  window.addEventListener("papyrus:settings-changed", apply);
+})();`}
+        </Script>
+        {showStagingBanner() ? <StagingBanner /> : null}
+        <AmplifyClientProvider>
+          <TooltipProvider>
+            <PapyrusConsoleShell>{children}</PapyrusConsoleShell>
+          </TooltipProvider>
+        </AmplifyClientProvider>
+      </body>
+    </html>
+  );
+}

package/app/newsroom/[section]/[...selection]/page.tsx

@@ -0,0 +1,50 @@
+import { notFound, redirect } from "next/navigation";
+import { NewsDeskPage } from "../../../../components/news-desk-page";
+import type { NewsDeskTab } from "../../../../components/topic-steering-workspace";
+
+export const dynamic = "force-dynamic";
+
+type NewsDeskNestedSectionPageProps = {
+  params: Promise<{ section: string; selection: string[] }>;
+  searchParams?: Promise<{
+    demo?: string | string[];
+    panel?: string | string[];
+    reference?: string | string[];
+    category?: string | string[];
+    node?: string | string[];
+    assignment?: string | string[];
+    message?: string | string[];
+    user?: string | string[];
+    item?: string | string[];
+    q?: string | string[];
+    anchorKind?: string | string[];
+    anchorId?: string | string[];
+    anchorLineageId?: string | string[];
+    maxTokens?: string | string[];
+    from?: string | string[];
+  }>;
+};
+
+const NEWS_DESK_ROUTE_SECTIONS = new Set<NewsDeskTab>([
+  "administration",
+  "topics",
+  "concepts",
+  "references",
+  "insights",
+  "messages",
+  "assignments",
+]);
+
+export default async function NewsDeskNestedSectionPage({ params, searchParams }: NewsDeskNestedSectionPageProps) {
+  const { section, selection } = await params;
+  if (section === "users") redirect("/newsroom/administration/users");
+  if (section === "doctrine") redirect("/newsroom/administration/policies");
+  if (section === "administration" && selection[0] === "analysis") redirect("/newsroom/assignments");
+  if (section === "desks") {
+    const category = selection[0] ? decodeURIComponent(selection[0]) : null;
+    if (category) redirect(`/newsroom/topics?category=${encodeURIComponent(category)}`);
+    redirect("/newsroom/topics");
+  }
+  if (!NEWS_DESK_ROUTE_SECTIONS.has(section as NewsDeskTab)) notFound();
+  return <NewsDeskPage section={section} selectionPath={selection} searchParams={searchParams} />;
+}

package/app/newsroom/[section]/page.tsx

@@ -0,0 +1,47 @@
+import { notFound, redirect } from "next/navigation";
+import { NewsDeskPage } from "../../../components/news-desk-page";
+import type { NewsDeskTab } from "../../../components/topic-steering-workspace";
+
+export const dynamic = "force-dynamic";
+
+type NewsDeskSectionPageProps = {
+  params: Promise<{ section: string }>;
+  searchParams?: Promise<{
+    demo?: string | string[];
+    panel?: string | string[];
+    reference?: string | string[];
+    category?: string | string[];
+    node?: string | string[];
+    assignment?: string | string[];
+    message?: string | string[];
+    user?: string | string[];
+    item?: string | string[];
+    q?: string | string[];
+    anchorKind?: string | string[];
+    anchorId?: string | string[];
+    anchorLineageId?: string | string[];
+    maxTokens?: string | string[];
+    from?: string | string[];
+    proposal?: string | string[];
+  }>;
+};
+
+const NEWS_DESK_ROUTE_SECTIONS = new Set<NewsDeskTab>([
+  "administration",
+  "topics",
+  "concepts",
+  "references",
+  "insights",
+  "messages",
+  "assignments",
+  "search",
+]);
+
+export default async function NewsDeskSectionPage({ params, searchParams }: NewsDeskSectionPageProps) {
+  const { section } = await params;
+  if (section === "users") redirect("/newsroom/administration/users");
+  if (section === "doctrine") redirect("/newsroom/administration/policies");
+  if (section === "desks") redirect("/newsroom/topics");
+  if (!NEWS_DESK_ROUTE_SECTIONS.has(section as NewsDeskTab)) notFound();
+  return <NewsDeskPage section={section} searchParams={searchParams} />;
+}

package/app/newsroom/articles/[id]/page.tsx

@@ -0,0 +1,15 @@
+import { NewsroomArticleEditor } from "../../../../components/newsroom-article-editor";
+
+export const dynamic = "force-dynamic";
+
+type NewsroomArticleEditorPageProps = {
+  params: Promise<{ id: string }>;
+  searchParams?: Promise<{ demo?: string | string[] }>;
+};
+
+export default async function NewsroomArticleEditorPage({ params, searchParams }: NewsroomArticleEditorPageProps) {
+  const { id } = await params;
+  const resolved = await searchParams;
+  const demoValue = Array.isArray(resolved?.demo) ? resolved?.demo[0] : resolved?.demo;
+  return <NewsroomArticleEditor articleId={decodeURIComponent(id)} demo={demoValue === "1"} />;
+}

package/app/newsroom/articles/page.tsx

@@ -0,0 +1,13 @@
+import { NewsroomArticlesView } from "../../../components/newsroom-articles-view";
+
+export const dynamic = "force-dynamic";
+
+type NewsroomArticlesPageProps = {
+  searchParams?: Promise<{ demo?: string | string[] }>;
+};
+
+export default async function NewsroomArticlesPage({ searchParams }: NewsroomArticlesPageProps) {
+  const resolved = await searchParams;
+  const demoValue = Array.isArray(resolved?.demo) ? resolved?.demo[0] : resolved?.demo;
+  return <NewsroomArticlesView demo={demoValue === "1"} />;
+}

package/app/newsroom/forum/[threadId]/page.tsx

@@ -0,0 +1,35 @@
+import { NewsDeskPage } from "../../../../components/news-desk-page";
+
+export const dynamic = "force-dynamic";
+
+type NewsroomForumThreadPageProps = {
+  params: Promise<{ threadId: string }>;
+  searchParams?: Promise<{
+    demo?: string | string[];
+    panel?: string | string[];
+    reference?: string | string[];
+    category?: string | string[];
+    node?: string | string[];
+    assignment?: string | string[];
+    message?: string | string[];
+    user?: string | string[];
+    item?: string | string[];
+    q?: string | string[];
+    anchorKind?: string | string[];
+    anchorId?: string | string[];
+    anchorLineageId?: string | string[];
+    maxTokens?: string | string[];
+    from?: string | string[];
+  }>;
+};
+
+export default async function NewsroomForumThreadPage({ params, searchParams }: NewsroomForumThreadPageProps) {
+  const { threadId } = await params;
+  return (
+    <NewsDeskPage
+      section="overview"
+      selectionPath={["forum", threadId]}
+      searchParams={searchParams}
+    />
+  );
+}

package/app/newsroom/insights/[threadId]/page.tsx

@@ -0,0 +1,22 @@
+import { NewsDeskPage } from "../../../../components/news-desk-page";
+
+export const dynamic = "force-dynamic";
+
+type NewsroomInsightThreadPageProps = {
+  params: Promise<{ threadId: string }>;
+  searchParams?: Promise<{
+    demo?: string | string[];
+    domain?: string | string[];
+  }>;
+};
+
+export default async function NewsroomInsightThreadPage({ params, searchParams }: NewsroomInsightThreadPageProps) {
+  const { threadId } = await params;
+  return (
+    <NewsDeskPage
+      section="insights"
+      selectionPath={[threadId]}
+      searchParams={searchParams}
+    />
+  );
+}

package/app/newsroom/insights/page.tsx

@@ -0,0 +1,14 @@
+import { NewsDeskPage } from "../../../components/news-desk-page";
+
+export const dynamic = "force-dynamic";
+
+type NewsroomInsightsPageProps = {
+  searchParams?: Promise<{
+    demo?: string | string[];
+    domain?: string | string[];
+  }>;
+};
+
+export default async function NewsroomInsightsPage({ searchParams }: NewsroomInsightsPageProps) {
+  return <NewsDeskPage section="insights" searchParams={searchParams} />;
+}

package/app/newsroom/layout.tsx

@@ -0,0 +1,12 @@
+import { NewsDeskClientProvider } from "../../components/news-desk-client-provider";
+import { resolveDevSandboxEditorAuth } from "../../lib/dev-sandbox-editor-auth";
+
+export default function NewsroomLayout({ children }: Readonly<{ children: React.ReactNode }>) {
+  const devSandboxEditorAuth = resolveDevSandboxEditorAuth();
+
+  return (
+    <NewsDeskClientProvider devSandboxEditorAuth={devSandboxEditorAuth}>
+      {children}
+    </NewsDeskClientProvider>
+  );
+}

package/app/newsroom/page.tsx

@@ -0,0 +1,31 @@
+import { NewsDeskPage } from "../../components/news-desk-page";
+
+export const dynamic = "force-dynamic";
+
+export type NewsDeskRootSearchParams = {
+  demo?: string | string[];
+  section?: string | string[];
+  tab?: string | string[];
+  panel?: string | string[];
+  reference?: string | string[];
+  category?: string | string[];
+  node?: string | string[];
+  assignment?: string | string[];
+  message?: string | string[];
+  user?: string | string[];
+  item?: string | string[];
+  q?: string | string[];
+  anchorKind?: string | string[];
+  anchorId?: string | string[];
+  anchorLineageId?: string | string[];
+  maxTokens?: string | string[];
+  from?: string | string[];
+};
+
+type NewsDeskRootPageProps = {
+  searchParams?: Promise<NewsDeskRootSearchParams>;
+};
+
+export default function NewsDeskRootPage({ searchParams }: NewsDeskRootPageProps) {
+  return <NewsDeskPage searchParams={searchParams} />;
+}

package/app/newsroom/sections/[sectionId]/page.tsx

@@ -0,0 +1,17 @@
+import { notFound } from "next/navigation";
+import { NewsDeskPage } from "../../../../components/news-desk-page";
+
+export const dynamic = "force-dynamic";
+
+type NewsroomDeepSectionPageProps = {
+  params: Promise<{ sectionId: string }>;
+  searchParams?: Promise<Record<string, string | string[] | undefined>>;
+};
+
+export default async function NewsroomDeepSectionPage({ params, searchParams }: NewsroomDeepSectionPageProps) {
+  const { sectionId } = await params;
+  const normalizedSectionId = decodeURIComponent(sectionId ?? "").trim();
+  if (!normalizedSectionId) notFound();
+
+  return <NewsDeskPage sectionPageId={normalizedSectionId} searchParams={searchParams} />;
+}

package/app/page.tsx

@@ -0,0 +1,272 @@
+import { getSiteRenderer } from "../lib/site-renderer";
+import { contentRepository, getScenarioIdParam } from "../lib/content-repository";
+import type { EditionContent } from "../lib/content-types";
+import { createEditionSectionPlan } from "../lib/edition-sections";
+import { getEditionDatePath } from "../lib/edition-routes";
+import {
+  EMPTY_EDITION_PLACEHOLDER_SLUG,
+  buildEmptyEditionLayoutPlan,
+} from "../lib/empty-edition-layout-plan";
+import {
+  loadPublicPlaceholderSections,
+  loadPublicPlaceholderTopics,
+  type PublicPlaceholderSection,
+  type PublicPlaceholderTopic,
+} from "../lib/public-placeholder-config";
+import type { PublicationItem } from "../lib/publication-items";
+import { SITE_BRAND, rootRoute } from "../lib/site-brand";
+import { redirect } from "next/navigation";
+import NewsDeskRootPage, { type NewsDeskRootSearchParams } from "./newsroom/page";
+
+export const dynamic = "force-dynamic";
+
+type HomePageProps = {
+  searchParams?: Promise<{
+    scenario?: string | string[];
+    code?: string | string[];
+    state?: string | string[];
+    error?: string | string[];
+  } & NewsDeskRootSearchParams>;
+};
+
+export default async function Home({ searchParams }: HomePageProps) {
+  const resolvedSearchParams = await searchParams;
+  const scenarioId = getScenarioIdParam(resolvedSearchParams?.scenario);
+
+  // Root-route behavior is per-brand (SITE_BRAND.rootRoute). A site that
+  // co-hosts reader + CMS uses the default "reader" (render the publication
+  // home page here). A CMS-only site points the root at the newsroom or
+  // anywhere else. Preserve the scenario and OAuth-callback paths.
+  if (rootRoute.kind === "newsroom" && !scenarioId) {
+    return <NewsDeskRootPage searchParams={searchParams} />;
+  }
+
+  if (rootRoute.kind === "redirect" && !scenarioId && !hasOAuthRedirectParams(resolvedSearchParams)) {
+    redirect(rootRoute.destination);
+  }
+
+  // Resolved only on the reader path: Markus brands (renderer "markus") have
+  // no Next.js reader and getSiteRenderer() throws for them, but they can
+  // still serve the newsroom at the root via rootRoute above.
+  const siteRenderer = getSiteRenderer();
+
+  if (!scenarioId) {
+    if (hasOAuthRedirectParams(resolvedSearchParams)) {
+      const mastheadHomeHref = await loadFirstPublishedEditionPath();
+      const content = await loadLatestGraphQLEdition();
+      if (!content || content.items.length === 0) return <siteRenderer.renderEdition content={createEmptyGraphQLEdition()} />;
+      return (
+        <siteRenderer.renderEdition
+          content={content}
+          editionBasePath={getEditionDatePath(content.editionDate)}
+          mastheadHomeHref={mastheadHomeHref}
+        />
+      );
+    }
+
+    const latestEdition = await contentRepository.getLatestPublishedEdition();
+    if (latestEdition) redirect(getEditionDatePath(latestEdition.editionDate));
+    return <siteRenderer.renderEdition content={createEmptyGraphQLEdition()} />;
+  }
+
+  const content = await loadHomeContent(scenarioId);
+  if (content.items.length === 0) return <siteRenderer.renderEdition content={createEmptyGraphQLEdition()} />;
+  return <siteRenderer.renderEdition content={content} />;
+}
+
+async function loadLatestGraphQLEdition(): Promise<EditionContent | null> {
+  const latestEdition = await contentRepository.getLatestPublishedEdition();
+  if (!latestEdition) return null;
+  return contentRepository.loadEditionContent({ editionDate: latestEdition.editionDate });
+}
+
+async function loadFirstPublishedEditionPath(): Promise<string | undefined> {
+  const firstEdition = await contentRepository.getFirstPublishedEdition();
+  if (!firstEdition) return undefined;
+  return getEditionDatePath(firstEdition.editionDate);
+}
+
+async function loadHomeContent(scenarioId: string | null): Promise<EditionContent> {
+  try {
+    return await contentRepository.loadEditionContent({ scenarioId });
+  } catch (error) {
+    if (scenarioId || !isMissingReaderBackendError(error)) throw error;
+    return createEmptyGraphQLEdition();
+  }
+}
+
+function createEmptyGraphQLEdition(): EditionContent {
+  const placeholderSlug = EMPTY_EDITION_PLACEHOLDER_SLUG;
+  const configuredSections = loadPublicPlaceholderSections();
+  const publicTopics = loadPublicPlaceholderTopics();
+  const sectionItems = createPlaceholderSectionItems(configuredSections);
+  const topicItems = createPlaceholderTopicItems(publicTopics);
+  const sectionsCta = createPlaceholderCtaItem({
+    slug: "empty-edition-sections-newsroom",
+    title: "Manage sections in Newsroom",
+    deck: "Canonical and rotating sections are managed from the Newsroom.",
+    href: "/newsroom/sections",
+    group: "sections",
+    ctaLabel: "Manage sections in Newsroom",
+  });
+  const topicsCta = createPlaceholderCtaItem({
+    slug: "empty-edition-topics-newsroom",
+    title: "Curate topics in Newsroom",
+    deck: "The AI/ML technology that powers the knowledge base is curated from the Newsroom.",
+    href: "/newsroom/topics",
+    group: "topics",
+    ctaLabel: "Curate topics in Newsroom",
+  });
+  const items: EditionContent["items"] = [
+    createEmptyEditionLandingItem(placeholderSlug),
+    ...sectionItems,
+    sectionsCta,
+    ...topicItems,
+    topicsCta,
+  ];
+
+  return {
+    id: "empty-graphql-edition",
+    source: "graphql",
+    placeholderMode: "emptyEdition",
+    title: SITE_BRAND.appTitle,
+    editionDate: new Date().toISOString().slice(0, 10),
+    description: "No published GraphQL edition is available yet.",
+    items,
+    sections: createEditionSectionPlan(items),
+    layoutPlan: buildEmptyEditionLayoutPlan({
+      placeholderSlug,
+      sectionItemSlugs: sectionItems.map((item) => item.slug),
+      sectionsCtaSlug: sectionsCta.slug,
+      topicItemSlugs: topicItems.map((item) => item.slug),
+      topicsCtaSlug: topicsCta.slug,
+    }),
+  };
+}
+
+function createEmptyEditionLandingItem(slug: string): PublicationItem {
+  return {
+    type: "article",
+    slug,
+    shortSlug: "EMPTY",
+    section: "Newsroom",
+    headline: "An Autonomous Newsroom for Human-Steered Publishing",
+    deck: "An automated newsroom that turns research, judgment, and policy into blog-first editions.",
+    byline: SITE_BRAND.placeholderByline,
+    dateline: "SANDBOX",
+    image: {
+      src: "/papyrus-plant-placeholder.png",
+      themeVariants: {
+        dark: {
+          src: "/papyrus-plant-placeholder-dark.png",
+        },
+      },
+      alt: "Anthus Threat Intelligence emblem",
+      credit: "",
+      layout: {
+        minHeight: 120,
+        preferredHeight: 320,
+        maxHeight: 440,
+        aspectRatio: 0.785,
+        crop: "contain",
+        wrapsText: true,
+        inlineFloat: {
+          minColumnCount: 4,
+          columnSpan: 1,
+          widthRatio: 0.42,
+          narrowWidthRatio: 0.34,
+          maxWidthRatio: 0.42,
+          minWidth: 72,
+        },
+      },
+    },
+    body: [
+      `${SITE_BRAND.articleTitleSuffix} helps a publication do what good journalism promises: establish the facts, add context, identify trends, and turn scattered information into something readers can understand.`,
+      "Instead of starting with a blank article form, you start by steering the newsroom. You define the mission, set editorial policies, choose sections and topics, and tell research agents what questions or trends deserve attention.",
+      "As the system finds source material, you curate what it learns. You rate and vote on references, comment on whether they are relevant or reliable, and help the knowledge base decide what should inform future coverage.",
+      "Editor agents use that guidance to plan coverage and create assignments. Reporter agents gather context, copywriting agents draft stories, and layout agents assemble editions for human proofing and approval.",
+      "You can steer lightly, give explicit research or writing assignments, or write directly when a piece needs a human voice. If you take your hands off the wheel, the newsroom keeps moving in the direction set by its mission, policies, and curated knowledge.",
+      "This is the default placeholder for a fresh installation. Once an edition is published, this front page will become the publication itself.",
+    ],
+  };
+}
+
+function createPlaceholderSectionItems(sections: PublicPlaceholderSection[]): PublicationItem[] {
+  return sections.map((section) => ({
+    type: "sectionHeader",
+    slug: `empty-edition-section-${section.id}`,
+    section: section.type === "canonical" ? "Canonical Section" : "Rotating Section",
+    title: section.title,
+    deck: section.shortTitle,
+    metadata: {
+      placeholderKind: "section",
+      placeholderGroup: section.type === "canonical" ? "canonical" : "rotating",
+      placeholderType: section.type === "canonical" ? "canonical" : "rotating",
+    },
+  }));
+}
+
+function createPlaceholderTopicItems(topics: PublicPlaceholderTopic[]): PublicationItem[] {
+  return topics.map((topic) => ({
+    type: "sectionHeader",
+    slug: `empty-edition-topic-${topic.key}`,
+    section: "Inferred Topic",
+    title: topic.title,
+    deck: topic.shortTitle,
+    body: [topic.description],
+    metadata: {
+      placeholderKind: "topic",
+      placeholderGroup: "topics",
+    },
+  }));
+}
+
+function createPlaceholderCtaItem({
+  slug,
+  title,
+  deck,
+  href,
+  group,
+  ctaLabel,
+}: {
+  slug: string;
+  title: string;
+  deck: string;
+  href: string;
+  group: string;
+  ctaLabel: string;
+}): PublicationItem {
+  return {
+    type: "promo",
+    slug,
+    section: "Newsroom",
+    title,
+    deck,
+    href,
+    metadata: {
+      placeholderKind: "cta",
+      placeholderGroup: group,
+      ctaLabel,
+    },
+  };
+}
+
+function isMissingGraphQLEditionError(error: unknown): boolean {
+  return error instanceof Error && error.message.includes("No published GraphQL edition found");
+}
+
+function isMissingReaderBackendError(error: unknown): boolean {
+  return (
+    isMissingGraphQLEditionError(error)
+    || (error instanceof Error && error.message.includes("missing projection model"))
+  );
+}
+
+function hasOAuthRedirectParams(searchParams: Awaited<HomePageProps["searchParams"]>): boolean {
+  return hasParam(searchParams?.error) || (hasParam(searchParams?.code) && hasParam(searchParams?.state));
+}
+
+function hasParam(value: string | string[] | null | undefined): boolean {
+  if (Array.isArray(value)) return value.some(Boolean);
+  return Boolean(value);
+}