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

package/lib/newsroom-forum-routes.ts

@@ -1,3 +1,5 @@
+import { toPublicNewsroomPath } from "./newsroom-base-path";
+
 export const FORUM_THREAD_ROUTE_PREFIX = "/newsroom/forum/";
 export const INSIGHT_THREAD_ROUTE_PREFIX = "/newsroom/insights/";
 export const FORUM_MESSAGE_HASH_PREFIX = "message-";
@@ -81,7 +83,7 @@ export function buildForumThreadUrl(
   if (options?.demo) params.set("demo", "1");
   const query = params.toString();
   const hash = options?.messageId ? getForumMessageAnchorId(options.messageId) : "";
-  return `/newsroom/forum/${encodedThreadId}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`;
+  return toPublicNewsroomPath(`/newsroom/forum/${encodedThreadId}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`);
 }
 
 export function buildInsightThreadUrl(
@@ -93,7 +95,7 @@ export function buildInsightThreadUrl(
   if (options?.demo) params.set("demo", "1");
   const query = params.toString();
   const hash = options?.messageId ? getForumMessageAnchorId(options.messageId) : "";
-  return `${INSIGHT_THREAD_ROUTE_PREFIX}${encodedThreadId}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`;
+  return toPublicNewsroomPath(`${INSIGHT_THREAD_ROUTE_PREFIX}${encodedThreadId}${query ? `?${query}` : ""}${hash ? `#${hash}` : ""}`);
 }
 
 export function buildThreadUrlForSurface(
@@ -141,7 +143,7 @@ export function buildNewsroomForumIndexUrl(demo?: boolean): string {
   const params = new URLSearchParams();
   if (demo) params.set("demo", "1");
   const query = params.toString();
-  return query ? `/newsroom?${query}` : "/newsroom";
+  return toPublicNewsroomPath(query ? `/newsroom?${query}` : "/newsroom");
 }
 
 export function buildNewsroomInsightsIndexUrl(demo?: boolean, domain?: string): string {
@@ -149,5 +151,5 @@ export function buildNewsroomInsightsIndexUrl(demo?: boolean, domain?: string):
   if (demo) params.set("demo", "1");
   if (domain?.trim()) params.set("domain", domain.trim());
   const query = params.toString();
-  return query ? `/newsroom/insights?${query}` : "/newsroom/insights";
+  return toPublicNewsroomPath(query ? `/newsroom/insights?${query}` : "/newsroom/insights");
 }

package/lib/newsroom-index-filters.ts

@@ -1,3 +1,4 @@
+import { browserPathToInternalNewsroomPath, toPublicNewsroomPath } from "./newsroom-base-path";
 export type NewsroomIndexTab = "references" | "messages" | "assignments" | "insights";
 
 export type ReferenceIndexOrder = "published" | "imported";
@@ -147,10 +148,10 @@ export function buildNewsroomIndexWebPath(
   tab: NewsroomIndexTab,
   filters: ReferencesIndexFilters | MessagesIndexFilters | AssignmentsIndexFilters | InsightsIndexFilters,
 ): string {
-  if (tab === "references") return `/newsroom/references${buildReferencesIndexQuery(filters as ReferencesIndexFilters)}`;
-  if (tab === "messages") return `/newsroom/messages${buildMessagesIndexQuery(filters as MessagesIndexFilters)}`;
-  if (tab === "insights") return `/newsroom/insights${buildInsightsIndexQuery(filters as InsightsIndexFilters)}`;
-  return `/newsroom/assignments${buildAssignmentsIndexQuery(filters as AssignmentsIndexFilters)}`;
+  if (tab === "references") return toPublicNewsroomPath(`/newsroom/references${buildReferencesIndexQuery(filters as ReferencesIndexFilters)}`);
+  if (tab === "messages") return toPublicNewsroomPath(`/newsroom/messages${buildMessagesIndexQuery(filters as MessagesIndexFilters)}`);
+  if (tab === "insights") return toPublicNewsroomPath(`/newsroom/insights${buildInsightsIndexQuery(filters as InsightsIndexFilters)}`);
+  return toPublicNewsroomPath(`/newsroom/assignments${buildAssignmentsIndexQuery(filters as AssignmentsIndexFilters)}`);
 }
 
 export function syncBrowserNewsroomIndexUrl(
@@ -168,8 +169,9 @@ export function syncBrowserNewsroomIndexUrl(
 
 /** Lineage id from `/newsroom/references/<id>` (not index-only URLs). */
 export function parseReferenceLineageIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
-  if (!pathname?.startsWith("/newsroom/references/")) return null;
-  const segment = pathname.slice("/newsroom/references/".length).split("/")[0]?.trim() ?? "";
+  const internalPathname = pathname ? browserPathToInternalNewsroomPath(pathname) : null;
+  if (!internalPathname?.startsWith("/newsroom/references/")) return null;
+  const segment = internalPathname.slice("/newsroom/references/".length).split("/")[0]?.trim() ?? "";
   if (!segment) return null;
   try {
     return decodeURIComponent(segment);
@@ -180,8 +182,9 @@ export function parseReferenceLineageIdFromNewsroomPathname(pathname: string | n
 
 /** Assignment id from `/newsroom/assignments/<id>` (not index-only URLs). */
 export function parseAssignmentIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
-  if (!pathname?.startsWith("/newsroom/assignments/")) return null;
-  const segment = pathname.slice("/newsroom/assignments/".length).split("/")[0]?.trim() ?? "";
+  const internalPathname = pathname ? browserPathToInternalNewsroomPath(pathname) : null;
+  if (!internalPathname?.startsWith("/newsroom/assignments/")) return null;
+  const segment = internalPathname.slice("/newsroom/assignments/".length).split("/")[0]?.trim() ?? "";
   if (!segment) return null;
   try {
     return decodeURIComponent(segment);
@@ -191,8 +194,9 @@ export function parseAssignmentIdFromNewsroomPathname(pathname: string | null |
 }
 
 export function parseInsightThreadIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
-  if (!pathname?.startsWith("/newsroom/insights/")) return null;
-  const segment = pathname.slice("/newsroom/insights/".length).split("/")[0]?.trim() ?? "";
+  const internalPathname = pathname ? browserPathToInternalNewsroomPath(pathname) : null;
+  if (!internalPathname?.startsWith("/newsroom/insights/")) return null;
+  const segment = internalPathname.slice("/newsroom/insights/".length).split("/")[0]?.trim() ?? "";
   if (!segment) return null;
   try {
     return decodeURIComponent(segment);

package/lib/newsroom-media-backend.ts

@@ -0,0 +1,142 @@
+import { generateClient } from "aws-amplify/data";
+import { getUrl, uploadData } from "aws-amplify/storage";
+import type { Schema } from "../amplify/data/resource";
+import type { MediaAssetFields, MediaAssetRecord, NewsroomMediaBackend } from "./newsroom-media";
+
+type MediaListPage = {
+  data?: (Record<string, unknown> | null)[] | null;
+  nextToken?: string | null;
+  errors?: { message?: string }[] | null;
+};
+
+export type MediaDataClient = {
+  models: {
+    MediaAsset: {
+      create: (
+        input: MediaAssetFields,
+        options: { authMode: "userPool" },
+      ) => Promise<{ errors?: { message?: string }[] | null }>;
+      listMediaAssetsByItemAndSortKey: (
+        input: { itemId: string },
+        options: { authMode: "userPool"; nextToken?: string | null; limit?: number },
+      ) => Promise<MediaListPage>;
+    };
+  };
+};
+
+export type MediaStorageApi = {
+  upload: (input: { path: string; data: Blob; contentType: string }) => Promise<void>;
+  signedUrl: (path: string) => Promise<string>;
+};
+
+function failOnErrors(errors: { message?: string }[] | null | undefined): void {
+  if (errors && errors.length > 0) {
+    throw new Error(errors.map((error) => error.message ?? "GraphQL error").join("; "));
+  }
+}
+
+function srcPathFromMetadata(metadata: unknown): string | null {
+  let parsed = metadata;
+  if (typeof metadata === "string") {
+    try {
+      parsed = JSON.parse(metadata);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const srcPath = (parsed as Record<string, unknown>).srcPath;
+  return typeof srcPath === "string" ? srcPath : null;
+}
+
+export function createMediaBackend(client: () => MediaDataClient, storage: MediaStorageApi): NewsroomMediaBackend {
+  return {
+    uploadImage: ({ storagePath, data, contentType }) =>
+      storage.upload({ path: storagePath, data, contentType }),
+    async createMediaAsset(fields) {
+      const response = await client().models.MediaAsset.create(fields, { authMode: "userPool" });
+      failOnErrors(response.errors);
+    },
+    async listMediaAssets(itemId) {
+      const records: MediaAssetRecord[] = [];
+      let nextToken: string | null | undefined = null;
+      do {
+        const page: MediaListPage = await client().models.MediaAsset.listMediaAssetsByItemAndSortKey(
+          { itemId },
+          { authMode: "userPool", nextToken, limit: 500 },
+        );
+        failOnErrors(page.errors);
+        for (const row of page.data ?? []) {
+          if (!row) continue;
+          records.push({
+            id: String(row.id),
+            sortKey: String(row.sortKey),
+            storagePath: typeof row.storagePath === "string" ? row.storagePath : null,
+            alt: typeof row.alt === "string" ? row.alt : "",
+            srcPath: srcPathFromMetadata(row.metadata),
+          });
+        }
+        nextToken = page.nextToken;
+      } while (nextToken);
+      return records;
+    },
+    imageUrl: (storagePath) => storage.signedUrl(storagePath),
+  };
+}
+
+const amplifyStorage: MediaStorageApi = {
+  async upload({ path, data, contentType }) {
+    await uploadData({ path, data, options: { contentType } }).result;
+  },
+  async signedUrl(path) {
+    const { url } = await getUrl({ path });
+    return url.toString();
+  },
+};
+
+export function createLiveMediaBackend(): NewsroomMediaBackend {
+  let client: MediaDataClient | null = null;
+  return createMediaBackend(() => {
+    if (!client) client = generateClient<Schema>() as unknown as MediaDataClient;
+    return client;
+  }, amplifyStorage);
+}
+
+export function createDemoMediaBackend(): NewsroomMediaBackend {
+  const objects = new Map<string, Blob>();
+  const rows = new Map<string, MediaAssetFields[]>();
+  return {
+    async uploadImage({ storagePath, data }) {
+      objects.set(storagePath, data);
+    },
+    async createMediaAsset(fields) {
+      rows.set(fields.itemId, [...(rows.get(fields.itemId) ?? []), fields]);
+    },
+    async listMediaAssets(itemId) {
+      return (rows.get(itemId) ?? []).map((fields) => ({
+        id: fields.id,
+        sortKey: fields.sortKey,
+        storagePath: fields.storagePath,
+        alt: fields.alt,
+        srcPath: srcPathFromMetadata(fields.metadata),
+      }));
+    },
+    async imageUrl(storagePath) {
+      const object = objects.get(storagePath);
+      if (!object) throw new Error(`No demo object at ${storagePath}.`);
+      return URL.createObjectURL(object);
+    },
+  };
+}
+
+let liveBackend: NewsroomMediaBackend | null = null;
+let demoBackend: NewsroomMediaBackend | null = null;
+
+export function resolveMediaBackend(demo: boolean): NewsroomMediaBackend {
+  if (demo) {
+    demoBackend ??= createDemoMediaBackend();
+    return demoBackend;
+  }
+  liveBackend ??= createLiveMediaBackend();
+  return liveBackend;
+}

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/oauth-redirect-priority.ts

@@ -0,0 +1,40 @@
+function originOf(value: string): string {
+  const trimmed = value.replace(/\/+$/, "");
+  try {
+    const parsed = new URL(trimmed);
+    const hostname = parsed.hostname === "127.0.0.1" || parsed.hostname === "::1" ? "localhost" : parsed.hostname;
+    return `${parsed.protocol}//${hostname}${parsed.port ? `:${parsed.port}` : ""}`;
+  } catch {
+    return trimmed;
+  }
+}
+
+function pathOf(value: string): string | null {
+  try {
+    return new URL(value).pathname.replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Puts the redirect URLs of the current origin first; among those, the
+ * newsroom return path leads when the site has one, so Amplify (which signs in
+ * with the first entry) returns an editor to the newsroom.
+ */
+export function prioritizeRedirectUrlsForOrigin(
+  urls: readonly string[],
+  currentOrigin: string,
+  publicNewsroomBasePath: string,
+): string[] {
+  const origin = originOf(currentOrigin);
+  const newsroomPath = publicNewsroomBasePath.replace(/\/+$/, "");
+  const head = urls.filter((value) => originOf(value) === origin);
+  if (head.length === 0) return [...urls];
+  const tail = urls.filter((value) => originOf(value) !== origin);
+  const newsroomFirst =
+    newsroomPath === ""
+      ? head
+      : [...head.filter((value) => pathOf(value) === newsroomPath), ...head.filter((value) => pathOf(value) !== newsroomPath)];
+  return [...newsroomFirst, ...tail];
+}

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

package/lib/reference-policy.ts

@@ -17,6 +17,11 @@ export type ReferenceRejectionReasonCode = typeof REFERENCE_REJECTION_REASON_COD
 const REFERENCE_REJECTION_REASON_CODE_SET = new Set<string>(REFERENCE_REJECTION_REASON_CODES);
 const SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET = new Set<string>(["out_of_scope", "policy_exclusion"]);
 
+/** Rejection reasons that say the source is not relevant (scope-training negatives). */
+export function isScopeTrainingNegativeReason(code: string): boolean {
+  return SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET.has(code);
+}
+
 export function normalizeReferenceCurationStatus(value: unknown, defaultStatus: ReferenceCurationStatus = "pending"): ReferenceCurationStatus {
   const normalized = normalizePolicyToken(value ?? defaultStatus);
   if (normalized === "accepted" || normalized === "accept" || normalized === "ready" || normalized === "trusted") return "accepted";