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

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

@@ -769,85 +769,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 +817,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 +1660,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-actions-demo.ts

@@ -0,0 +1,190 @@
+import { ContentActionFailure } from "./content-actions-client";
+import type {
+  DeriveMarkusInput,
+  DeriveMarkusResult,
+  PublishItemResult,
+  SaveItemDraftInput,
+  SaveItemDraftResult,
+  UnpublishItemResult,
+} from "./content-actions-client";
+import {
+  createDemoArticleRecords,
+  demoContentHash,
+  type DemoArticleRecord,
+} from "./newsroom-demo-articles";
+import { sourceLineOffset, type ArticlesBackend, type EditableArticle, type NewsroomArticleRow } from "./newsroom-articles";
+
+function titleFromYaml(frontMatterYaml: string | null, fallback: string): string {
+  for (const line of (frontMatterYaml ?? "").split("\n")) {
+    const match = /^title\s*:\s*(.*)$/.exec(line);
+    if (match && match[1].trim()) return match[1].trim().replace(/^["']|["']$/g, "");
+  }
+  return fallback;
+}
+
+const DEMO_IMAGE_DIRECTIVE = /^::image\{([^}]*)\}$/;
+
+function demoAttribute(attributes: string, name: string): string {
+  const match = new RegExp(`${name}="([^"]*)"`).exec(attributes);
+  return match ? match[1] : "";
+}
+
+function demoEnvelope(bodyMarkus: string) {
+  const images: Record<string, Record<string, unknown>> = {};
+  const children = bodyMarkus
+    .split(/\n{2,}/)
+    .map((block) => block.trim())
+    .filter(Boolean)
+    .map((block) => {
+      const heading = /^(#{1,6})\s+(.*)$/.exec(block);
+      if (heading) {
+        return { type: "heading", level: heading[1].length, inline: [{ type: "text", text: heading[2] }], line: null };
+      }
+      const image = DEMO_IMAGE_DIRECTIVE.exec(block);
+      if (image) {
+        const token = `PAPYRUSMARKUP${String(Object.keys(images).length + 1).padStart(5, "0")}END`;
+        images[token] = {
+          src: demoAttribute(image[1], "src"),
+          alt: demoAttribute(image[1], "alt"),
+          layout: demoAttribute(image[1], "layout") || null,
+        };
+        return { type: "paragraph", inline: [{ type: "text", text: token }], line: null };
+      }
+      return { type: "paragraph", inline: [{ type: "text", text: block }], line: null };
+    });
+  return {
+    schemaVersion: 1,
+    markus: { version: "demo", irSchemaVersion: 1 },
+    document: { type: "document", schema_version: 1, front_matter: {}, children },
+    papyrus: { images, citations: {}, citationLists: {}, entries: {}, bibliography: [] },
+  };
+}
+
+export function createDemoArticlesBackend(): ArticlesBackend {
+  const records = new Map<string, DemoArticleRecord>(createDemoArticleRecords().map((record) => [record.id, record]));
+  let created = 0;
+
+  const requireRecord = (id: string): DemoArticleRecord => {
+    const record = records.get(id);
+    if (!record) throw new ContentActionFailure([{ code: "not-found", message: "That article was not found.", line: null }]);
+    return record;
+  };
+
+  return {
+    actions: {
+      async deriveMarkus(input: DeriveMarkusInput): Promise<DeriveMarkusResult> {
+        const lines = input.bodyMarkus.split("\n");
+        const invalidIndex = lines.findIndex((line) => line.includes(":::nope"));
+        if (invalidIndex >= 0) {
+          throw new ContentActionFailure([
+            { code: "markus-validation", message: 'Unknown directive "nope".', line: invalidIndex + 1 + sourceLineOffset(input.frontMatterYaml) },
+          ]);
+        }
+        const envelope = demoEnvelope(input.bodyMarkus);
+        return {
+          ok: true,
+          bodyIrBytes: JSON.stringify(envelope).length,
+          ...(input.includeIr ? { bodyIr: envelope } : {}),
+          errors: [],
+        };
+      },
+      async saveItemDraft(input: SaveItemDraftInput): Promise<SaveItemDraftResult> {
+        const existing = input.id ? requireRecord(input.id) : null;
+        if (existing && input.expectedContentHash !== null && input.expectedContentHash !== existing.contentHash) {
+          throw new ContentActionFailure([
+            { code: "conflict", message: "The item changed since it was loaded.", line: null },
+          ]);
+        }
+        if (existing && existing.everPublished && existing.slug !== input.slug) {
+          throw new ContentActionFailure([
+            { code: "slug-locked", message: "The slug cannot change once the item has been published.", line: null },
+          ]);
+        }
+        const id = existing?.id ?? `demo-article-new-${(created += 1)}`;
+        const title = titleFromYaml(input.frontMatterYaml, input.slug);
+        const frontMatterYaml = input.frontMatterYaml ?? "";
+        const record: DemoArticleRecord = {
+          id,
+          type: input.type,
+          slug: input.slug,
+          section: input.section,
+          title,
+          status: existing?.status ?? "draft",
+          frontMatterYaml,
+          bodyMarkus: input.bodyMarkus,
+          contentHash: demoContentHash(frontMatterYaml, input.bodyMarkus),
+          publishedContentHash: existing?.publishedContentHash ?? null,
+          versionNumber: existing?.versionNumber ?? null,
+          everPublished: existing?.everPublished ?? false,
+          updatedAt: new Date().toISOString(),
+        };
+        records.set(id, record);
+        return {
+          ok: true,
+          item: {
+            id,
+            contentHash: record.contentHash,
+            status: record.status,
+            slug: record.slug,
+            versionNumber: record.versionNumber,
+          },
+        };
+      },
+      async publishItem(id: string): Promise<PublishItemResult> {
+        const record = requireRecord(id);
+        const changed = record.status !== "published" || record.publishedContentHash !== record.contentHash;
+        const versionNumber = changed ? (record.versionNumber ?? 0) + 1 : record.versionNumber;
+        records.set(id, {
+          ...record,
+          status: "published",
+          everPublished: true,
+          publishedContentHash: record.contentHash,
+          versionNumber,
+          updatedAt: new Date().toISOString(),
+        });
+        return { ok: true, changed, publishedId: `published-${id}`, versionNumber };
+      },
+      async unpublishItem(id: string): Promise<UnpublishItemResult> {
+        const record = requireRecord(id);
+        const changed = record.status === "published";
+        records.set(id, {
+          ...record,
+          status: "draft",
+          publishedContentHash: null,
+          updatedAt: new Date().toISOString(),
+        });
+        return { ok: true, changed };
+      },
+    },
+    async listRows(): Promise<NewsroomArticleRow[]> {
+      return [...records.values()]
+        .map((record) => ({
+          id: record.id,
+          type: record.type,
+          slug: record.slug,
+          section: record.section,
+          title: record.title || record.slug,
+          status: record.status,
+          pending: record.status === "published" && record.publishedContentHash !== record.contentHash,
+          updatedAt: record.updatedAt,
+        }))
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    },
+    async loadArticle(id: string): Promise<EditableArticle> {
+      const record = requireRecord(id);
+      return {
+        id: record.id,
+        type: record.type,
+        section: record.section,
+        slug: record.slug,
+        frontMatterYaml: record.frontMatterYaml,
+        bodyMarkus: record.bodyMarkus,
+        contentHash: record.contentHash,
+        status: record.status,
+        versionNumber: record.versionNumber,
+        aliases: [],
+        everPublished: record.everPublished,
+      };
+    },
+  };
+}

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-source-context.ts

@@ -3,12 +3,22 @@ import { getContentSource, type ContentSource } from "./site-env";
 
 export type ContentSourceContext = {
   source: ContentSource;
+  /** Request-scoped data client (drafts mode: carries the visitor's session cookies). */
+  client?: unknown;
 };
 
 const contentSourceStorage = new AsyncLocalStorage<ContentSourceContext>();
 
-export function runWithContentSource<T>(source: ContentSource, operation: () => Promise<T>): Promise<T> {
-  return contentSourceStorage.run({ source }, operation);
+export function runWithContentSource<T>(
+  source: ContentSource,
+  operation: () => Promise<T>,
+  client?: unknown,
+): Promise<T> {
+  return contentSourceStorage.run({ source, client }, operation);
+}
+
+export function currentRequestClient<T>(): T | undefined {
+  return contentSourceStorage.getStore()?.client as T | undefined;
 }
 
 export function currentContentSource(): ContentSource {

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/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 {