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

package/lib/newsroom-media.ts

@@ -0,0 +1,182 @@
+export const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+export const IMAGE_CONTENT_TYPES: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  svg: "image/svg+xml",
+};
+
+export type ImageFileLike = { name: string; size: number };
+
+function extensionOf(filename: string): string {
+  const dot = filename.lastIndexOf(".");
+  return dot === -1 ? "" : filename.slice(dot + 1).toLowerCase();
+}
+
+export function contentTypeForFilename(filename: string): string | null {
+  return IMAGE_CONTENT_TYPES[extensionOf(filename)] ?? null;
+}
+
+export function isSvgFilename(filename: string): boolean {
+  return extensionOf(filename) === "svg";
+}
+
+function sanitizeSegment(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/-{2,}/g, "-")
+    .replace(/^[-.]+|-+$/g, "");
+}
+
+export function srcPathFor(slug: string, filename: string, existingSrcPaths: Iterable<string> = []): string {
+  const taken = new Set(existingSrcPaths);
+  const extension = sanitizeSegment(extensionOf(filename));
+  const dot = filename.lastIndexOf(".");
+  const rawStem = dot === -1 ? filename : filename.slice(0, dot);
+  const stem = sanitizeSegment(rawStem) || "image";
+  const directory = sanitizeSegment(slug) || "article";
+  const suffix = extension ? `.${extension}` : "";
+  let candidate = `assets/${directory}/${stem}${suffix}`;
+  for (let counter = 2; taken.has(candidate); counter += 1) {
+    candidate = `assets/${directory}/${stem}-${counter}${suffix}`;
+  }
+  return candidate;
+}
+
+export async function sha256Hex(data: string | ArrayBuffer): Promise<string> {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+export async function mediaIdFor(itemId: string, srcPath: string): Promise<string> {
+  return `media-${itemId}-${(await sha256Hex(srcPath)).slice(0, 10)}`;
+}
+
+export function validateImageFile(file: ImageFileLike): string | null {
+  if (contentTypeForFilename(file.name) === null) {
+    return "Choose a PNG, JPEG, GIF, WebP, AVIF or SVG image.";
+  }
+  if (file.size <= 0) return "That file is empty.";
+  if (file.size > MAX_IMAGE_BYTES) return "Images can be at most 10 MB.";
+  return null;
+}
+
+function altAttributeValue(alt: string): string {
+  return alt.replace(/[\r\n]+/g, " ").replace(/"/g, "'").replace(/[{}]/g, "");
+}
+
+export function imageDirective(srcPath: string, alt: string): string {
+  return `::image{src="${srcPath}" alt="${altAttributeValue(alt)}" layout="inline"}`;
+}
+
+export type MediaAssetFields = {
+  id: string;
+  itemId: string;
+  type: "image";
+  role: "body";
+  sortKey: string;
+  storagePath: string;
+  alt: string;
+  width?: number;
+  height?: number;
+  metadata: string;
+};
+
+export function mediaSortKey(position: number, srcPath: string): string {
+  return `${String(position).padStart(3, "0")}#${srcPath}`;
+}
+
+export type SelectionInsertion = { body: string; altSelectionStart: number };
+
+function countEdgeNewlines(text: string, fromEnd: boolean): number {
+  let count = 0;
+  while (count < 2 && (fromEnd ? text[text.length - 1 - count] : text[count]) === "\n") count += 1;
+  return count;
+}
+
+export function insertDirectiveAtSelection(
+  body: string,
+  selectionStart: number,
+  selectionEnd: number,
+  directive: string,
+): SelectionInsertion {
+  const before = body.slice(0, selectionStart);
+  const after = body.slice(selectionEnd);
+  const prefix = before === "" ? "" : "\n".repeat(2 - countEdgeNewlines(before, true));
+  const suffix = after === "" ? "\n" : "\n".repeat(2 - countEdgeNewlines(after, false));
+  const directiveStart = before.length + prefix.length;
+  return {
+    body: `${before}${prefix}${directive}${suffix}${after}`,
+    altSelectionStart: directiveStart + directive.indexOf('alt="') + 'alt="'.length,
+  };
+}
+
+export type MediaAssetRecord = {
+  id: string;
+  sortKey: string;
+  storagePath: string | null;
+  alt: string;
+  srcPath: string | null;
+};
+
+export type NewsroomMediaBackend = {
+  uploadImage: (input: { storagePath: string; data: Blob; contentType: string }) => Promise<void>;
+  createMediaAsset: (fields: MediaAssetFields) => Promise<void>;
+  listMediaAssets: (itemId: string) => Promise<MediaAssetRecord[]>;
+  imageUrl: (storagePath: string) => Promise<string>;
+};
+
+export type ImageDimensionReader = (file: Blob, filename: string) => Promise<{ width: number; height: number } | null>;
+
+export type UploadedImage = { srcPath: string; directive: string; imageUrl: string };
+
+export async function uploadArticleImage(
+  backend: NewsroomMediaBackend,
+  readDimensions: ImageDimensionReader,
+  input: { itemId: string; slug: string; file: File },
+): Promise<UploadedImage> {
+  const problem = validateImageFile(input.file);
+  if (problem) throw new Error(problem);
+  const contentType = contentTypeForFilename(input.file.name) as string;
+  const existing = await backend.listMediaAssets(input.itemId);
+  const srcPath = srcPathFor(
+    input.slug,
+    input.file.name,
+    existing.map((asset) => asset.srcPath).filter((path): path is string => path !== null),
+  );
+  const bytes = await input.file.arrayBuffer();
+  const sha256 = await sha256Hex(bytes);
+  const dimensions = await readDimensions(input.file, input.file.name);
+  const storagePath = `media/${srcPath}`;
+  await backend.uploadImage({ storagePath, data: input.file, contentType });
+  await backend.createMediaAsset({
+    id: await mediaIdFor(input.itemId, srcPath),
+    itemId: input.itemId,
+    type: "image",
+    role: "body",
+    sortKey: mediaSortKey(existing.length + 1, srcPath),
+    storagePath,
+    alt: input.file.name,
+    ...(dimensions ?? {}),
+    metadata: JSON.stringify({ srcPath, sha256, bytes: bytes.byteLength, contentType }),
+  });
+  return { srcPath, directive: imageDirective(srcPath, ""), imageUrl: await backend.imageUrl(storagePath) };
+}
+
+export async function readImageDimensions(file: Blob, filename: string): Promise<{ width: number; height: number } | null> {
+  if (isSvgFilename(filename)) return null;
+  try {
+    const bitmap = await createImageBitmap(file);
+    const size = { width: bitmap.width, height: bitmap.height };
+    bitmap.close();
+    return size;
+  } catch {
+    return null;
+  }
+}

package/lib/newsroom-nav.ts

@@ -2,6 +2,7 @@ import { newsroomHref, toPublicNewsroomPath } from "./newsroom-base-path";
 
 export type NewsroomNavTabId =
   | "overview"
+  | "articles"
   | "messages"
   | "insights"
   | "assignments"
@@ -22,12 +23,14 @@ export type NewsroomNavItem = {
 
 export const NEWSROOM_OPS_NAV: NewsroomNavItem[] = [
   { id: "overview", label: "Overview", detail: "Desk home", href: newsroomHref(), mobilePrimary: true },
+  { id: "articles", label: "Articles", detail: "Drafts & published", href: newsroomHref("articles"), mobilePrimary: true },
   { id: "assignments", label: "Assignments", detail: "Work queue", href: newsroomHref("assignments"), mobilePrimary: true },
   { id: "references", label: "References", detail: "Knowledge base", href: newsroomHref("references"), mobilePrimary: true },
   { id: "messages", label: "Messages", detail: "Forum", href: newsroomHref("messages") },
   { id: "insights", label: "Insights", detail: "Research threads", href: newsroomHref("insights") },
   { id: "topics", label: "Topics", detail: "Taxonomy", href: newsroomHref("topics"), mobilePrimary: true },
   { id: "concepts", label: "Concepts", detail: "Ontology", href: newsroomHref("concepts") },
+  { id: "search", label: "Search", detail: "Knowledge base", href: newsroomHref("search") },
   { id: "administration", label: "Administration", detail: "Users & policies", href: newsroomHref("administration") },
 ];
 

package/lib/papyrus-web-locations.ts

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

package/lib/presentation-footer.ts

@@ -1,6 +1,7 @@
 import { getEditionSectionItems } from "./edition-sections";
 import type { EditionContent } from "./content-types";
 import type { PublicationItem } from "./publication-items";
+import { toPublicReaderPath } from "./reader-base-path";
 
 export type PresentationFooterEntry = {
   section: string;
@@ -43,9 +44,9 @@ export type PresentationFooterGeometry = {
 };
 
 export const PRESENTATION_FOOTER_UTILITIES: PresentationFooterUtilityEntry[] = [
-  { 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 },
 ];
 

package/lib/pretext-layout.ts

@@ -1,4 +1,5 @@
 import {
+  clearCache,
   layoutNextLine,
   prepareWithSegments,
   type LayoutCursor,
@@ -78,14 +79,18 @@ export function layoutAllTextLines({
   linePaintHeight,
   fontSize,
   fontFamily,
-}: Omit<LayoutTextLinesOptions, "cursor" | "maxHeight" | "obstacles">): TextLine[] {
+  obstacles = [],
+}: Omit<LayoutTextLinesOptions, "cursor" | "maxHeight" | "obstacles"> & { obstacles?: TextObstacle[] }): TextLine[] {
   const lines: TextLine[] = [];
   let cursor: LayoutCursor = { segmentIndex: 0, graphemeIndex: 0 };
 
   for (let lineIndex = 0; lineIndex < 2000; lineIndex += 1) {
-    const line = layoutNextLine(prepared, cursor, maxWidth);
+    const y = lineIndex * lineHeight;
+    const slot = getAvailableSlot(maxWidth, y, linePaintHeight, obstacles);
+    if (!slot) continue;
+    const line = layoutNextLine(prepared, cursor, slot.width);
     if (!line) return lines;
-    lines.push(toTextLine(line, 0, lineIndex * lineHeight, fontSize, fontFamily, lineHeight, linePaintHeight));
+    lines.push(toTextLine(line, slot.x, y, fontSize, fontFamily, lineHeight, linePaintHeight));
     cursor = line.end;
   }
 
@@ -177,3 +182,7 @@ function toTextLine(line: LayoutLine, x: number, y: number, fontSize: number, fo
 function clamp(value: number, min: number, max: number): number {
   return Math.max(min, Math.min(max, value));
 }
+
+export function clearPretextMeasurementCache(): void {
+  clearCache();
+}

package/lib/reader-base-path.ts

@@ -0,0 +1,24 @@
+import { SITE_BRAND } from "./site-brand";
+
+export function normalizeReaderBasePath(value: string | undefined | null): string {
+  const trimmed = (value ?? "").trim().replace(/\/+$/, "");
+  if (!trimmed) return "";
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+export function getReaderBasePath(): string {
+  return normalizeReaderBasePath(SITE_BRAND.readerBasePath);
+}
+
+export function toPublicReaderPath(path: string, readerBasePath: string = getReaderBasePath()): string {
+  if (!readerBasePath) return path;
+  if (path === "/" || path === "") return readerBasePath;
+  return `${readerBasePath}${path.startsWith("/") ? path : `/${path}`}`;
+}
+
+export function toInternalReaderPath(path: string, readerBasePath: string = getReaderBasePath()): string {
+  if (!readerBasePath) return path;
+  if (path === readerBasePath || path === `${readerBasePath}/`) return "/";
+  if (path.startsWith(`${readerBasePath}/`)) return path.slice(readerBasePath.length);
+  return path;
+}

package/lib/reader-static-params.ts

@@ -1,4 +1,10 @@
 import { graphqlContentRepository } from "./graphql-content-repository";
+import { SITE_BRAND } from "./site-brand";
+import type { RendererConfig } from "./renderer-config";
+
+export function siteServesNextReaderRoutes(rendererKind: RendererConfig["kind"] = SITE_BRAND.renderer.kind): boolean {
+  return rendererKind !== "markus";
+}
 
 const MONTH_NAMES = [
   "january",
@@ -23,6 +29,7 @@ type EditionDateStaticParam = {
 
 export async function generateEditionDateStaticParams(): Promise<EditionDateStaticParam[]> {
   if (process.env.NODE_ENV === "development") return [];
+  if (!siteServesNextReaderRoutes()) return [];
 
   const { editions } = await graphqlContentRepository.listPublishedEditions({ limit: 100 });
   const params: EditionDateStaticParam[] = [];
@@ -35,6 +42,7 @@ export async function generateEditionDateStaticParams(): Promise<EditionDateStat
 
 export async function generateArticleStaticParams(): Promise<Array<{ slug: string }>> {
   if (process.env.NODE_ENV === "development") return [];
+  if (!siteServesNextReaderRoutes()) return [];
 
   const slugs = await graphqlContentRepository.listArticleSlugs();
   return slugs.map((slug) => ({ slug }));

package/lib/renderer.ts

@@ -4,6 +4,7 @@ import type { EditionContent } from "./content-types";
 import type { PretextLayout } from "./renderer-config";
 import type { PresentationFooterEntry } from "./presentation-footer";
 import type { PublicationItem } from "./publication-items";
+import type { VideoScriptRef } from "./video-script";
 
 /**
  * Renderer is the swappable render pipeline that turns standard content
@@ -36,6 +37,8 @@ export type RenderEditionProps = {
 export type ArticlePageEditionFooter = {
   editionBasePath: string;
   entries: PresentationFooterEntry[];
+  /** Section links for the rhythm blog layout's page header. Ignored by the classic layout. */
+  sections?: Array<{ key: string; label: string }>;
   subtitle: string;
   title?: string;
 };
@@ -46,6 +49,8 @@ export type RenderArticleProps = {
   backLabel?: string;
   editionFooter?: ArticlePageEditionFooter;
   editionDate?: string;
+  /** VideoML script for the preview player. */
+  videoScript?: VideoScriptRef | null;
 };
 
 export type RenderItemProps = {
@@ -54,6 +59,8 @@ export type RenderItemProps = {
   backLabel?: string;
   editionFooter?: ArticlePageEditionFooter;
   editionDate?: string;
+  /** VideoML script for the preview player. */
+  videoScript?: VideoScriptRef | null;
 };
 
 /**

package/lib/revalidate-secret.ts

@@ -0,0 +1,59 @@
+import { timingSafeEqual } from "node:crypto";
+import { GetParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+
+export const REVALIDATE_SECRET_PARAMETER_ENV = "PAPYRUS_REVALIDATE_SECRET_PARAMETER";
+export const REVALIDATE_SECRET_CACHE_MILLISECONDS = 5 * 60 * 1000;
+
+export type RevalidateSecretReader = (parameterName: string) => Promise<string | null>;
+
+type CachedSecret = { parameterName: string; value: string; expiresAt: number };
+
+let cachedSecret: CachedSecret | null = null;
+let defaultSsmClient: SSMClient | null = null;
+
+export function resetRevalidateSecretCache(): void {
+  cachedSecret = null;
+}
+
+async function readSecretFromSsm(parameterName: string): Promise<string | null> {
+  defaultSsmClient ??= new SSMClient({});
+  const response = await defaultSsmClient.send(new GetParameterCommand({ Name: parameterName, WithDecryption: true }));
+  const value = response.Parameter?.Value?.trim();
+  return value ? value : null;
+}
+
+export async function loadRevalidateSecret(
+  options: { environment?: Record<string, string | undefined>; readSecret?: RevalidateSecretReader; now?: number } = {},
+): Promise<string | null> {
+  const environment = options.environment ?? process.env;
+  const parameterName = environment[REVALIDATE_SECRET_PARAMETER_ENV]?.trim();
+  if (!parameterName) return null;
+  const now = options.now ?? Date.now();
+  if (cachedSecret && cachedSecret.parameterName === parameterName && cachedSecret.expiresAt > now) {
+    return cachedSecret.value;
+  }
+  try {
+    const value = (await (options.readSecret ?? readSecretFromSsm)(parameterName))?.trim();
+    if (!value) return null;
+    cachedSecret = { parameterName, value, expiresAt: now + REVALIDATE_SECRET_CACHE_MILLISECONDS };
+    return value;
+  } catch (error) {
+    console.error(`Revalidate secret parameter could not be read (${error instanceof Error ? error.name : "error"}).`);
+    return null;
+  }
+}
+
+export function secretsMatch(provided: string | null | undefined, expected: string): boolean {
+  const providedBytes = Buffer.from((provided ?? "").trim());
+  const expectedBytes = Buffer.from(expected);
+  return providedBytes.length === expectedBytes.length && timingSafeEqual(providedBytes, expectedBytes);
+}
+
+export async function isAuthorizedRevalidateRequest(
+  providedSecret: string | null | undefined,
+  options: Parameters<typeof loadRevalidateSecret>[0] = {},
+): Promise<boolean> {
+  const expected = await loadRevalidateSecret(options);
+  if (!expected) return false;
+  return secretsMatch(providedSecret, expected);
+}

package/lib/root-route-redirect.ts

@@ -0,0 +1,16 @@
+export type RootSearchParams = Record<string, string | string[] | undefined>;
+
+export function buildRootRedirectTarget(destination: string, searchParams: RootSearchParams | undefined): string {
+  const query = new URLSearchParams();
+  for (const [name, value] of Object.entries(searchParams ?? {})) {
+    if (Array.isArray(value)) {
+      for (const entry of value) query.append(name, entry);
+    } else if (value !== undefined) {
+      query.append(name, value);
+    }
+  }
+  const serialized = query.toString();
+  if (!serialized) return destination;
+  const separator = destination.includes("?") ? "&" : "?";
+  return `${destination}${separator}${serialized}`;
+}

package/lib/site-brand-tenant.ts

@@ -1,27 +1,8 @@
 import path from "node:path";
-import {
-  getSiteBrand,
-  resolveRuntimeSiteBrandId,
-  resolveSiteBrandId,
-  type SiteBrand,
-  type SiteBrandId,
-} from "./site-brand";
+import { getSiteBrand, resolveSiteBrandId, type SiteBrand, type SiteBrandId } from "./site-brand";
 
-export const BRAND_OVERRIDE_COOKIE = "papyrus-site-brand-override";
-
-export function resolveActiveSiteBrandId(
-  cookieOverride: string | undefined | null = null,
-  envBrandId: SiteBrandId = resolveSiteBrandId(),
-): SiteBrandId {
-  return resolveRuntimeSiteBrandId(cookieOverride) ?? envBrandId;
-}
-
-export function resolveActiveSiteBrand(
-  cookieOverride: string | undefined | null = null,
-  brandId?: SiteBrandId,
-): SiteBrand {
-  const resolvedId = brandId ?? resolveActiveSiteBrandId(cookieOverride);
-  return getSiteBrand(resolvedId);
+export function resolveActiveSiteBrand(brandId?: SiteBrandId): SiteBrand {
+  return getSiteBrand(brandId ?? resolveSiteBrandId());
 }
 
 export function resolveBrandConfigPath(relativePath: string): string {