@anthusai/papyrus 1.0.0-next.2 → 1.0.0-next.21

package/lib/edition-routes.ts

@@ -1,3 +1,5 @@
+import { getReaderBasePath, toPublicReaderPath } from "./reader-base-path";
+
 const MONTH_NAMES = [
   "january",
   "february",
@@ -39,52 +41,52 @@ type ParsedEditionSectionRoute = ParsedEditionDateRoute & {
 
 const RESERVED_DATE_CHILD_SEGMENTS = new Set(["page", "section"]);
 
-export function getEditionDatePath(editionDate: string): string {
+export function getEditionDatePath(editionDate: string, readerBasePath: string = getReaderBasePath()): string {
   const match = editionDate.match(/^(\d{4})-(\d{2})-(\d{2})$/);
-  if (!match) return "/";
+  if (!match) return toPublicReaderPath("/", readerBasePath);
 
   const monthIndex = Number(match[2]) - 1;
   const monthName = MONTH_NAMES[monthIndex];
-  if (!monthName) return "/";
+  if (!monthName) return toPublicReaderPath("/", readerBasePath);
 
-  return `/${match[1]}/${monthName}/${match[3]}`;
+  return toPublicReaderPath(`/${match[1]}/${monthName}/${match[3]}`, readerBasePath);
 }
 
-export function getEditionPagePath(editionDate: string, pageNumber: number): string {
-  const basePath = getEditionDatePath(editionDate);
+export function getEditionPagePath(editionDate: string, pageNumber: number, readerBasePath: string = getReaderBasePath()): string {
+  const basePath = getEditionDatePath(editionDate, readerBasePath);
   return pageNumber <= 1 ? basePath : `${basePath}/page/${pageNumber}`;
 }
 
-export function getEditionSectionPath(editionDate: string, sectionKey: string): string {
-  return `${getEditionDatePath(editionDate)}/section/${encodeURIComponent(sectionKey)}`;
+export function getEditionSectionPath(editionDate: string, sectionKey: string, readerBasePath: string = getReaderBasePath()): string {
+  return `${getEditionDatePath(editionDate, readerBasePath)}/section/${encodeURIComponent(sectionKey)}`;
 }
 
-export function getEditionArticlePath(editionDate: string, articleSlug: string): string {
-  return `${getEditionDatePath(editionDate)}/${encodeURIComponent(articleSlug)}`;
+export function getEditionArticlePath(editionDate: string, articleSlug: string, readerBasePath: string = getReaderBasePath()): string {
+  return `${getEditionDatePath(editionDate, readerBasePath)}/${encodeURIComponent(articleSlug)}`;
 }
 
 export const getEditionItemPath = getEditionArticlePath;
 
-export function parseEditionDateRoute(input: EditionDateRouteInput): ParsedEditionDateRoute | null {
-  const parsed = parseEditionDateSegments(input);
+export function parseEditionDateRoute(input: EditionDateRouteInput, readerBasePath: string = getReaderBasePath()): ParsedEditionDateRoute | null {
+  const parsed = parseEditionDateSegments(input, readerBasePath);
   if (!parsed) return null;
 
   return {
     ...parsed,
-    isCanonical: getCurrentDatePath(input) === parsed.canonicalPath,
+    isCanonical: getCurrentDatePath(input, readerBasePath) === parsed.canonicalPath,
   };
 }
 
-export function parseEditionPageRoute(input: EditionDateRouteInput & { pageNumber: string }): ParsedEditionPageRoute | null {
-  const parsed = parseEditionDateSegments(input);
+export function parseEditionPageRoute(input: EditionDateRouteInput & { pageNumber: string }, readerBasePath: string = getReaderBasePath()): ParsedEditionPageRoute | null {
+  const parsed = parseEditionDateSegments(input, readerBasePath);
   if (!parsed) return null;
   if (!/^\d+$/.test(input.pageNumber)) return null;
 
   const pageNumber = Number(input.pageNumber);
   if (!Number.isSafeInteger(pageNumber) || pageNumber < 1) return null;
 
-  const canonicalPath = getEditionPagePath(parsed.editionDate, pageNumber);
-  const currentPath = `${getCurrentDatePath(input)}/page/${input.pageNumber}`;
+  const canonicalPath = getEditionPagePath(parsed.editionDate, pageNumber, readerBasePath);
+  const currentPath = `${getCurrentDatePath(input, readerBasePath)}/page/${input.pageNumber}`;
   return {
     editionDate: parsed.editionDate,
     canonicalPath,
@@ -93,13 +95,13 @@ export function parseEditionPageRoute(input: EditionDateRouteInput & { pageNumbe
   };
 }
 
-export function parseEditionArticleRoute(input: EditionDateRouteInput & { articleSlug: string }): ParsedEditionArticleRoute | null {
-  const parsed = parseEditionDateSegments(input);
+export function parseEditionArticleRoute(input: EditionDateRouteInput & { articleSlug: string }, readerBasePath: string = getReaderBasePath()): ParsedEditionArticleRoute | null {
+  const parsed = parseEditionDateSegments(input, readerBasePath);
   if (!parsed) return null;
   if (RESERVED_DATE_CHILD_SEGMENTS.has(input.articleSlug.toLowerCase())) return null;
 
-  const canonicalPath = getEditionArticlePath(parsed.editionDate, input.articleSlug);
-  const currentPath = `${getCurrentDatePath(input)}/${input.articleSlug}`;
+  const canonicalPath = getEditionArticlePath(parsed.editionDate, input.articleSlug, readerBasePath);
+  const currentPath = `${getCurrentDatePath(input, readerBasePath)}/${input.articleSlug}`;
   return {
     editionDate: parsed.editionDate,
     canonicalPath,
@@ -108,13 +110,13 @@ export function parseEditionArticleRoute(input: EditionDateRouteInput & { articl
   };
 }
 
-export function parseEditionSectionRoute(input: EditionDateRouteInput & { sectionKey: string }): ParsedEditionSectionRoute | null {
-  const parsed = parseEditionDateSegments(input);
+export function parseEditionSectionRoute(input: EditionDateRouteInput & { sectionKey: string }, readerBasePath: string = getReaderBasePath()): ParsedEditionSectionRoute | null {
+  const parsed = parseEditionDateSegments(input, readerBasePath);
   if (!parsed) return null;
   if (!input.sectionKey.trim()) return null;
 
-  const canonicalPath = getEditionSectionPath(parsed.editionDate, input.sectionKey);
-  const currentPath = `${getCurrentDatePath(input)}/section/${input.sectionKey}`;
+  const canonicalPath = getEditionSectionPath(parsed.editionDate, input.sectionKey, readerBasePath);
+  const currentPath = `${getCurrentDatePath(input, readerBasePath)}/section/${input.sectionKey}`;
   return {
     editionDate: parsed.editionDate,
     canonicalPath,
@@ -123,7 +125,7 @@ export function parseEditionSectionRoute(input: EditionDateRouteInput & { sectio
   };
 }
 
-function parseEditionDateSegments(input: EditionDateRouteInput): Omit<ParsedEditionDateRoute, "isCanonical"> | null {
+function parseEditionDateSegments(input: EditionDateRouteInput, readerBasePath: string): Omit<ParsedEditionDateRoute, "isCanonical"> | null {
   if (!/^\d{4}$/.test(input.year)) return null;
 
   const monthIndex = MONTH_NAMES.indexOf(input.month.toLowerCase() as (typeof MONTH_NAMES)[number]);
@@ -140,12 +142,12 @@ function parseEditionDateSegments(input: EditionDateRouteInput): Omit<ParsedEdit
 
   return {
     editionDate,
-    canonicalPath: getEditionDatePath(editionDate),
+    canonicalPath: getEditionDatePath(editionDate, readerBasePath),
   };
 }
 
-function getCurrentDatePath(input: EditionDateRouteInput): string {
-  return `/${input.year}/${input.month}/${input.day}`;
+function getCurrentDatePath(input: EditionDateRouteInput, readerBasePath: string): string {
+  return toPublicReaderPath(`/${input.year}/${input.month}/${input.day}`, readerBasePath);
 }
 
 function isValidIsoDate(editionDate: string): boolean {

package/lib/empty-theme.css

@@ -0,0 +1 @@
+/* Default for `papyrus-site-theme` when a publication ships no publication/theme.css. */

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,11 +18,15 @@ 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 { getContentSource } from "./site-env";
 
-const AUTH_MODE = "identityPool";
 const DEFAULT_EDITION_SLUG = "current";
 const PUBLISHED_STATUS = "published";
-const ARTICLE_TYPE_STATUS = "article#published";
+const DRAFT_STATUS = "draft";
+const ARTICLE_TYPE = "article";
 
 type DataClient = ReturnType<typeof generateClient<Schema>>;
 type EditionPublishedAtIndexQuery = (
@@ -64,8 +69,6 @@ type GraphQLEditionItem = {
 
 type GraphQLItem = {
   id: string;
-  sourceItemId?: string | null;
-  itemLineageId?: string | null;
   versionNumber?: number | null;
   type: string;
   status: string;
@@ -133,19 +136,38 @@ const IMAGE_ROLES: NonNullable<ArticleImageAsset["roles"]> = [
 let readerContextClient: DataClient | null = null;
 let buildTimeClient: DataClient | null = null;
 
+function authMode(): "userPool" | "identityPool" {
+  return currentContentSource() === "drafts" ? "userPool" : "identityPool";
+}
+
+function isVisibleItemStatus(status: string): boolean {
+  if (status === PUBLISHED_STATUS) return true;
+  return currentContentSource() === "drafts" && status === DRAFT_STATUS;
+}
+
 async function withReaderGraphQLContext<T>(operation: () => Promise<T>): Promise<T> {
-  const { runWithAmplifyServerContext } = getAmplifyServerRuntime();
-  return runWithAmplifyServerContext({
-    nextServerContext: null,
-    operation: async () => {
-      readerContextClient = generateClient<Schema>({ authMode: AUTH_MODE });
-      try {
-        return await operation();
-      } finally {
-        readerContextClient = null;
-      }
-    },
-  });
+  const { runWithAmplifyServerContext, 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");
+    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;
+        }
+      },
+    }),
+  );
 }
 
 export const graphqlContentRepository: ContentRepository = {
@@ -200,7 +222,7 @@ export const graphqlContentRepository: ContentRepository = {
   getArticle(slug) {
     return withReaderGraphQLContext(async () => {
       const item = await getItemBySlug(slug);
-      if (!item || item.type !== "article" || item.status !== "published") return undefined;
+      if (!item || item.type !== ARTICLE_TYPE || !isVisibleItemStatus(item.status)) return undefined;
       return normalizeArticle(item, await listMediaAssets(item.id));
     });
   },
@@ -216,11 +238,15 @@ 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_STATUS);
+      const items = await listItemsByTypeStatus(`${ARTICLE_TYPE}#${PUBLISHED_STATUS}`);
       return items
-        .filter((item) => item.type === "article" && item.status === "published")
+        .filter((item) => item.type === ARTICLE_TYPE && isVisibleItemStatus(item.status))
         .map((item) => item.slug)
         .sort();
     });
@@ -228,11 +254,13 @@ export const graphqlContentRepository: ContentRepository = {
 };
 
 function getClient(): DataClient {
+  const requestClient = currentRequestClient<DataClient>();
+  if (requestClient) return requestClient;
   if (readerContextClient) return readerContextClient;
 
   if (!buildTimeClient) {
     getAmplifyServerRuntime();
-    buildTimeClient = generateClient<Schema>({ authMode: AUTH_MODE });
+    buildTimeClient = generateClient<Schema>({ authMode: authMode() });
   }
   return buildTimeClient;
 }
@@ -331,7 +359,7 @@ async function loadEditionContentFromEdition(edition: GraphQLEdition): Promise<E
     await Promise.all(
       editionItems.map(async (editionItem) => {
         const item = await getItemById(editionItem.publishedItemId);
-        if (!item || item.status !== PUBLISHED_STATUS) return null;
+        if (!item || !isVisibleItemStatus(item.status)) return null;
         return normalizePublicationItem(item, await listMediaAssets(item.id));
       }),
     )
@@ -344,7 +372,7 @@ async function loadEditionContentFromEdition(edition: GraphQLEdition): Promise<E
       await Promise.all(
         missingLayoutItems.map(async (itemId) => {
           const item = await getItemBySlug(itemId);
-          if (!item || item.status !== PUBLISHED_STATUS) return null;
+          if (!item || !isVisibleItemStatus(item.status)) return null;
           return normalizePublicationItem(item, await listMediaAssets(item.id));
         }),
       )
@@ -357,6 +385,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",
@@ -367,10 +398,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>;
@@ -461,7 +520,7 @@ async function loadEditionItem(editionDate: string, itemSlug: string): Promise<P
   const editionItems = await listEditionItems(edition.id);
   for (const editionItem of editionItems) {
     const item = await getItemById(editionItem.publishedItemId);
-    if (!item || item.slug !== itemSlug || item.status !== PUBLISHED_STATUS) continue;
+    if (!item || item.slug !== itemSlug || !isVisibleItemStatus(item.status)) continue;
     return (await normalizePublicationItem(item, await listMediaAssets(item.id))) ?? undefined;
   }
   return undefined;
@@ -505,36 +564,168 @@ function isMissingReaderBackendError(error: unknown): boolean {
 }
 
 function getEditionPublishedAtIndexQuery(): EditionPublishedAtIndexQuery | null {
-  const editionModel = getPublishedEditionModel() as unknown as {
-    listPublishedEditionsByStatusAndPublishedAt?: EditionPublishedAtIndexQuery;
-  };
+  const editionModel = getPublishedEditionModel();
   return typeof editionModel.listPublishedEditionsByStatusAndPublishedAt === "function"
     ? editionModel.listPublishedEditionsByStatusAndPublishedAt
     : null;
 }
 
-function getPublishedEditionModel() {
+type ListOptions = Record<string, unknown>;
+type ListResponse<T> = Promise<GraphQLListResponse<T>>;
+
+type EditionSourceModel = {
+  publishedEditionBySlug: (input: { slug: string }, options: ListOptions) => ListResponse<GraphQLEdition>;
+  listPublishedEditionsByStatusAndEditionDate: (
+    input: { status: string; editionDate?: { eq: string } },
+    options: ListOptions,
+  ) => ListResponse<GraphQLEdition>;
+  listPublishedEditionsByStatusAndPublishedAt?: EditionPublishedAtIndexQuery;
+};
+
+type EditionItemSourceModel = {
+  listPublishedEditionItemsByEditionAndSortKey: (
+    input: { publishedEditionId: string },
+    options: ListOptions,
+  ) => ListResponse<GraphQLEditionItem>;
+};
+
+type ItemSourceModel = {
+  get: (input: { id: string }, options: ListOptions) => Promise<GraphQLGetResponse<GraphQLItem>>;
+  publishedItemBySlug: (input: { slug: string }, options: ListOptions) => ListResponse<GraphQLItem>;
+  listPublishedItemsByTypeStatusAndPublishedAt: (input: { typeStatus: string }, options: ListOptions) => ListResponse<GraphQLItem>;
+};
+
+type MediaAssetSourceModel = {
+  listPublishedMediaAssetsByItemAndSortKey: (
+    input: { publishedItemId: string },
+    options: ListOptions,
+  ) => ListResponse<GraphQLMediaAsset>;
+};
+
+const DRAFTS_EDITION_STATUSES = [PUBLISHED_STATUS, DRAFT_STATUS];
+
+async function listMergedAcrossStatuses<T>(
+  statuses: string[],
+  runForStatus: (status: string, pageOptions: ListOptions) => ListResponse<T>,
+  sortValue: (row: T) => string,
+  options: ListOptions,
+): ListResponse<T> {
+  const rows: T[] = [];
+  for (const status of statuses) {
+    let pageToken: string | null | undefined;
+    do {
+      const response = await runForStatus(status, { authMode: options.authMode, limit: 100, nextToken: pageToken });
+      if (response.errors?.length) return { data: [], errors: response.errors };
+      rows.push(...((response.data ?? []).filter(Boolean) as T[]));
+      pageToken = response.nextToken;
+    } while (pageToken);
+  }
+  const direction = options.sortDirection === "DESC" ? -1 : 1;
+  rows.sort((left, right) => direction * sortValue(left).localeCompare(sortValue(right)));
+  const offset = Number(options.nextToken ?? 0) || 0;
+  const limit = typeof options.limit === "number" ? options.limit : undefined;
+  const end = limit === undefined ? rows.length : offset + limit;
+  return {
+    data: rows.slice(offset, end),
+    nextToken: end < rows.length ? String(end) : undefined,
+  };
+}
+
+function getPublishedEditionModel(): EditionSourceModel {
+  if (currentContentSource() === "drafts") {
+    const model = getClient().models.Edition;
+    if (!model) throw missingProjectionModelError("Edition");
+    return {
+      publishedEditionBySlug: (input, options) => model.editionBySlug(input, options) as ListResponse<GraphQLEdition>,
+      listPublishedEditionsByStatusAndEditionDate: (input, options) =>
+        listMergedAcrossStatuses<GraphQLEdition>(
+          DRAFTS_EDITION_STATUSES,
+          (status, pageOptions) =>
+            model.listEditionsByStatusAndEditionDate({ ...input, status }, pageOptions) as ListResponse<GraphQLEdition>,
+          (edition) => edition.editionDate,
+          options,
+        ),
+    };
+  }
   const model = getClient().models.PublishedEdition;
   if (!model) throw missingProjectionModelError("PublishedEdition");
-  return model;
+  return model as unknown as EditionSourceModel;
 }
 
-function getPublishedEditionItemModel() {
+function getPublishedEditionItemModel(): EditionItemSourceModel {
+  if (currentContentSource() === "drafts") {
+    const model = getClient().models.EditionItem;
+    if (!model) throw missingProjectionModelError("EditionItem");
+    return {
+      listPublishedEditionItemsByEditionAndSortKey: async ({ publishedEditionId }, options) => {
+        const response = (await model.listEditionItemsByEditionAndSortKey(
+          { editionId: publishedEditionId },
+          options,
+        )) as unknown as GraphQLListResponse<{ id: string; editionId: string; itemId: string; sortKey: string }>;
+        return {
+          ...response,
+          data: (response.data ?? []).filter(Boolean).map((row) => ({
+            id: row.id,
+            publishedEditionId: row.editionId,
+            publishedItemId: row.itemId,
+            sortKey: row.sortKey,
+          })),
+        };
+      },
+    };
+  }
   const model = getClient().models.PublishedEditionItem;
   if (!model) throw missingProjectionModelError("PublishedEditionItem");
-  return model;
+  return model as unknown as EditionItemSourceModel;
 }
 
-function getPublishedItemModel() {
+function getPublishedItemModel(): ItemSourceModel {
+  if (currentContentSource() === "drafts") {
+    const model = getClient().models.Item;
+    if (!model) throw missingProjectionModelError("Item");
+    return {
+      get: (input, options) => model.get(input, options) as Promise<GraphQLGetResponse<GraphQLItem>>,
+      publishedItemBySlug: (input, options) => model.itemBySlug(input, options) as ListResponse<GraphQLItem>,
+      listPublishedItemsByTypeStatusAndPublishedAt: ({ typeStatus }, options) => {
+        const itemType = typeStatus.split("#")[0];
+        return listMergedAcrossStatuses<GraphQLItem>(
+          [DRAFT_STATUS, PUBLISHED_STATUS],
+          (status, pageOptions) =>
+            model.listItemsByTypeStatusAndPublishedAt(
+              { typeStatus: `${itemType}#${status}` },
+              pageOptions,
+            ) as ListResponse<GraphQLItem>,
+          (item) => item.publishedAt ?? "",
+          options,
+        );
+      },
+    };
+  }
   const model = getClient().models.PublishedItem;
   if (!model) throw missingProjectionModelError("PublishedItem");
-  return model;
+  return model as unknown as ItemSourceModel;
 }
 
-function getPublishedMediaAssetModel() {
+function getPublishedMediaAssetModel(): MediaAssetSourceModel {
+  if (currentContentSource() === "drafts") {
+    const model = getClient().models.MediaAsset;
+    if (!model) throw missingProjectionModelError("MediaAsset");
+    return {
+      listPublishedMediaAssetsByItemAndSortKey: async ({ publishedItemId }, options) => {
+        const response = (await model.listMediaAssetsByItemAndSortKey(
+          { itemId: publishedItemId },
+          options,
+        )) as unknown as GraphQLListResponse<Omit<GraphQLMediaAsset, "publishedItemId"> & { itemId: string }>;
+        return {
+          ...response,
+          data: (response.data ?? []).filter(Boolean).map((row) => ({ ...row, publishedItemId: row.itemId })),
+        };
+      },
+    };
+  }
   const model = getClient().models.PublishedMediaAsset;
   if (!model) throw missingProjectionModelError("PublishedMediaAsset");
-  return model;
+  return model as unknown as MediaAssetSourceModel;
 }
 
 function missingProjectionModelError(modelName: string): Error {
@@ -561,7 +752,7 @@ async function listItemsByTypeStatus(typeStatus: string): Promise<GraphQLItem[]>
 }
 
 async function getItemById(id: string): Promise<GraphQLItem | null> {
-  const response = await getPublishedItemModel().get({ id }, { authMode: AUTH_MODE });
+  const response = await getPublishedItemModel().get({ id }, { authMode: authMode() });
   return readGetResponse<GraphQLItem>(response);
 }
 
@@ -583,7 +774,7 @@ async function listAll<T>(operation: (options: Record<string, unknown>) => Promi
 
   do {
     const response = await operation({
-      authMode: AUTH_MODE,
+      authMode: authMode(),
       limit: 100,
       nextToken,
     });
@@ -597,7 +788,7 @@ async function listAll<T>(operation: (options: Record<string, unknown>) => Promi
 
 async function listFirst<T>(operation: (options: Record<string, unknown>) => Promise<GraphQLListResponse<T>>): Promise<T[]> {
   const response = await operation({
-    authMode: AUTH_MODE,
+    authMode: authMode(),
     limit: 1,
     sortDirection: "DESC",
   });
@@ -611,7 +802,7 @@ async function listPage<T>(
   nextToken?: string | null,
 ): Promise<{ editions: T[]; nextToken?: string | null }> {
   const response = await operation({
-    authMode: AUTH_MODE,
+    authMode: authMode(),
     limit,
     nextToken,
     sortDirection: "DESC",
@@ -663,7 +854,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);
 }
@@ -785,15 +976,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/layout-scenarios.ts

@@ -5,7 +5,6 @@ import { createDefaultEditionLayoutPlan, type EditionLayoutPlan } from "./layout
 import { articleToPublicationItem, cloneArticle } from "./publication-items";
 import { PILOBOL_SAMPLE_SCENARIO_ID, createPilobolSampleEditionContent } from "./pilobol-sample";
 import { SITE_BRAND } from "./site-brand";
-import threatIntelligenceSeedContent from "../publications/threat_intelligence/seed/seed-edition-content.json";
 
 export type LayoutScenario = EditionContent & {
   source: "scenario";
@@ -190,7 +189,8 @@ function getDefaultScenarioSeed(): {
   editionVideo?: ArticleVideoAsset;
   newsDeskAppendix?: NewsDeskAppendix | null;
 } {
-  if (SITE_BRAND.id !== "threat-intelligence") {
+  const demoEdition = SITE_BRAND.demoEdition;
+  if (!demoEdition) {
     return {
       title: "Current Edition",
       editionDate,
@@ -201,12 +201,12 @@ function getDefaultScenarioSeed(): {
   }
 
   return {
-    title: threatIntelligenceSeedContent.title,
-    editionDate: threatIntelligenceSeedContent.publishDate,
-    description: threatIntelligenceSeedContent.description,
-    articles: threatIntelligenceSeedContent.articles as Article[],
-    suppressNewsDeskAppendix: threatIntelligenceSeedContent.suppressNewsDeskAppendix === true,
-    editionVideo: threatIntelligenceSeedContent.video as ArticleVideoAsset | undefined,
+    title: demoEdition.title,
+    editionDate: demoEdition.editionDate,
+    description: demoEdition.description,
+    articles: demoEdition.articles,
+    suppressNewsDeskAppendix: demoEdition.suppressNewsDeskAppendix === true,
+    editionVideo: demoEdition.editionVideo,
     newsDeskAppendix: null,
   };
 }

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);