@anthusai/papyrus 1.4.0-next.2 → 1.4.0-next.4

package/components/use-paged-content-item-versions.ts

@@ -0,0 +1,151 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  canonicalContentItemStage,
+  legacyStageKeysToLoad,
+  type ContentItemVersionRecord,
+} from "../lib/content-item-lifecycle";
+import { getContentItemStageDefinitions } from "../lib/site-brand";
+import { loadNewsroomContentItemStagePage } from "./news-desk-taxonomy-client";
+
+const REFRESH_INTERVAL_MILLISECONDS = 30_000;
+
+type StageBucket = {
+  versions: ContentItemVersionRecord[];
+  nextToken: string | null;
+  pagesLoaded: number;
+};
+
+export type PagedContentItemVersions = {
+  versions: ContentItemVersionRecord[];
+  loading: boolean;
+  error: string | null;
+  stageHasMore: (canonicalStage: string) => boolean;
+  loadMoreForStage: (canonicalStage: string) => void;
+};
+
+function mergeFreshFirstPage(existing: StageBucket | undefined, fresh: StageBucket): StageBucket {
+  if (!existing || existing.pagesLoaded <= 1) return fresh;
+  const freshIds = new Set(fresh.versions.map(version => version.id));
+  return {
+    versions: [...fresh.versions, ...existing.versions.filter(version => !freshIds.has(version.id))],
+    nextToken: existing.nextToken,
+    pagesLoaded: existing.pagesLoaded,
+  };
+}
+
+/**
+ * Newest-updated content items per stage, one page per stage to start, more pages on demand.
+ * The periodic refresh re-fetches only first pages and keeps whatever later pages were already loaded.
+ */
+export function usePagedContentItemVersions(options: {
+  enabled: boolean;
+  openedCollapsedUntilOpenedStages: readonly string[];
+}): PagedContentItemVersions {
+  const { enabled, openedCollapsedUntilOpenedStages } = options;
+  const [buckets, setBuckets] = useState<Record<string, StageBucket>>({});
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const bucketsRef = useRef(buckets);
+  const stageKeysBeingExtendedRef = useRef(new Set<string>());
+  const generationRef = useRef(0);
+
+  const openedStagesSignature = openedCollapsedUntilOpenedStages.join(",");
+  const stageKeysToLoad = useMemo(() => {
+    const stageDefinitions = getContentItemStageDefinitions();
+    return [
+      ...stageDefinitions
+        .filter(definition => !definition.collapsedUntilOpened || openedStagesSignature.split(",").includes(definition.key))
+        .map(definition => definition.key),
+      ...legacyStageKeysToLoad(stageDefinitions),
+    ];
+  }, [openedStagesSignature]);
+  const stageKeysToLoadRef = useRef(stageKeysToLoad);
+  stageKeysToLoadRef.current = stageKeysToLoad;
+
+  const storeBuckets = useCallback((update: (previous: Record<string, StageBucket>) => Record<string, StageBucket>) => {
+    const next = update(bucketsRef.current);
+    bucketsRef.current = next;
+    setBuckets(next);
+  }, []);
+
+  const refreshFirstPages = useCallback(async (request: number, isInitial: boolean, stageKeys: readonly string[]) => {
+    if (isInitial) setLoading(true);
+    try {
+      const freshBuckets = await Promise.all(stageKeys.map(async stageKey => {
+        const page = await loadNewsroomContentItemStagePage(stageKey);
+        return [stageKey, { versions: page.versions, nextToken: page.nextToken, pagesLoaded: 1 }] as const;
+      }));
+      if (generationRef.current !== request) return;
+      storeBuckets(previous => {
+        const next = { ...previous };
+        for (const [stageKey, fresh] of freshBuckets) next[stageKey] = mergeFreshFirstPage(previous[stageKey], fresh);
+        return next;
+      });
+      setError(null);
+    } catch (reason: unknown) {
+      if (generationRef.current === request && isInitial) setError(reason instanceof Error ? reason.message : "Could not load newsroom records.");
+    } finally {
+      if (generationRef.current === request && isInitial) setLoading(false);
+    }
+  }, [storeBuckets]);
+
+  useEffect(() => {
+    const request = ++generationRef.current;
+    bucketsRef.current = {};
+    setBuckets({});
+    setError(null);
+    if (!enabled) { setLoading(false); return; }
+    void refreshFirstPages(request, true, stageKeysToLoadRef.current);
+    const refreshWhenVisible = () => {
+      if (document.visibilityState === "visible") void refreshFirstPages(request, false, stageKeysToLoadRef.current);
+    };
+    const interval = window.setInterval(refreshWhenVisible, REFRESH_INTERVAL_MILLISECONDS);
+    document.addEventListener("visibilitychange", refreshWhenVisible);
+    return () => {
+      generationRef.current = request + 1;
+      window.clearInterval(interval);
+      document.removeEventListener("visibilitychange", refreshWhenVisible);
+    };
+  }, [enabled, refreshFirstPages]);
+
+  useEffect(() => {
+    if (!enabled) return;
+    const stageKeysNotLoadedYet = stageKeysToLoad.filter(stageKey => !(stageKey in bucketsRef.current));
+    if (stageKeysNotLoadedYet.length) void refreshFirstPages(generationRef.current, false, stageKeysNotLoadedYet);
+  }, [enabled, refreshFirstPages, stageKeysToLoad]);
+
+  const stageKeysInCanonicalStage = useCallback((canonicalStage: string) => Object.keys(bucketsRef.current)
+    .filter(stageKey => canonicalContentItemStage(stageKey, getContentItemStageDefinitions()) === canonicalStage), []);
+
+  const loadMoreForStage = useCallback((canonicalStage: string) => {
+    const request = generationRef.current;
+    for (const stageKey of stageKeysInCanonicalStage(canonicalStage)) {
+      const bucket = bucketsRef.current[stageKey];
+      if (!bucket?.nextToken || stageKeysBeingExtendedRef.current.has(stageKey)) continue;
+      stageKeysBeingExtendedRef.current.add(stageKey);
+      loadNewsroomContentItemStagePage(stageKey, bucket.nextToken).then(page => {
+        if (generationRef.current !== request) return;
+        storeBuckets(previous => {
+          const current = previous[stageKey] ?? bucket;
+          const knownIds = new Set(current.versions.map(version => version.id));
+          return {
+            ...previous,
+            [stageKey]: {
+              versions: [...current.versions, ...page.versions.filter(version => !knownIds.has(version.id))],
+              nextToken: page.nextToken,
+              pagesLoaded: current.pagesLoaded + 1,
+            },
+          };
+        });
+      }).catch(() => undefined).finally(() => { stageKeysBeingExtendedRef.current.delete(stageKey); });
+    }
+  }, [stageKeysInCanonicalStage, storeBuckets]);
+
+  const stageHasMore = useCallback((canonicalStage: string) => stageKeysInCanonicalStage(canonicalStage)
+    .some(stageKey => Boolean(bucketsRef.current[stageKey]?.nextToken)), [stageKeysInCanonicalStage]);
+
+  const versions = useMemo(() => Object.values(buckets).flatMap(bucket => bucket.versions), [buckets]);
+  return { versions, loading, error, stageHasMore, loadMoreForStage };
+}

package/lib/approved-priming-proof-reports.ts

@@ -1,6 +1,9 @@
+import approvedReport0 from "./approved-priming-proofs/papyrus.json";
+
 /**
  * Priming proof reports a publication owner approved for visitors, keyed by site brand id.
- * A report reaches this map only through a reviewed commit of its
- * `publications/priming-proofs/<brand id>.json` file; see docs/cyclotron-priming.md.
+ * A report reaches this map only through a reviewed commit made by scripts/approve-priming-proof-report.ts.
  */
-export const APPROVED_PRIMING_PROOF_REPORTS: Record<string, unknown> = {};
+export const APPROVED_PRIMING_PROOF_REPORTS: Record<string, unknown> = {
+  "papyrus": approvedReport0,
+};

package/lib/approved-priming-proofs/papyrus.json

@@ -0,0 +1,90 @@
+{
+  "version": "cyclotron-priming-proof/v1",
+  "proofId": "ti-2026-10",
+  "publication": "Anthus Threat Intelligence",
+  "cyclotronId": "papyrus-relevance",
+  "question": "Should this candidate source become a reference for this publication?",
+  "labels": [
+    "include",
+    "exclude"
+  ],
+  "positiveLabel": "include",
+  "decisionModel": "jev:jev-1.13.0",
+  "ranAt": "2026-10-18T13:34:13.426310Z",
+  "heldOut": {
+    "size": 10,
+    "byLabel": {
+      "include": 5,
+      "exclude": 5
+    },
+    "fingerprint": "b12fe63012c925bd6def343a13b94ccedafd5184ddb93c8312998486045da779",
+    "frozenAt": "2026-10-18T13:02:20.090030Z",
+    "source": "References editors reviewed in the Newsroom, labeled by the scope-training rule"
+  },
+  "priming": {
+    "acceptedExamples": 13,
+    "excludedBecauseInHeldOut": 0,
+    "fingerprint": null,
+    "source": "editor reviews of References",
+    "order": "reviews in review order, then priming examples in acceptance order"
+  },
+  "conditions": {
+    "freshStorePerPoint": true,
+    "rubric": "publication doctrine seed",
+    "optimizer": false,
+    "reviewProgram": false
+  },
+  "points": [
+    {
+      "labels": 0,
+      "labelsByClass": {
+        "include": 0,
+        "exclude": 0
+      },
+      "decided": 10,
+      "agreement": 1,
+      "precision": 1,
+      "recall": 1,
+      "confusion": {
+        "truePositives": 5,
+        "falsePositives": 0,
+        "trueNegatives": 5,
+        "falseNegatives": 0
+      }
+    },
+    {
+      "labels": 5,
+      "labelsByClass": {
+        "include": 4,
+        "exclude": 1
+      },
+      "decided": 10,
+      "agreement": 1,
+      "precision": 1,
+      "recall": 1,
+      "confusion": {
+        "truePositives": 5,
+        "falsePositives": 0,
+        "trueNegatives": 5,
+        "falseNegatives": 0
+      }
+    },
+    {
+      "labels": 13,
+      "labelsByClass": {
+        "include": 4,
+        "exclude": 9
+      },
+      "decided": 10,
+      "agreement": 0.9,
+      "precision": 1,
+      "recall": 0.8,
+      "confusion": {
+        "truePositives": 4,
+        "falsePositives": 0,
+        "trueNegatives": 5,
+        "falseNegatives": 1
+      }
+    }
+  ]
+}

package/lib/blog-feature-solver.ts

@@ -12,7 +12,7 @@ import {
 } from "./blog-rhythm";
 import { layoutAllTextLines, layoutTextLines, prepareWithSegments, type TextLine, type TextObstacle } from "./pretext-layout";
 
-export type FeaturedLayoutMode = "obstacle" | "float" | "stacked";
+export type FeaturedLayoutMode = "float" | "stacked";
 
 export type SolvedFeaturedItem = {
   mode: FeaturedLayoutMode;
@@ -92,19 +92,6 @@ export function solveFeaturedItem(input: SolveFeaturedItemInput): SolvedFeatured
   });
   const aspectRatio = getImageAspectRatio(input.imageAsset);
 
-  if (mode === "obstacle") {
-    return solveObstacleFeaturedItem({
-      prepared,
-      containerWidth: input.containerWidth,
-      viewportWidth: input.viewportWidth,
-      rhythm,
-      textStyle: input.textStyle,
-      aspectRatio,
-      gap,
-      imageAsset: input.imageAsset,
-    });
-  }
-
   if (mode === "float") {
     return solveFloatFeaturedItem({
       prepared,
@@ -151,96 +138,6 @@ type PreparedSolveInput = {
   imageAsset: ArticleImageAsset;
 };
 
-function solveObstacleFeaturedItem(input: PreparedSolveInput): SolvedFeaturedItem {
-  const maxImageWidth = getFloatImageWidth(input);
-  let best: {
-    score: number;
-    textLines: TextLine[];
-    imageHeight: number;
-    imageWidth: number;
-    captionHeight: number;
-    mediaHeight: number;
-    copyWidth: number;
-    textFrameHeight: number;
-    hasMore: boolean;
-  } | null = null;
-
-  for (const imageWidth of getObstacleImageWidths(maxImageWidth, input.rhythm)) {
-    const copyWidth = Math.max(
-      getFloatCopyMinimum(input.viewportWidth, input.rhythm),
-      input.containerWidth - imageWidth - input.gap,
-    );
-    const imageHeight = snapImageHeight(imageWidth / input.aspectRatio, input.rhythm, input.imageAsset.layout);
-    const captionHeight = getFeatureCaptionHeight(input.imageAsset, imageWidth, input.rhythm);
-    const mediaHeight = imageHeight + captionHeight;
-    const obstacle: TextObstacle = {
-      x: Math.max(0, copyWidth - imageWidth),
-      y: 0,
-      width: imageWidth,
-      height: mediaHeight,
-    };
-
-    let candidateHeight = mediaHeight;
-    let result = layoutTextLines({
-      prepared: input.prepared,
-      cursor: { segmentIndex: 0, graphemeIndex: 0 },
-      maxHeight: candidateHeight,
-      maxWidth: copyWidth,
-      lineHeight: input.textStyle.lineHeight,
-      linePaintHeight: input.textStyle.linePaintHeight,
-      fontSize: input.textStyle.fontSize,
-      fontFamily: input.textStyle.fontFamily,
-      obstacles: [obstacle],
-    });
-
-    const textBottom = getMeasuredTextHeight(result.lines);
-    if (textBottom > 0 && textBottom < candidateHeight) {
-      candidateHeight = reserveRhythmRows(textBottom, input.rhythm);
-      obstacle.height = candidateHeight;
-      result = layoutTextLines({
-        prepared: input.prepared,
-        cursor: { segmentIndex: 0, graphemeIndex: 0 },
-        maxHeight: candidateHeight,
-        maxWidth: copyWidth,
-        lineHeight: input.textStyle.lineHeight,
-        linePaintHeight: input.textStyle.linePaintHeight,
-        fontSize: input.textStyle.fontSize,
-        fontFamily: input.textStyle.fontFamily,
-        obstacles: [obstacle],
-      });
-    }
-
-    const whitespace = Math.max(0, candidateHeight - getMeasuredTextHeight(result.lines));
-    const score = 50_000 - whitespace * 1.4 - Math.abs(candidateHeight - mediaHeight) * 0.35 - Math.abs(maxImageWidth - imageWidth) * 0.2;
-    const candidate = {
-      score,
-      textLines: result.lines,
-      imageHeight: Math.min(imageHeight, candidateHeight),
-      imageWidth,
-      captionHeight,
-      mediaHeight: candidateHeight,
-      copyWidth,
-      textFrameHeight: reserveRhythmRows(getMeasuredTextHeight(result.lines), input.rhythm),
-      hasMore: result.hasMore,
-    };
-    if (!best || candidate.score > best.score) best = candidate;
-  }
-
-  const fallbackImageHeight = input.rhythm.rowHeight * 6;
-  return {
-    mode: "obstacle",
-    textLines: best?.textLines ?? [],
-    imageHeight: best?.imageHeight ?? fallbackImageHeight,
-    imageWidth: best?.imageWidth ?? maxImageWidth,
-    captionHeight: best?.captionHeight ?? 0,
-    mediaHeight: best?.mediaHeight ?? fallbackImageHeight,
-    copyWidth: best?.copyWidth ?? input.containerWidth,
-    textFrameHeight: best?.textFrameHeight ?? 0,
-    hasMore: best?.hasMore ?? false,
-    gap: input.gap,
-  };
-}
-
 function solveFloatFeaturedItem(input: PreparedSolveInput): SolvedFeaturedItem {
   const geometry = computeFloatGeometry({
     containerWidth: input.containerWidth,
@@ -417,11 +314,6 @@ function getFloatCopyMinimum(viewportWidth: number, rhythm: VerticalRhythm): num
   return rhythmLengthRows(viewportWidth <= 600 ? FLOAT_COPY_MIN_PHONE_ROWS : FLOAT_COPY_MIN_DESKTOP_ROWS, rhythm);
 }
 
-function getObstacleImageWidths(maximum: number, rhythm: VerticalRhythm): number[] {
-  const candidateRows = [0, 1, 2].map((offset) => Math.max(rhythm.rowHeight * 5, maximum - (offset * rhythm.rowHeight)));
-  return Array.from(new Set(candidateRows));
-}
-
 function snapImageHeight(
   naturalHeight: number,
   rhythm: VerticalRhythm,

package/lib/content-actions-demo.ts

@@ -12,6 +12,7 @@ import {
   demoContentHash,
   type DemoArticleRecord,
 } from "./newsroom-demo-articles";
+import { createLocalPreviewEditableArticle } from "./local-preview-seed";
 import { sourceLineOffset, type ArticlesBackend, type EditableArticle, type NewsroomArticleRow } from "./newsroom-articles";
 
 function titleFromYaml(frontMatterYaml: string | null, fallback: string): string {
@@ -171,6 +172,8 @@ export function createDemoArticlesBackend(): ArticlesBackend {
         .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
     },
     async loadArticle(id: string): Promise<EditableArticle> {
+      const previewRecord = records.get(id) ? null : createLocalPreviewEditableArticle(id);
+      if (previewRecord) return previewRecord;
       const record = requireRecord(id);
       return {
         id: record.id,

package/lib/front-mosaic.ts

@@ -1,3 +1,4 @@
+import { warnAboutMissingMedia } from "./layout-warnings";
 import {
   type ArticleFrameBlockSpec,
   type ArticleFrameCompositionSlotSpec,
@@ -605,7 +606,7 @@ function solveComposedFrontArticleFrame(
         flow.usedImageAssetIds,
       );
       if (!image) {
-        if (mediaSpec?.required) throw new Error(`${blockSpec.id} requires media slot ${slot.mediaIndex ?? 0} but no image could be solved`);
+        if (mediaSpec?.required) warnAboutMissingMedia(`${blockSpec.id} requires media slot ${slot.mediaIndex ?? 0} but no image could be solved and renders without it`);
         continue;
       }
       const stackTop = getOccupiedColumnBottom(columnBottoms, image.columnStart, image.columnSpan);

package/lib/layout-plan.ts

@@ -1,3 +1,4 @@
+import { warnAboutMissingMedia } from "./layout-warnings";
 import { z } from "zod";
 import {
   type PublicationItem,
@@ -894,7 +895,7 @@ function validateBlock(
   if (block.type === "mediaCluster") {
     const assets = findAssetsByRole(item, block.assetRole);
     if (block.required && assets.length < block.count.min) {
-      throw new Error(`${label}.${block.id} requires at least ${block.count.min} media assets`);
+      warnAboutMissingMedia(`${label}.${block.id} requires at least ${block.count.min} media assets`);
     }
   }
 }
@@ -902,7 +903,7 @@ function validateBlock(
 function validateMediaSpec(item: PublicationItem, media: LayoutMediaSpec, label: string): void {
   const matchingAssets = findAssetsByRole(item, media.assetRole);
   if (media.required && matchingAssets.length === 0) {
-    throw new Error(`${label} requires an image asset${media.assetRole ? ` with role ${media.assetRole}` : ""}`);
+    warnAboutMissingMedia(`${label} requires an image asset${media.assetRole ? ` with role ${media.assetRole}` : ""} and renders without it`);
   }
 }
 

package/lib/layout-warnings.ts

@@ -0,0 +1,8 @@
+const missingMediaWarningsAlreadyLogged = new Set<string>();
+
+/** A story without its lead image must still publish; the layout renders without the slot. */
+export function warnAboutMissingMedia(message: string): void {
+  if (missingMediaWarningsAlreadyLogged.has(message)) return;
+  missingMediaWarningsAlreadyLogged.add(message);
+  console.warn(`[layout-plan] ${message}`);
+}

package/lib/local-preview-seed.ts

@@ -1,4 +1,5 @@
 import type { AssignmentRecord, ReferenceRecord } from "./category-repository";
+import type { EditableArticle } from "./newsroom-articles";
 import { contentItemStageKeys, type ContentItemVersionRecord } from "./content-item-lifecycle";
 import { getContentItemStageDefinitions } from "./site-brand";
 
@@ -93,3 +94,22 @@ export function createLocalPreviewAssignments(): AssignmentRecord[] {
   }));
   return [...assignmentsOnContentItems, ...assignmentsWithoutContentItem];
 }
+
+export function createLocalPreviewEditableArticle(id: string): EditableArticle | null {
+  const version = createLocalPreviewContentItemVersions().find(candidate => candidate.id === id);
+  if (!version) return null;
+  const headline = version.headline || version.title || version.slug;
+  return {
+    id: version.id,
+    type: version.type,
+    section: version.section ?? null,
+    slug: version.slug,
+    frontMatterYaml: `title: ${headline}\nsection: ${version.section ?? ""}`,
+    bodyMarkus: `# ${headline}\n\nThe local preview shows this story's record. Its full body text is loaded from the live backend.`,
+    contentHash: null,
+    status: version.status === "published" ? "published" : "draft",
+    versionNumber: version.versionNumber,
+    aliases: [],
+    everPublished: version.status === "published",
+  };
+}

package/lib/newsroom-assignments.ts

@@ -18,6 +18,19 @@ export type AssignmentMetrics = {
   canceled: number;
 };
 
+export const BOOKKEEPING_ASSIGNMENT_TYPE_KEYS: ReadonlySet<string> = new Set([
+  "analysis.reindex",
+  "curation.reference-intake",
+  "reference.corpus-accession",
+  "reference.identifier-backfill",
+  "reference.doi-backfill",
+  "reference.text-extraction",
+]);
+
+export function isEditorialWorkAssignment(assignment: Pick<AssignmentRecord, "assignmentTypeKey">): boolean {
+  return !BOOKKEEPING_ASSIGNMENT_TYPE_KEYS.has(assignment.assignmentTypeKey?.trim() ?? "");
+}
+
 export function assignmentTypeKeyForFilter(assignment: AssignmentRecord): string {
   return assignment.assignmentTypeKey?.trim() || "unknown";
 }

package/lib/newsroom-board.ts

@@ -114,6 +114,31 @@ export function assignmentBoardConfig(issues: readonly NativeBoardIssue[]): Kanb
     .map(status => ({ key: `${ASSIGNMENT_BOARD_TYPE}/${status}`, name: assignmentStatusLabel(status) })));
 }
 
+function matchesDesk(candidate: string | null | undefined, deskId: string): boolean {
+  return Boolean(candidate) && candidate!.trim().toLowerCase() === deskId.trim().toLowerCase();
+}
+
+export function deskContainsContentItem(version: ContentItemVersionRecord, deskId: string): boolean {
+  return matchesDesk(version.section, deskId);
+}
+
+export function deskContainsAssignment(assignment: AssignmentRecord, deskId: string): boolean {
+  return matchesDesk(assignment.sectionId, deskId) || matchesDesk(assignment.sectionKey, deskId);
+}
+
+/** A desk board shows stories and assignments side by side; each keeps its own columns and the type filter narrows to one. */
+export function deskBoardConfig(issues: readonly NativeBoardIssue[]): KanbanConfig {
+  const storiesConfig = contentItemBoardConfig(issues.filter(issue => issue.kind === "contentItem"));
+  const assignmentsConfig = assignmentBoardConfig(issues.filter(issue => issue.kind === "assignment"));
+  return {
+    ...storiesConfig,
+    types: [...(storiesConfig.types ?? []), ...(assignmentsConfig.types ?? [])],
+    statuses: [...storiesConfig.statuses, ...assignmentsConfig.statuses],
+    categories: storiesConfig.categories,
+    workflows: { ...storiesConfig.workflows, ...assignmentsConfig.workflows },
+  };
+}
+
 export function canReadNewsroomBoard(phase: string | undefined): boolean {
   return phase === "ready";
 }

package/lib/prospectus-account-client.ts

@@ -0,0 +1,64 @@
+export interface ProspectusPublishingAccountChoice {
+  accountId: string;
+  name?: string;
+  role: string;
+}
+
+export type ProspectusAccountState =
+  | { status: "unavailable" }
+  | { status: "signedOut"; signInUrl: string }
+  | {
+      status: "signedIn";
+      publishingAccounts: ProspectusPublishingAccountChoice[];
+      selectedAccountId: string | null;
+      cyclotronLabAccess: boolean;
+    };
+
+type FetchImplementation = (input: string, init?: RequestInit) => Promise<Response>;
+
+const SESSION_PATH = "/api/auth/prospectus/session";
+const SELECTION_PATH = "/api/auth/prospectus/selection";
+const SIGN_IN_PATH = "/api/auth/prospectus/sign-in";
+
+export function prospectusSignInUrl(returnPath: string): string {
+  return `${SIGN_IN_PATH}?returnTo=${encodeURIComponent(returnPath)}`;
+}
+
+export async function loadProspectusAccountState(
+  returnPath: string,
+  fetchImplementation: FetchImplementation = fetch,
+): Promise<ProspectusAccountState> {
+  let response: Response;
+  try {
+    response = await fetchImplementation(SESSION_PATH, { credentials: "same-origin", cache: "no-store" });
+  } catch {
+    return { status: "unavailable" };
+  }
+  if (!response.ok) return { status: "unavailable" };
+  const body = await response.json().catch(() => null) as
+    | { signedIn?: boolean; publishingAccounts?: ProspectusPublishingAccountChoice[]; selectedAccountId?: string | null; cyclotronLabAccess?: boolean }
+    | null;
+  if (!body) return { status: "unavailable" };
+  if (!body.signedIn) return { status: "signedOut", signInUrl: prospectusSignInUrl(returnPath) };
+  return {
+    status: "signedIn",
+    publishingAccounts: Array.isArray(body.publishingAccounts) ? body.publishingAccounts : [],
+    selectedAccountId: body.selectedAccountId ?? null,
+    cyclotronLabAccess: body.cyclotronLabAccess === true,
+  };
+}
+
+export async function selectProspectusAccount(
+  accountId: string,
+  fetchImplementation: FetchImplementation = fetch,
+): Promise<{ selectedAccountId: string; role: string } | { error: string }> {
+  const response = await fetchImplementation(SELECTION_PATH, {
+    method: "POST",
+    credentials: "same-origin",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ accountId }),
+  });
+  const body = await response.json().catch(() => null) as { selectedAccountId?: string; role?: string; message?: string } | null;
+  if (!response.ok || !body?.selectedAccountId) return { error: body?.message ?? "That account could not be selected." };
+  return { selectedAccountId: body.selectedAccountId, role: body.role ?? "" };
+}

package/lib/site-stack.ts

@@ -149,7 +149,7 @@ export const PILOBOL_US_THEME_PACK_TOKENS: ThemePackTokens = {
 };
 
 /**
- * Anthus palette, read off the live Gatsby site at `AnthusAI/Anth.us`
+ * Anthus palette, read off the live Gatsby site at `AnthusAI/Anth.us-legacy-Gatsby`
  * (`src/styles/variables.scss` `:root`). Colors only — Shadcn owns typography.
  * Mapping from that file's names to the pack's slots:
  *

package/package.json

@@ -84,6 +84,7 @@
     "./components/newsroom-access-gate": "./components/newsroom-access-gate.tsx",
     "./components/newsroom-article-editor": "./components/newsroom-article-editor.tsx",
     "./components/newsroom-articles-view": "./components/newsroom-articles-view.tsx",
+    "./components/newsroom-assignment-detail": "./components/newsroom-assignment-detail.tsx",
     "./components/newsroom-assignments-view": "./components/newsroom-assignments-view.tsx",
     "./components/newsroom-board-view": "./components/newsroom-board-view.tsx",
     "./components/newsroom-client-shell": "./components/newsroom-client-shell.tsx",
@@ -135,6 +136,7 @@
     "./components/use-blog-header-obstacles": "./components/use-blog-header-obstacles.ts",
     "./components/use-brand-fonts-ready": "./components/use-brand-fonts-ready.ts",
     "./components/use-near-viewport": "./components/use-near-viewport.ts",
+    "./components/use-paged-content-item-versions": "./components/use-paged-content-item-versions.ts",
     "./components/use-resolved-papyrus-theme": "./components/use-resolved-papyrus-theme.ts",
     "./components/use-rhythm-overlay": "./components/use-rhythm-overlay.ts",
     "./lib/amplify-outputs-guard": "./lib/amplify-outputs-guard.ts",
@@ -181,6 +183,7 @@
     "./lib/layout-plan": "./lib/layout-plan.ts",
     "./lib/layout-scenarios": "./lib/layout-scenarios.ts",
     "./lib/layout-types": "./lib/layout-types.ts",
+    "./lib/layout-warnings": "./lib/layout-warnings.ts",
     "./lib/local-preview-seed": "./lib/local-preview-seed.ts",
     "./lib/local-preview": "./lib/local-preview.ts",
     "./lib/markus-body": "./lib/markus-body.ts",
@@ -219,6 +222,7 @@
     "./lib/presentation-footer": "./lib/presentation-footer.ts",
     "./lib/pretext-layout": "./lib/pretext-layout.ts",
     "./lib/priming-proof-report": "./lib/priming-proof-report.ts",
+    "./lib/prospectus-account-client": "./lib/prospectus-account-client.ts",
     "./lib/prospectus-publication-access": "./lib/prospectus-publication-access.ts",
     "./lib/prospectus-session": "./lib/prospectus-session.ts",
     "./lib/prospectus-sign-in-routes": "./lib/prospectus-sign-in-routes.ts",
@@ -350,7 +354,7 @@
       "optional": true
     }
   },
-  "version": "1.4.0-next.2",
+  "version": "1.4.0-next.4",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",
@@ -376,7 +380,9 @@
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "cyclotron": "https://github.com/AnthusAI/Cyclotron/releases/download/ui-v0.2.2/cyclotron-0.2.2.tgz",
+    "d3": "^7.9.0",
     "esbuild": "^0.28.2",
+    "framer-motion": "^14.3.0",
     "gray-matter": "^4.0.3",
     "gsap": "^3.15.0",
     "lucide-react": "^1.16.0",
@@ -385,6 +391,7 @@
     "shadcn": "^4.8.0",
     "tailwind-merge": "^3.6.0",
     "tailwindcss": "^4.3.0",
+    "three": "^0.186.1",
     "tsx": "^4.23.15",
     "tw-animate-css": "^1.4.0",
     "use-stick-to-bottom": "^1.1.4",