@anthusai/papyrus 1.0.0-next.9 → 1.1.0

package/lib/brand-fonts.ts

@@ -0,0 +1,112 @@
+export type SiteBrandFontFace = {
+  /** Public URL of the font file, e.g. `/fonts/acme-serif-regular.woff2`. */
+  src: string;
+  weight?: number | string;
+  style?: "normal" | "italic";
+};
+
+export type SiteBrandGoogleFontSource = {
+  weights: number[];
+  /** Also load the italic style of every listed weight. */
+  italics?: boolean;
+};
+
+/**
+ * One brand-declared font family. Declare exactly one source: `google` loads
+ * the family from the Google Fonts stylesheet API; `faces` self-hosts files
+ * with `@font-face`. The root layout exposes `cssVariable` as
+ * `"<family>", <fallback>` on `<html>`, so publication CSS writes
+ * `font-family: var(--font-masthead)`.
+ */
+export type SiteBrandFont = {
+  family: string;
+  cssVariable: string;
+  fallback?: string;
+  google?: SiteBrandGoogleFontSource;
+  faces?: SiteBrandFontFace[];
+};
+
+export type BrandFontAssets = {
+  preconnectOrigins: string[];
+  stylesheetHrefs: string[];
+  fontFaceCss: string;
+  rootStyle: Record<string, string>;
+  isEmpty: boolean;
+};
+
+const GOOGLE_STYLESHEET_ORIGIN = "https://fonts.googleapis.com";
+const GOOGLE_FILE_ORIGIN = "https://fonts.gstatic.com";
+const DEFAULT_FALLBACK = "sans-serif";
+const CSS_VARIABLE_PATTERN = /^--[a-z][a-z0-9-]*$/;
+
+export function validateBrandFonts(fonts: SiteBrandFont[]): void {
+  const seenVariables = new Set<string>();
+  for (const font of fonts) {
+    if (!font.family.trim()) throw new Error("A brand font needs a family name.");
+    if (!CSS_VARIABLE_PATTERN.test(font.cssVariable)) {
+      throw new Error(`Brand font "${font.family}" cssVariable must look like --font-name, got "${font.cssVariable}".`);
+    }
+    if (seenVariables.has(font.cssVariable)) {
+      throw new Error(`Brand font cssVariable ${font.cssVariable} is declared twice.`);
+    }
+    seenVariables.add(font.cssVariable);
+    const sourceCount = Number(Boolean(font.google)) + Number(Boolean(font.faces?.length));
+    if (sourceCount !== 1) {
+      throw new Error(`Brand font "${font.family}" must declare exactly one source: google or faces.`);
+    }
+    if (font.google && font.google.weights.length === 0) {
+      throw new Error(`Brand font "${font.family}" google source needs at least one weight.`);
+    }
+  }
+}
+
+function buildGoogleFamilyQuery(font: SiteBrandFont): string {
+  const google = font.google!;
+  const weights = [...new Set(google.weights)].sort((left, right) => left - right);
+  const familyName = font.family.trim().replace(/\s+/g, "+");
+  if (!google.italics) return `family=${familyName}:wght@${weights.join(";")}`;
+  const axisValues = [0, 1].flatMap((italic) => weights.map((weight) => `${italic},${weight}`));
+  return `family=${familyName}:ital,wght@${axisValues.join(";")}`;
+}
+
+export function buildGoogleFontsHref(fonts: SiteBrandFont[]): string | null {
+  const googleFonts = fonts.filter((font) => font.google);
+  if (googleFonts.length === 0) return null;
+  return `${GOOGLE_STYLESHEET_ORIGIN}/css2?${googleFonts.map(buildGoogleFamilyQuery).join("&")}&display=swap`;
+}
+
+function buildFontFaceCss(font: SiteBrandFont): string {
+  return (font.faces ?? [])
+    .map((face) => {
+      const declarations = [
+        `font-family:${JSON.stringify(font.family)}`,
+        `src:url(${JSON.stringify(face.src)})`,
+        `font-weight:${face.weight ?? 400}`,
+        `font-style:${face.style ?? "normal"}`,
+        "font-display:swap",
+      ];
+      return `@font-face{${declarations.join(";")}}`;
+    })
+    .join("");
+}
+
+export function resolveBrandFontAssets(fonts: SiteBrandFont[] | undefined): BrandFontAssets {
+  if (!fonts || fonts.length === 0) {
+    return { preconnectOrigins: [], stylesheetHrefs: [], fontFaceCss: "", rootStyle: {}, isEmpty: true };
+  }
+  validateBrandFonts(fonts);
+  const googleHref = buildGoogleFontsHref(fonts);
+  return {
+    preconnectOrigins: googleHref ? [GOOGLE_STYLESHEET_ORIGIN, GOOGLE_FILE_ORIGIN] : [],
+    stylesheetHrefs: googleHref ? [googleHref] : [],
+    fontFaceCss: fonts.map(buildFontFaceCss).join(""),
+    rootStyle: Object.fromEntries(
+      fonts.map((font) => [font.cssVariable, `${JSON.stringify(font.family)}, ${font.fallback ?? DEFAULT_FALLBACK}`]),
+    ),
+    isEmpty: false,
+  };
+}
+
+export function listBrandFontFamilies(fonts: SiteBrandFont[] | undefined): string[] {
+  return (fonts ?? []).map((font) => font.family);
+}

package/lib/cached-content-repository.ts

@@ -10,6 +10,7 @@ import type {
 } from "./content-types";
 import { graphqlContentRepository } from "./graphql-content-repository";
 import { READER_REVALIDATE_SECONDS } from "./reader-route-config";
+import type { VideoScriptRef } from "./video-script";
 import { getContentSource } from "./site-env";
 
 const bypassReaderCacheInDevelopment = process.env.NODE_ENV === "development";
@@ -88,3 +89,14 @@ export function getCachedLatestPublishedEdition(): Promise<EditionRouteSummary |
     async () => graphqlContentRepository.getLatestPublishedEdition(),
   );
 }
+
+export function getCachedVideoScript(targetSlug: string): Promise<VideoScriptRef | null> {
+  if (bypassReaderCacheInDevelopment) {
+    return Promise.resolve(graphqlContentRepository.loadVideoScript(targetSlug)).then((result) => result ?? null);
+  }
+  return withReaderCache(
+    ["reader-video-script", targetSlug],
+    [articleCacheTag(targetSlug), ARTICLES_CACHE_TAG],
+    async () => graphqlContentRepository.loadVideoScript(targetSlug),
+  );
+}

package/lib/category-repository.ts

@@ -494,6 +494,7 @@ export type AssignmentRecord = {
   createdAt: string;
   updatedAt: string;
   newsroomFeedKey?: string | null;
+  itemLineageId?: string | null;
   metadata?: unknown;
 };
 
@@ -769,85 +770,7 @@ function knowledgeCorpusIdFromKey(corpusKey: string): string {
 }
 
 export async function loadCategorySteeringDashboard(): Promise<CategorySteeringDashboard> {
-  const proposals = await loadServerSteeringProposals();
-  if (proposals.length === 0) return createEmptyCategorySteeringDashboard();
-  return {
-    ...createEmptyCategorySteeringDashboard(),
-    isPublicSkeleton: false,
-    proposals: sortProposals(proposals),
-    loadError: null,
-  };
-}
-
-const SERVER_STEERING_PROPOSALS_QUERY = `
-  query ListSteeringProposals($limit: Int, $nextToken: String) {
-    listSteeringProposals(limit: $limit, nextToken: $nextToken) {
-      items {
-        id
-        categorySetId
-        corpusId
-        proposalKind
-        steeringDomain
-        status
-        title
-        summary
-        categoryKey
-        targetCategoryKey
-        graphEntityId
-        relationshipType
-        displayName
-        shortTitle
-        subtitle
-        description
-        evidenceItemIds
-        suggestedSeedItemIds
-        suggestedHoldoutItemIds
-        sourceSnapshotId
-        proposedAt
-        reviewedAt
-        reviewedBy
-        updatedAt
-      }
-      nextToken
-    }
-  }
-`;
-
-async function loadServerSteeringProposals(): Promise<CategorySteeringProposal[]> {
-  const endpoint = process.env.PAPYRUS_GRAPHQL_ENDPOINT;
-  const jwt = process.env.PAPYRUS_GRAPHQL_JWT;
-  if (!endpoint || !jwt) return [];
-
-  const items: CategorySteeringProposal[] = [];
-  let nextToken: string | null = null;
-
-  for (let page = 0; page < 20; page += 1) {
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        Authorization: `Bearer ${jwt}`,
-      },
-      body: JSON.stringify({
-        query: SERVER_STEERING_PROPOSALS_QUERY,
-        variables: { limit: 500, nextToken },
-      }),
-      cache: "no-store",
-    });
-    if (!response.ok) return [];
-    const payload = await response.json() as {
-      data?: { listSteeringProposals?: { items?: Array<CategorySteeringProposal | null> | null; nextToken?: string | null } | null } | null;
-      errors?: Array<{ message?: string }> | null;
-    };
-    if (payload.errors?.length) return [];
-    const connection = payload.data?.listSteeringProposals;
-    if (!connection) return [];
-    items.push(...(connection.items ?? []).filter(Boolean) as CategorySteeringProposal[]);
-    nextToken = connection.nextToken ?? null;
-    if (!nextToken) break;
-  }
-
-  return items;
+  return createEmptyCategorySteeringDashboard();
 }
 
 function sortCategorySets(categorySets: CategorySteeringCategorySet[], importRuns: CategorySteeringImportRun[]): CategorySteeringCategorySet[] {
@@ -895,20 +818,6 @@ function sortCategorys(categorys: CategorySteeringCategory[]): CategorySteeringC
   });
 }
 
-function sortProposals(proposals: CategorySteeringProposal[]): CategorySteeringProposal[] {
-  const statusWeight = new Map([
-    ["proposed", 0],
-    ["deferred", 1],
-    ["accepted", 2],
-    ["rejected", 3],
-  ]);
-  return [...proposals].sort((left, right) => {
-    const statusDiff = (statusWeight.get(left.status) ?? 9) - (statusWeight.get(right.status) ?? 9);
-    if (statusDiff !== 0) return statusDiff;
-    return (right.proposedAt ?? right.updatedAt ?? "").localeCompare(left.proposedAt ?? left.updatedAt ?? "");
-  });
-}
-
 function defaultNewsroomSections(importedAt: string, sectionsConfigPath = DEFAULT_NEWSROOM_SECTIONS_CONFIG_PATH): NewsroomSectionRecord[] {
   return loadNewsroomSectionSeedRows(sectionsConfigPath).map((row, index) => ({
     ...row,
@@ -1752,6 +1661,47 @@ export function createDemoCategorySteeringDashboard(
       },
     ],
     semanticRelations: [
+      {
+        // The relevance cyclotron's decision about the pending demo reference.
+        id: "semantic-relation-demo-relevance-history-002",
+        relationState: "current",
+        predicate: "relevance_decision_is",
+        relationTypeKey: "relevance_decision_is",
+        relationDomain: "workflow",
+        subjectKind: "reference",
+        subjectId: referenceHistoryTwoId,
+        subjectLineageId: referenceHistoryTwoLineageId,
+        objectKind: "semanticNode",
+        objectId: "semantic-node-relevance-include-v1",
+        objectLineageId: "semantic-node-relevance-include",
+        subjectStateKey: `reference#${referenceHistoryTwoLineageId}#current`,
+        objectStateKey: "semanticNode#semantic-node-relevance-include#current",
+        objectSubjectStateKey: "semanticNode#semantic-node-relevance-include#current#reference",
+        predicateObjectStateKey: "relevance_decision_is#semanticNode#semantic-node-relevance-include#current",
+        subjectVersionKey: `reference#${referenceHistoryTwoId}`,
+        objectVersionKey: "semanticNode#semantic-node-relevance-include-v1",
+        score: 0.82,
+        confidence: 0.82,
+        rank: 1,
+        classifierId: "papyrus-relevance/relevant",
+        modelVersion: "1",
+        reviewRecommended: true,
+        importRunId: "knowledge-import-demo-projection",
+        importedAt,
+        metadata: JSON.stringify({
+          decisionId: "decision-demo-history-002",
+          cyclotronId: "papyrus-relevance",
+          label: "include",
+          probabilities: { include: 0.82, exclude: 0.18 },
+          labels: ["include", "exclude"],
+          positiveLabel: "include",
+          question: "Should this candidate source become a reference for this publication?",
+          reviewControl: "thumbs",
+          reviewReason: "program",
+          reviewDetail: "Every decision is reviewed while the cyclotron is onboarding.",
+          version: 1,
+        }),
+      },
       {
         id: "semantic-relation-demo-reporting-context-comment",
         relationState: "current",

package/lib/content-item-lifecycle.ts

@@ -0,0 +1,55 @@
+/**
+ * One content item, one lifecycle: the stages an Item lineage moves through.
+ * Mirrors CONTENT_ITEM_STAGES in src/papyrus_content/content_item_lifecycle.py.
+ * See docs/content-item-lifecycle.md.
+ */
+export const CONTENT_ITEM_STAGES = [
+  "idea",
+  "assignment",
+  "research",
+  "report",
+  "editor_select",
+  "copywriting",
+  "published",
+] as const;
+
+export type ContentItemStage = (typeof CONTENT_ITEM_STAGES)[number];
+
+const CONTENT_ITEM_STAGE_LABELS: Record<ContentItemStage, string> = {
+  idea: "Idea",
+  assignment: "Assignment",
+  research: "Research",
+  report: "Report",
+  editor_select: "Editor select",
+  copywriting: "Copywriting",
+  published: "Published",
+};
+
+export function contentItemStageLabel(stage: string): string {
+  return (CONTENT_ITEM_STAGE_LABELS as Record<string, string>)[stage] ?? stage;
+}
+
+export type ContentItemVersionRecord = {
+  id: string;
+  lineageId: string;
+  versionNumber: number;
+  stage?: string | null;
+  type: string;
+  status: string;
+  title?: string | null;
+  headline?: string | null;
+  slug: string;
+  section?: string | null;
+  updatedAt?: string | null;
+};
+
+export function latestVersionPerContentItem(
+  versions: readonly ContentItemVersionRecord[],
+): ContentItemVersionRecord[] {
+  const latestByLineage = new Map<string, ContentItemVersionRecord>();
+  for (const version of versions) {
+    const current = latestByLineage.get(version.lineageId);
+    if (!current || version.versionNumber > current.versionNumber) latestByLineage.set(version.lineageId, version);
+  }
+  return [...latestByLineage.values()];
+}

package/lib/content-repository.ts

@@ -31,6 +31,9 @@ export const contentRepository: ContentRepository = {
   listArticleSlugs() {
     return graphqlContentRepository.listArticleSlugs();
   },
+  loadVideoScript(targetSlug: string) {
+    return graphqlContentRepository.loadVideoScript(targetSlug);
+  },
 };
 
 export function getScenarioIdParam(scenario: string | string[] | null | undefined): string | null {

package/lib/content-types.ts

@@ -1,6 +1,7 @@
 import type { Article, ArticleVideoAsset } from "./articles";
 import type { EditionLayoutPlan } from "./layout-plan";
 import type { PublicationItem } from "./publication-items";
+import type { VideoScriptRef } from "./video-script";
 
 export type ContentSource = "scenario" | "graphql";
 
@@ -55,6 +56,8 @@ export type EditionContent = {
   scenarioId?: string;
   description?: string;
   editionVideo?: ArticleVideoAsset | null;
+  /** Video scripts by item slug (`"edition-overview"` for the edition video), for the VideoML preview. */
+  videoScripts?: Record<string, VideoScriptRef>;
 };
 
 export type EditionRouteSummary = {
@@ -101,4 +104,5 @@ export type ContentRepository = {
   getEditionArticle(options: GetEditionArticleOptions): Article | undefined | Promise<Article | undefined>;
   getEditionItem(options: GetEditionItemOptions): PublicationItem | undefined | Promise<PublicationItem | undefined>;
   listArticleSlugs(): string[] | Promise<string[]>;
+  loadVideoScript(targetSlug: string): VideoScriptRef | null | Promise<VideoScriptRef | null>;
 };

package/lib/curation-client.ts

@@ -0,0 +1,61 @@
+import {createPrimingClient} from 'cyclotron/priming-client';
+import {assertPublicationScope,createPublicationClient,publicationScopeKey,type PublicationEnvelope,type PublicationRevisionRef,type PublicationScope} from './publication-cyclotron';
+
+export type CurationBootstrap={
+  scope:PublicationScope;
+  mode:'embedded'|'remote';
+  priming:{listId:string;classifiers:{id:string;revision:number}[]}|null;
+  capabilities:readonly string[];
+  bindingRef:PublicationRevisionRef|null;
+};
+export type CurationRequest=<T>(path:string,body:Record<string,unknown>,scope:Readonly<PublicationScope>)=>Promise<T>;
+
+/** Same-origin only. The server verifies these expected pins against its session. */
+export const requestCuration:CurationRequest=async<T,>(path:string,body:Record<string,unknown>,scope:Readonly<PublicationScope>)=>{
+  if(!path.startsWith('/api/newsroom/curation/'))throw new Error('Same-origin curation route required');
+  const controller=new AbortController();
+  const timer=setTimeout(()=>controller.abort(),15000);
+  let response:Response;
+  let result;
+  try{
+  response=await fetch(path,{method:'POST',credentials:'same-origin',signal:controller.signal,headers:{
+    'Content-Type':'application/json','X-Cyclotron-Account':scope.accountId,
+    'X-Papyrus-Publication':scope.publicationId,'X-Papyrus-Binding':scope.bindingRevision,
+  },body:JSON.stringify(body)});
+  result=await response.json().catch(()=>null);
+  }catch(error){
+    const timeout=controller.signal.aborted||(error instanceof Error&&error.name==='AbortError');
+    throw new Error(timeout?'Curation request timed out. Your selection is preserved. Check the server and saved history before retrying; do not resubmit automatically.':'Cannot reach the curation server. Your selection is preserved. Check the preview is running and saved history before retrying; do not resubmit automatically.');
+  }finally{clearTimeout(timer);}
+  if(response.status===401)throw new Error('Sign in again: the curation session expired. Your selection is preserved.');
+  if(response.status===403)throw new Error('Your session does not have permission for this curation action. Your selection is preserved.');
+  if(!response.ok||!result||result.errors)throw new Error(`Curation request failed (HTTP ${response.status}): ${result?.error??result?.errors?.[0]?.message??'invalid server response'}. Check saved history before retrying; your selection is preserved.`);
+  return result as T;
+};
+
+/** One controller contract for both modes; no browser-selected service URL. */
+export function createCurationSession(bootstrap:CurationBootstrap,request:CurationRequest,currentScope:()=>PublicationScope|null){
+  const pinned=Object.freeze({...bootstrap.scope});
+  const scopeKey=publicationScopeKey(pinned);
+  const assertCurrent=()=>{
+    const selected=currentScope();
+    if(!selected||publicationScopeKey(selected)!==scopeKey)throw new Error('Curation account selection changed; refresh context');
+  };
+  const publication=createPublicationClient(pinned,(operation,payload,scope)=>request<PublicationEnvelope&Record<string,unknown>>('/api/newsroom/curation/publication',{operation,payload},scope),currentScope);
+  const priming=createPrimingClient(async<T,>(query:string,variables:Record<string,unknown>):Promise<T>=>{
+    assertCurrent();
+    const result=await request<{data:T}>('/api/newsroom/curation/priming',{query,variables},pinned);
+    assertCurrent();
+    return result.data;
+  });
+  return {
+    key:JSON.stringify([bootstrap.mode,scopeKey]),bootstrap,publication,priming,
+    async snapshot(){
+      const [status,history]=await Promise.all([publication.status(),publication.history()]);
+      assertCurrent();assertPublicationScope(status,history);
+      return {status,history};
+    },
+  };
+}
+
+export type CurationSession=ReturnType<typeof createCurationSession>;

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 {