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

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 { getContentSource } from "./site-env";
 
 const bypassReaderCacheInDevelopment = process.env.NODE_ENV === "development";
 
@@ -34,7 +35,7 @@ function withReaderCache<T>(
   tags: string[],
   loader: () => Promise<T>,
 ): Promise<T> {
-  if (bypassReaderCacheInDevelopment) return loader();
+  if (bypassReaderCacheInDevelopment || getContentSource() === "drafts") return loader();
   return unstable_cache(loader, cacheKey, {
     tags,
     revalidate: READER_REVALIDATE_SECONDS,

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,

package/lib/content-actions-client.ts

@@ -0,0 +1,98 @@
+import { generateClient } from "aws-amplify/data";
+import type { Schema } from "../amplify/data/resource";
+
+export type ContentActionError = { code: string; message: string; line: number | null };
+
+export type DeriveMarkusInput = { frontMatterYaml: string | null; bodyMarkus: string; includeIr?: boolean };
+export type SaveItemDraftInput = {
+  id: string | null;
+  type: string;
+  slug: string;
+  section: string | null;
+  frontMatterYaml: string | null;
+  bodyMarkus: string;
+  aliases: string[];
+  expectedContentHash: string | null;
+};
+
+export type DeriveMarkusResult = { ok: true; bodyIrBytes: number; bodyIr?: unknown; errors: [] };
+export type SavedItemSummary = {
+  id: string;
+  contentHash: string;
+  status: string;
+  slug: string;
+  versionNumber: number | null;
+};
+export type SaveItemDraftResult = { ok: true; item: SavedItemSummary };
+export type PublishItemResult = { ok: true; changed: boolean; publishedId: string; versionNumber: number | null };
+export type UnpublishItemResult = { ok: true; changed: boolean };
+
+export class ContentActionFailure extends Error {
+  readonly errors: ContentActionError[];
+
+  constructor(errors: ContentActionError[]) {
+    super(errors.map((error) => error.message).join("; ") || "Content action failed");
+    this.name = "ContentActionFailure";
+    this.errors = errors;
+  }
+}
+
+type GraphqlEnvelope = { data?: unknown; errors?: { message?: string }[] | null };
+
+export type ContentActionsTransport = {
+  queries: { deriveMarkus: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope> };
+  mutations: {
+    saveItemDraft: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
+    publishItem: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
+    unpublishItem: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
+  };
+};
+
+const USER_POOL = { authMode: "userPool" } as const;
+
+function parseActionResponse<T>(envelope: GraphqlEnvelope): T {
+  if (envelope.errors && envelope.errors.length > 0) {
+    throw new Error(envelope.errors.map((error) => error.message ?? "GraphQL error").join("; "));
+  }
+  const raw = envelope.data;
+  const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("The content action returned no data.");
+  }
+  const response = parsed as { ok?: boolean; errors?: ContentActionError[] };
+  if (response.ok !== true) {
+    throw new ContentActionFailure(response.errors ?? []);
+  }
+  return parsed as T;
+}
+
+export function createContentActionsClient(transport: ContentActionsTransport) {
+  return {
+    async deriveMarkus(input: DeriveMarkusInput): Promise<DeriveMarkusResult> {
+      return parseActionResponse(await transport.queries.deriveMarkus({ input: JSON.stringify(input) }, USER_POOL));
+    },
+    async saveItemDraft(input: SaveItemDraftInput): Promise<SaveItemDraftResult> {
+      return parseActionResponse(await transport.mutations.saveItemDraft({ input: JSON.stringify(input) }, USER_POOL));
+    },
+    async publishItem(id: string): Promise<PublishItemResult> {
+      return parseActionResponse(await transport.mutations.publishItem({ input: JSON.stringify({ id }) }, USER_POOL));
+    },
+    async unpublishItem(id: string): Promise<UnpublishItemResult> {
+      return parseActionResponse(await transport.mutations.unpublishItem({ input: JSON.stringify({ id }) }, USER_POOL));
+    },
+  };
+}
+
+let defaultClient: ReturnType<typeof createContentActionsClient> | null = null;
+
+function contentActionsClient() {
+  if (!defaultClient) {
+    defaultClient = createContentActionsClient(generateClient<Schema>() as unknown as ContentActionsTransport);
+  }
+  return defaultClient;
+}
+
+export const deriveMarkus = (input: DeriveMarkusInput) => contentActionsClient().deriveMarkus(input);
+export const saveItemDraft = (input: SaveItemDraftInput) => contentActionsClient().saveItemDraft(input);
+export const publishItem = (id: string) => contentActionsClient().publishItem(id);
+export const unpublishItem = (id: string) => contentActionsClient().unpublishItem(id);

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

@@ -1,6 +1,9 @@
 import type { ContentRepository } from "./content-types";
 import { graphqlContentRepository } from "./graphql-content-repository";
 import { getLayoutScenario } from "./layout-scenarios";
+import { assertContentSourceMatchesEnv } from "./site-env";
+
+assertContentSourceMatchesEnv();
 
 export const contentRepository: ContentRepository = {
   loadEditionContent({ scenarioId, editionDate, editionSlug } = {}) {

package/lib/content-source-context.ts

@@ -0,0 +1,26 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+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>,
+  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 {
+  return contentSourceStorage.getStore()?.source ?? getContentSource();
+}

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

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. */