@anthusai/papyrus 1.0.0-next.9 → 1.1.0

package/lib/graphql-content-repository.ts

@@ -3,7 +3,7 @@ import { generateClient } from "aws-amplify/data";
 import type { Schema } from "../amplify/data/resource";
 import type { Article, ArticleImage, ArticleImageAsset, ArticleImageLayout, ArticleImageThemeVariants, ArticleVideoAsset, ArticleVideoThemeVariants } from "./articles";
 import { withContentLoadTiming } from "./content-load-timing";
-import { getAmplifyServerRuntime } from "./amplify-server-runtime";
+import { getAmplifyServerRuntime, runWithGuestAmplifyContext } from "./amplify-server-runtime";
 import { resolveReaderStorageUrl, signStorageUrl } from "./reader-storage-url";
 import type { ContentRepository, EditionContent, EditionRouteSummary, ListPublishedEditionsOptions, LoadEditionContentOptions } from "./content-types";
 import { isDemoAmplifyOutputs } from "./demo-amplify-outputs";
@@ -18,7 +18,10 @@ import {
 } from "./publication-items";
 import { BodyIrError, matchBodyImages, projectBodyIr, type BodyProjection, type BodyProjectionImage } from "./markus-body";
 import { SITE_BRAND } from "./site-brand";
+import { shouldFetchVideoScripts } from "./video-mode";
+import { collectVideoScriptTargets, parseVideoScriptRef, videomlItemSlug, type VideoScriptRef } from "./video-script";
 import { currentContentSource, currentRequestClient, runWithContentSource } from "./content-source-context";
+import { withRateLimitRetry } from "./rate-limit-retry";
 import { getContentSource } from "./site-env";
 
 const DEFAULT_EDITION_SLUG = "current";
@@ -131,10 +134,9 @@ const IMAGE_ROLES: NonNullable<ArticleImageAsset["roles"]> = [
   "thumbnail",
 ];
 
-let readerContextClient: DataClient | null = null;
 let buildTimeClient: DataClient | null = null;
 
-function authMode(): "userPool" | "identityPool" {
+export function authMode(): "userPool" | "identityPool" {
   return currentContentSource() === "drafts" ? "userPool" : "identityPool";
 }
 
@@ -144,27 +146,20 @@ function isVisibleItemStatus(status: string): boolean {
 }
 
 async function withReaderGraphQLContext<T>(operation: () => Promise<T>): Promise<T> {
-  const { runWithAmplifyServerContext, config } = getAmplifyServerRuntime();
+  const { config } = getAmplifyServerRuntime();
   const source = getContentSource();
   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: null,
-      operation: async () => {
-        readerContextClient = generateClient<Schema>({ authMode: authMode() });
-        try {
-          return await operation();
-        } finally {
-          readerContextClient = null;
-        }
-      },
-    }),
+  return withRateLimitRetry(() =>
+    runWithGuestAmplifyContext(() =>
+      runWithContentSource(source, operation, generateClient<Schema>({ authMode: authMode() })),
+    ),
   );
 }
 
@@ -236,6 +231,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}`);
@@ -250,7 +249,6 @@ export const graphqlContentRepository: ContentRepository = {
 function getClient(): DataClient {
   const requestClient = currentRequestClient<DataClient>();
   if (requestClient) return requestClient;
-  if (readerContextClient) return readerContextClient;
 
   if (!buildTimeClient) {
     getAmplifyServerRuntime();
@@ -379,6 +377,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",
@@ -389,10 +390,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>;
@@ -817,7 +846,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);
 }
@@ -939,15 +968,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-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-board.ts

@@ -0,0 +1,99 @@
+import type { KanbanConfig, KanbanIssue } from "@kanbus/ui";
+import type { AssignmentRecord, ReferenceRecord } from "./category-repository";
+import {
+  CONTENT_ITEM_STAGES,
+  contentItemStageLabel,
+  latestVersionPerContentItem,
+  type ContentItemVersionRecord,
+} from "./content-item-lifecycle";
+import { getContentItemName } from "./site-brand";
+
+export type NativeBoardKind = "contentItem" | "reference" | "assignment";
+export interface NativeBoardIssue extends KanbanIssue {
+  kind: NativeBoardKind;
+  nativeId: string;
+  nativeStatus: string;
+  href: string;
+}
+
+export function contentItemBoardType(): string {
+  return getContentItemName().singular.toLowerCase();
+}
+
+function boardTypeForKind(kind: NativeBoardKind): string {
+  return kind === "contentItem" ? contentItemBoardType() : kind;
+}
+
+/**
+ * One card per content item, in the column for its lifecycle stage. Assignments that are work on a content item
+ * are counted on that item's card rather than shown as separate cards. References and other work keep their own
+ * identity and native status.
+ */
+export function projectNewsroomBoard(records: {
+  contentItemVersions?: readonly ContentItemVersionRecord[];
+  references?: readonly ReferenceRecord[];
+  assignments?: readonly AssignmentRecord[];
+}): NativeBoardIssue[] {
+  const assignmentCountByContentItem = new Map<string, number>();
+  for (const assignment of records.assignments ?? []) {
+    if (assignment.itemLineageId) {
+      assignmentCountByContentItem.set(assignment.itemLineageId, (assignmentCountByContentItem.get(assignment.itemLineageId) ?? 0) + 1);
+    }
+  }
+  const contentItemType = contentItemBoardType();
+  return [
+    ...latestVersionPerContentItem(records.contentItemVersions ?? []).map(version => {
+      const stage = version.stage ?? "idea";
+      const workCount = assignmentCountByContentItem.get(version.lineageId) ?? 0;
+      return {
+        id: `contentItem:${version.lineageId}`, nativeId: version.lineageId, kind: "contentItem" as const, type: contentItemType,
+        title: version.headline || version.title || version.slug, nativeStatus: stage, status: `${contentItemType}/${stage}`,
+        priority: 2, description: workCount ? `${workCount} assignment${workCount === 1 ? "" : "s"} on this ${contentItemType}.` : undefined,
+        updated_at: version.updatedAt ?? undefined, href: `/newsroom/articles/${encodeURIComponent(version.id)}`,
+      };
+    }),
+    ...(records.references ?? []).filter(row => !row.versionState || row.versionState === "current").map(row => ({
+      id: `reference:${row.id}`, nativeId: row.id, kind: "reference" as const, type: "reference",
+      title: row.title || row.externalItemId || row.id,
+      nativeStatus: row.curationStatus || "pending", status: `reference/${row.curationStatus || "pending"}`,
+      priority: 2, description: row.curationStatusReason || undefined,
+      updated_at: row.updatedAt || row.importedAt || undefined,
+      href: `/newsroom/references/${encodeURIComponent(row.lineageId || row.id)}`,
+    })),
+    ...(records.assignments ?? []).filter(row => !row.itemLineageId).map(row => ({
+      id: `assignment:${row.id}`, nativeId: row.id, kind: "assignment" as const, type: "assignment",
+      title: row.title, nativeStatus: row.status, status: `assignment/${row.status}`,
+      priority: row.priority ?? 2, assignee: row.assigneeId || undefined,
+      description: row.summary || row.brief || undefined,
+      created_at: row.createdAt, updated_at: row.updatedAt,
+      href: `/newsroom/assignments/${encodeURIComponent(row.id)}`,
+    })),
+  ];
+}
+
+/** Content items always show every lifecycle stage in order; unknown native statuses of other records stay visible. */
+export function newsroomBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConfig {
+  const contentItemType = contentItemBoardType();
+  const kinds: NativeBoardKind[] = ["contentItem", "reference", "assignment"];
+  const contentItemStatuses = [
+    ...CONTENT_ITEM_STAGES,
+    ...new Set(issues.filter(issue => issue.kind === "contentItem").map(issue => issue.nativeStatus)),
+  ].filter((stage, index, stages) => stages.indexOf(stage) === index)
+    .map(stage => ({ key: `${contentItemType}/${stage}`, name: contentItemStageLabel(stage), category: "native" }));
+  const otherStatuses = [...new Set(issues.filter(issue => issue.kind !== "contentItem").map(issue => issue.status))]
+    .map(key => ({ key, name: key.replace("/", " · "), category: "native" }));
+  const statuses = [...contentItemStatuses, ...otherStatuses];
+  return {
+    hierarchy: [], types: kinds.map(boardTypeForKind),
+    statuses,
+    categories: [{ name: "native" }], priorities: {}, type_colors: {},
+    workflows: Object.fromEntries(kinds.map(kind => {
+      const type = boardTypeForKind(kind);
+      return [type, Object.fromEntries(statuses.filter(status => status.key.startsWith(`${type}/`)).map(status => [status.key, []]))];
+    })),
+  };
+}
+
+export function canReadNewsroomBoard(phase: string | undefined): boolean {
+  return phase === "ready";
+}

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-forum-routes.ts

@@ -1,3 +1,5 @@
+import { toPublicNewsroomPath } from "./newsroom-base-path";
+
 export const FORUM_THREAD_ROUTE_PREFIX = "/newsroom/forum/";
 export const INSIGHT_THREAD_ROUTE_PREFIX = "/newsroom/insights/";
 export const FORUM_MESSAGE_HASH_PREFIX = "message-";
@@ -81,7 +83,7 @@ export function buildForumThreadUrl(
   if (options?.demo) params.set("demo", "1");
   const query = params.toString();
   const hash = options?.messageId ? getForumMessageAnchorId(options.messageId) : "";
-  return `/newsroom/forum/${encodedThreadId}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`;
+  return toPublicNewsroomPath(`/newsroom/forum/${encodedThreadId}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`);
 }
 
 export function buildInsightThreadUrl(
@@ -93,7 +95,7 @@ export function buildInsightThreadUrl(
   if (options?.demo) params.set("demo", "1");
   const query = params.toString();
   const hash = options?.messageId ? getForumMessageAnchorId(options.messageId) : "";
-  return `${INSIGHT_THREAD_ROUTE_PREFIX}${encodedThreadId}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`;
+  return toPublicNewsroomPath(`${INSIGHT_THREAD_ROUTE_PREFIX}${encodedThreadId}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`);
 }
 
 export function buildThreadUrlForSurface(
@@ -141,7 +143,7 @@ export function buildNewsroomForumIndexUrl(demo?: boolean): string {
   const params = new URLSearchParams();
   if (demo) params.set("demo", "1");
   const query = params.toString();
-  return query ? `/newsroom?${query}` : "/newsroom";
+  return toPublicNewsroomPath(query ? `/newsroom?${query}` : "/newsroom");
 }
 
 export function buildNewsroomInsightsIndexUrl(demo?: boolean, domain?: string): string {
@@ -149,5 +151,5 @@ export function buildNewsroomInsightsIndexUrl(demo?: boolean, domain?: string):
   if (demo) params.set("demo", "1");
   if (domain?.trim()) params.set("domain", domain.trim());
   const query = params.toString();
-  return query ? `/newsroom/insights?${query}` : "/newsroom/insights";
+  return toPublicNewsroomPath(query ? `/newsroom/insights?${query}` : "/newsroom/insights");
 }

package/lib/newsroom-index-filters.ts

@@ -1,3 +1,4 @@
+import { browserPathToInternalNewsroomPath, toPublicNewsroomPath } from "./newsroom-base-path";
 export type NewsroomIndexTab = "references" | "messages" | "assignments" | "insights";
 
 export type ReferenceIndexOrder = "published" | "imported";
@@ -147,10 +148,10 @@ export function buildNewsroomIndexWebPath(
   tab: NewsroomIndexTab,
   filters: ReferencesIndexFilters | MessagesIndexFilters | AssignmentsIndexFilters | InsightsIndexFilters,
 ): string {
-  if (tab === "references") return `/newsroom/references${buildReferencesIndexQuery(filters as ReferencesIndexFilters)}`;
-  if (tab === "messages") return `/newsroom/messages${buildMessagesIndexQuery(filters as MessagesIndexFilters)}`;
-  if (tab === "insights") return `/newsroom/insights${buildInsightsIndexQuery(filters as InsightsIndexFilters)}`;
-  return `/newsroom/assignments${buildAssignmentsIndexQuery(filters as AssignmentsIndexFilters)}`;
+  if (tab === "references") return toPublicNewsroomPath(`/newsroom/references${buildReferencesIndexQuery(filters as ReferencesIndexFilters)}`);
+  if (tab === "messages") return toPublicNewsroomPath(`/newsroom/messages${buildMessagesIndexQuery(filters as MessagesIndexFilters)}`);
+  if (tab === "insights") return toPublicNewsroomPath(`/newsroom/insights${buildInsightsIndexQuery(filters as InsightsIndexFilters)}`);
+  return toPublicNewsroomPath(`/newsroom/assignments${buildAssignmentsIndexQuery(filters as AssignmentsIndexFilters)}`);
 }
 
 export function syncBrowserNewsroomIndexUrl(
@@ -168,8 +169,9 @@ export function syncBrowserNewsroomIndexUrl(
 
 /** Lineage id from `/newsroom/references/<id>` (not index-only URLs). */
 export function parseReferenceLineageIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
-  if (!pathname?.startsWith("/newsroom/references/")) return null;
-  const segment = pathname.slice("/newsroom/references/".length).split("/")[0]?.trim() ?? "";
+  const internalPathname = pathname ? browserPathToInternalNewsroomPath(pathname) : null;
+  if (!internalPathname?.startsWith("/newsroom/references/")) return null;
+  const segment = internalPathname.slice("/newsroom/references/".length).split("/")[0]?.trim() ?? "";
   if (!segment) return null;
   try {
     return decodeURIComponent(segment);
@@ -180,8 +182,9 @@ export function parseReferenceLineageIdFromNewsroomPathname(pathname: string | n
 
 /** Assignment id from `/newsroom/assignments/<id>` (not index-only URLs). */
 export function parseAssignmentIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
-  if (!pathname?.startsWith("/newsroom/assignments/")) return null;
-  const segment = pathname.slice("/newsroom/assignments/".length).split("/")[0]?.trim() ?? "";
+  const internalPathname = pathname ? browserPathToInternalNewsroomPath(pathname) : null;
+  if (!internalPathname?.startsWith("/newsroom/assignments/")) return null;
+  const segment = internalPathname.slice("/newsroom/assignments/".length).split("/")[0]?.trim() ?? "";
   if (!segment) return null;
   try {
     return decodeURIComponent(segment);
@@ -191,8 +194,9 @@ export function parseAssignmentIdFromNewsroomPathname(pathname: string | null |
 }
 
 export function parseInsightThreadIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
-  if (!pathname?.startsWith("/newsroom/insights/")) return null;
-  const segment = pathname.slice("/newsroom/insights/".length).split("/")[0]?.trim() ?? "";
+  const internalPathname = pathname ? browserPathToInternalNewsroomPath(pathname) : null;
+  if (!internalPathname?.startsWith("/newsroom/insights/")) return null;
+  const segment = internalPathname.slice("/newsroom/insights/".length).split("/")[0]?.trim() ?? "";
   if (!segment) return null;
   try {
     return decodeURIComponent(segment);

package/lib/newsroom-nav.ts

@@ -1,4 +1,5 @@
 import { newsroomHref, toPublicNewsroomPath } from "./newsroom-base-path";
+import { getContentItemName } from "./site-brand";
 
 export type NewsroomNavTabId =
   | "overview"
@@ -23,13 +24,14 @@ 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: "articles", label: getContentItemName().plural, 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") },
   { id: "insights", label: "Insights", detail: "Research threads", href: newsroomHref("insights") },
   { id: "topics", label: "Topics", detail: "Taxonomy", href: newsroomHref("topics"), mobilePrimary: true },
   { id: "concepts", label: "Concepts", detail: "Ontology", href: newsroomHref("concepts") },
+  { id: "search", label: "Search", detail: "Knowledge base", href: newsroomHref("search") },
   { id: "administration", label: "Administration", detail: "Users & policies", href: newsroomHref("administration") },
 ];
 

package/lib/newsroom-organizer-nav.ts

@@ -0,0 +1,37 @@
+import { getContentItemName } from "./site-brand";
+
+const contentItemPluralLowercase = getContentItemName().plural.toLowerCase();
+export type OrganizerDestination = {
+  key: string; label: string; description: string; path: string;
+  access?: "admin"; primary?: boolean; unavailable?: string;
+};
+export const ORGANIZER_NAV_GROUPS: readonly { title: string; items: readonly OrganizerDestination[] }[] = [
+  { title: "Editorial work", items: [
+    { key: "overview", label: "Overview", description: "See the desk and choose where to begin.", path: "/newsroom", primary: true },
+    { key: "board", label: "Board", description: `Follow ${contentItemPluralLowercase}, sources and assignments across their stages.`, path: "/newsroom/work", primary: true },
+    { key: "articles", label: getContentItemName().plural, description: "Write, revise and prepare copy for publication.", path: "/newsroom/articles" },
+    { key: "assignments", label: "Assignments", description: "Claim work and follow research and reporting progress.", path: "/newsroom/assignments" },
+    { key: "messages", label: "Messages", description: "Read and reply to newsroom conversations.", path: "/newsroom/messages", primary: true },
+    { key: "insights", label: "Insights", description: "Discuss findings and research threads.", path: "/newsroom/insights" },
+  ] },
+  { title: "Research & knowledge", items: [
+    { key: "references", label: "References", description: "Inspect sources and make editorial inclusion decisions.", path: "/newsroom/references", primary: true },
+    { key: "desks", label: "Taxonomy", description: "Maintain topic sets and category versions.", path: "/newsroom/desks" },
+    { key: "topics", label: "Topic proposals", description: "Review suggested changes to coverage.", path: "/newsroom/topics" },
+    { key: "concepts", label: "Concepts", description: "Explore knowledge entities and relationships.", path: "/newsroom/concepts" },
+    { key: "search", label: "Knowledge search", description: "Find evidence across the knowledge base.", path: "/newsroom/search" },
+  ] },
+  { title: "Administration", items: [
+    { key: "policies", label: "Policies", description: "Set publication and category guidance.", path: "/newsroom/administration/policies" },
+    { key: "sections", label: "Sections", description: "Organize the publication’s sections.", path: "/newsroom/administration/sections" },
+    { key: "procedures", label: "Procedures", description: "Manage procedure definitions and versions.", path: "/newsroom/administration/procedures", access: "admin" },
+    { key: "users", label: "Users & identity merging", description: "Review people, roles and identity merges.", path: "/newsroom/administration/users", access: "admin" },
+    { key: "administration", label: "Administration", description: "Open the existing CMS settings workspace.", path: "/newsroom/administration" },
+  ] },
+];
+const all = ORGANIZER_NAV_GROUPS.flatMap(group => group.items);
+export const ORGANIZER_PRIMARY_NAV = ["overview", "board", "references", "messages"].map(key => all.find(item => item.key === key)!);
+
+export const ORGANIZER_SETTINGS_DESTINATION = {
+  label: "Settings", path: "/newsroom/settings", description: "Theme, motion and interface preferences.",
+} as const;

package/lib/newsroom-section-routing.ts

@@ -0,0 +1,20 @@
+import type { NewsDeskTab } from "../components/topic-steering-workspace";
+
+/** The organizer restores the existing taxonomy editor; legacy sites retain their aliases. */
+export function resolveNewsDeskTab(
+  sectionValue: string | string[] | null | undefined,
+  legacyTabValue: string | string[] | null | undefined,
+  organizer = false,
+): NewsDeskTab {
+  const section = Array.isArray(sectionValue) ? sectionValue[0] : sectionValue;
+  const legacyTab = Array.isArray(legacyTabValue) ? legacyTabValue[0] : legacyTabValue;
+  const raw = section ?? (legacyTab === "categories" ? "topics" : legacyTab);
+  const value = raw === "users" || raw === "doctrine" ? "administration"
+    : raw === "desks" && !organizer ? "topics" : raw;
+  switch (value) {
+    case "desks": case "administration": case "topics": case "concepts":
+    case "references": case "insights": case "messages": case "assignments": case "search":
+      return value;
+    default: return "overview";
+  }
+}

package/lib/oauth-redirect-priority.ts

@@ -0,0 +1,40 @@
+function originOf(value: string): string {
+  const trimmed = value.replace(/\/+$/, "");
+  try {
+    const parsed = new URL(trimmed);
+    const hostname = parsed.hostname === "127.0.0.1" || parsed.hostname === "::1" ? "localhost" : parsed.hostname;
+    return `${parsed.protocol}//${hostname}${parsed.port ? `:${parsed.port}` : ""}`;
+  } catch {
+    return trimmed;
+  }
+}
+
+function pathOf(value: string): string | null {
+  try {
+    return new URL(value).pathname.replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Puts the redirect URLs of the current origin first; among those, the
+ * newsroom return path leads when the site has one, so Amplify (which signs in
+ * with the first entry) returns an editor to the newsroom.
+ */
+export function prioritizeRedirectUrlsForOrigin(
+  urls: readonly string[],
+  currentOrigin: string,
+  publicNewsroomBasePath: string,
+): string[] {
+  const origin = originOf(currentOrigin);
+  const newsroomPath = publicNewsroomBasePath.replace(/\/+$/, "");
+  const head = urls.filter((value) => originOf(value) === origin);
+  if (head.length === 0) return [...urls];
+  const tail = urls.filter((value) => originOf(value) !== origin);
+  const newsroomFirst =
+    newsroomPath === ""
+      ? head
+      : [...head.filter((value) => pathOf(value) === newsroomPath), ...head.filter((value) => pathOf(value) !== newsroomPath)];
+  return [...newsroomFirst, ...tail];
+}

package/lib/papyrus-web-locations.ts

@@ -1,3 +1,4 @@
+import { toInternalReaderPath, toPublicReaderPath } from "./reader-base-path";
 import { PAPYRUS_OBJECT_KINDS, type PapyrusObjectKind } from "./papyrus-object-kinds";
 import {
   buildNewsroomIndexWebPath,
@@ -52,7 +53,7 @@ export function buildWebUiContext(webPath: string): PapyrusWebUiContext {
 export function webPathToPapyrusLocation(webPath: string): PapyrusWebUiContext {
   const normalized = normalizeWebPath(webPath);
   const url = new URL(normalized, "https://papyrus.local");
-  const pathname = url.pathname || "/";
+  const pathname = toInternalReaderPath(url.pathname || "/");
 
   if (pathname === "/" || pathname === "") {
     return location("papyrus://site/home", normalized, { label: "Papyrus home" });
@@ -81,7 +82,7 @@ export function webPathToPapyrusLocation(webPath: string): PapyrusWebUiContext {
   }
 
   if (!pathname.startsWith("/newsroom")) {
-    const tail = pathname.replace(/^\/+/, "");
+    const tail = (url.pathname || "/").replace(/^\/+/, "");
     return location(`papyrus://site/path/${encodeURIComponent(tail)}`, normalized, { label: pathname });
   }
 
@@ -215,9 +216,9 @@ export function papyrusUriToWebPath(uri: string): PapyrusUriToWebPathResult {
   const { kind, id } = parsed;
 
   if (kind === "site") {
-    if (id === "home") return { ok: true, papyrusLocationUri: raw, webPath: "/" };
-    if (id === "archive") return { ok: true, papyrusLocationUri: raw, webPath: "/archive" };
-    if (id === "settings") return { ok: true, papyrusLocationUri: raw, webPath: "/settings" };
+    if (id === "home") return { ok: true, papyrusLocationUri: raw, webPath: toPublicReaderPath("/") };
+    if (id === "archive") return { ok: true, papyrusLocationUri: raw, webPath: toPublicReaderPath("/archive") };
+    if (id === "settings") return { ok: true, papyrusLocationUri: raw, webPath: toPublicReaderPath("/settings") };
     if (id.startsWith("path/")) {
       return { ok: true, papyrusLocationUri: raw, webPath: `/${decodeURIComponent(id.slice("path/".length))}` };
     }
@@ -449,7 +450,7 @@ function objectKindToWebPath(kind: PapyrusObjectKind, objectId: string): string
   if (kind === "category") return `/newsroom/topics?category=${encoded}`;
   if (kind === "semanticNode") return `/newsroom/concepts?node=${encoded}`;
   if (kind === "newsroomSection") return `/newsroom/sections/${encoded}`;
-  if (kind === "item") return `/articles/${encoded}`;
+  if (kind === "item") return toPublicReaderPath(`/articles/${encoded}`);
   return `/newsroom?object=${encodeURIComponent(kind)}:${encoded}`;
 }