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

package/amplify/functions/shared/python-bundle.js

@@ -126,9 +126,9 @@ function bundleFromPip(outputDir, options) {
 }
 export function bundleFromCheckout(outputDir, options) {
     fs.copyFileSync(path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"), path.join(outputDir, "handler.py"));
-    for (const module of options.modules) {
-        fs.mkdirSync(path.join(outputDir, module), { recursive: true });
-        fs.cpSync(path.join(packageRoot, "src", module), path.join(outputDir, module), { recursive: true });
+    for (const moduleName of options.modules) {
+        fs.mkdirSync(path.join(outputDir, moduleName), { recursive: true });
+        fs.cpSync(path.join(packageRoot, "src", moduleName), path.join(outputDir, moduleName), { recursive: true });
     }
     options.checkoutExtras?.(outputDir);
     copySiteFiles(outputDir, options.siteFiles);

package/amplify/functions/shared/python-bundle.ts

@@ -164,9 +164,9 @@ export function bundleFromCheckout(outputDir: string, options: PythonBundleOptio
     path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"),
     path.join(outputDir, "handler.py"),
   );
-  for (const module of options.modules) {
-    fs.mkdirSync(path.join(outputDir, module), { recursive: true });
-    fs.cpSync(path.join(packageRoot, "src", module), path.join(outputDir, module), { recursive: true });
+  for (const moduleName of options.modules) {
+    fs.mkdirSync(path.join(outputDir, moduleName), { recursive: true });
+    fs.cpSync(path.join(packageRoot, "src", moduleName), path.join(outputDir, moduleName), { recursive: true });
   }
   options.checkoutExtras?.(outputDir);
   copySiteFiles(outputDir, options.siteFiles);

package/app/newsroom/sections/[sectionId]/page.tsx

@@ -1,4 +1,6 @@
 import { notFound } from "next/navigation";
+import { resolveActiveSiteBrand } from "../../../../lib/site-brand-tenant";
+import { NewsroomBoardView } from "../../../../components/newsroom-board-view";
 import { NewsDeskPage } from "../../../../components/news-desk-page";
 
 export const dynamic = "force-dynamic";
@@ -13,5 +15,6 @@ export default async function NewsroomDeepSectionPage({ params, searchParams }:
   const normalizedSectionId = decodeURIComponent(sectionId ?? "").trim();
   if (!normalizedSectionId) notFound();
 
+  if (resolveActiveSiteBrand().newsroomLayout === "organizer") return <NewsroomBoardView subject="desk" deskId={normalizedSectionId} />;
   return <NewsDeskPage sectionPageId={normalizedSectionId} searchParams={searchParams} />;
 }

package/components/news-desk-taxonomy-client.ts

@@ -2172,40 +2172,45 @@ const CONTENT_ITEMS_BY_STAGE_QUERY = `
   }
 `;
 
-export async function loadNewsroomContentItemVersions(options: { includeCollapsedUntilOpenedStages?: readonly string[] } = {}): Promise<ContentItemVersionRecord[]> {
-  const stageDefinitions = getContentItemStageDefinitions();
-  const stagesToLoad = [
-    ...stageDefinitions
-      .filter(definition => !definition.collapsedUntilOpened || options.includeCollapsedUntilOpenedStages?.includes(definition.key))
-      .map(definition => definition.key),
-    ...legacyStageKeysToLoad(stageDefinitions),
-  ];
+export const CONTENT_ITEM_COLUMN_PAGE_LIMIT = 25;
+
+export type ContentItemStagePage = {
+  versions: ContentItemVersionRecord[];
+  nextToken: string | null;
+};
+
+/** One newest-updated-first page of the content items in one stage, so a board column can load as it is scrolled. */
+export async function loadNewsroomContentItemStagePage(
+  stage: string,
+  nextToken: string | null = null,
+  limit: number = CONTENT_ITEM_COLUMN_PAGE_LIMIT,
+): Promise<ContentItemStagePage> {
   if (isLocalPreviewEnabled()) {
-    return createLocalPreviewContentItemVersions().filter(version => stagesToLoad.includes(version.stage ?? ""));
+    const versionsInStage = createLocalPreviewContentItemVersions().filter(version => version.stage === stage);
+    const offset = nextToken ? Number(nextToken) : 0;
+    const followingOffset = offset + limit;
+    return {
+      versions: versionsInStage.slice(offset, followingOffset),
+      nextToken: followingOffset < versionsInStage.length ? String(followingOffset) : null,
+    };
   }
   configureAmplifyClient();
   const client = generateClient<Schema>() as unknown as {
     graphql: (options: Record<string, unknown>) => Promise<GraphQLConnectionResponse<ContentItemVersionRecord>>;
   };
   const field = "listItemsByStageAndUpdatedAt";
-  const versionsPerStage = await Promise.all(stagesToLoad.map(async (stage) => {
-    const versions: ContentItemVersionRecord[] = [];
-    let nextToken: string | null = null;
-    do {
-      const response: GraphQLConnectionResponse<ContentItemVersionRecord> = await client.graphql({
-        query: CONTENT_ITEMS_BY_STAGE_QUERY,
-        variables: { stage, sortDirection: "DESC", limit: NEWSROOM_PAGE_LIMIT, nextToken },
-        authMode: USER_POOL_AUTH_MODE,
-      });
-      assertNoGraphQLErrors(response.errors);
-      const connection = response.data?.[field];
-      if (!connection) throw new Error(`Missing GraphQL connection payload for ${field}.`);
-      versions.push(...((connection.items ?? []).filter(Boolean) as ContentItemVersionRecord[]));
-      nextToken = connection.nextToken ?? null;
-    } while (nextToken);
-    return versions;
-  }));
-  return versionsPerStage.flat();
+  const response: GraphQLConnectionResponse<ContentItemVersionRecord> = await client.graphql({
+    query: CONTENT_ITEMS_BY_STAGE_QUERY,
+    variables: { stage, sortDirection: "DESC", limit, nextToken },
+    authMode: USER_POOL_AUTH_MODE,
+  });
+  assertNoGraphQLErrors(response.errors);
+  const connection = response.data?.[field];
+  if (!connection) throw new Error(`Missing GraphQL connection payload for ${field}.`);
+  return {
+    versions: (connection.items ?? []).filter(Boolean) as ContentItemVersionRecord[],
+    nextToken: connection.nextToken ?? null,
+  };
 }
 
 const PUBLISHED_ITEMS_QUERY = `
@@ -2231,6 +2236,7 @@ type PublishedItemBoardRow = {
 };
 
 export async function loadNewsroomPublishedContentItemVersions(): Promise<ContentItemVersionRecord[]> {
+  if (isLocalPreviewEnabled()) return [];
   configureAmplifyClient();
   const client = generateClient<Schema>() as unknown as {
     graphql: (options: Record<string, unknown>) => Promise<GraphQLConnectionResponse<PublishedItemBoardRow>>;

package/components/newsroom-board-view.tsx

@@ -2,12 +2,10 @@
 
 import { useEffect, useMemo, useRef, useState } from "react";
 import Link from "next/link";
-import { IssueCollection, IssueDetailPanel, useBoardColumnState } from "@kanbus/ui";
+import { IssueCollection, IssueDetailPanel, IssueTypeFilter, issueTypeFromFilter, useBoardColumnState } from "@kanbus/ui";
 import "@kanbus/ui/styles/kanban.css";
 import "./newsroom-newsprint-board.css";
 import { PlusIcon } from "lucide-react";
-import { buttonVariants } from "./ui/button";
-import { cn } from "../lib/utils";
 import { newsroomHref } from "../lib/newsroom-base-path";
 import {
   ASSIGNMENT_BOARD_TYPE,
@@ -15,14 +13,20 @@ import {
   canReadNewsroomBoard,
   contentItemBoardConfig,
   contentItemBoardType,
+  deskBoardConfig,
+  deskContainsAssignment,
+  deskContainsContentItem,
   projectAssignmentBoard,
   projectContentItemBoard,
   type NativeBoardIssue,
 } from "../lib/newsroom-board";
-import type { AssignmentRecord } from "../lib/category-repository";
+import type { AssignmentRecord, NewsroomSectionRecord } from "../lib/category-repository";
+import { displayNewsroomSectionShortTitle } from "../lib/newsroom-sections";
 import { getContentItemName, getContentItemStageDefinitions, SITE_BRAND } from "../lib/site-brand";
 import { getNewsroomNavHref } from "../lib/newsroom-nav";
-import { loadNewsroomAssignmentPage, loadNewsroomContentItemVersions, loadNewsroomPublishedContentItemVersions } from "./news-desk-taxonomy-client";
+import { loadNewsroomAssignmentPage, loadNewsroomPublishedContentItemVersions } from "./news-desk-taxonomy-client";
+import { usePagedContentItemVersions } from "./use-paged-content-item-versions";
+import type { ContentItemVersionRecord } from "../lib/content-item-lifecycle";
 import { useOptionalNewsDeskClient } from "./news-desk-client-provider";
 import { NewsDeskAccessGate } from "./newsroom-access-gate";
 import { NewsroomOpsShell, NewsroomOpsStatusBanner } from "./newsroom-ops-shell";
@@ -31,6 +35,7 @@ import { readLocalReaderSettings, subscribeReaderSettingsChanges } from "./reade
 
 const STATIC_MOTION = { mode: "static" } as const;
 const BOARD_REFRESH_INTERVAL_MILLISECONDS = 30_000;
+const COLUMN_LOAD_MORE_DISTANCE_PIXELS = 240;
 
 async function loadEveryNewsroomAssignment() {
   const assignments: AssignmentRecord[] = [];
@@ -43,81 +48,112 @@ async function loadEveryNewsroomAssignment() {
   return assignments;
 }
 
-export type NewsroomBoardSubject = "contentItem" | "assignment";
+export type NewsroomBoardSubject = "contentItem" | "assignment" | "desk";
 
 /** Read-only board of one record kind over authenticated CMS records; existing workspaces own every mutation. */
-export function NewsroomBoardView({ subject }: { subject: NewsroomBoardSubject }) {
+export function NewsroomBoardView({ subject, deskId }: { subject: NewsroomBoardSubject; deskId?: string }) {
   const session = useOptionalNewsDeskClient();
   const allowed = canReadNewsroomBoard(session?.shell.phase);
   const theme = useResolvedPapyrusTheme();
   const [lowMotion, setLowMotion] = useState(false);
-  const [issues, setIssues] = useState<NativeBoardIssue[]>([]);
+  const [assignmentBoardIssues, setAssignmentBoardIssues] = useState<NativeBoardIssue[]>([]);
+  const [publishedVersions, setPublishedVersions] = useState<ContentItemVersionRecord[]>([]);
+  const [assignments, setAssignments] = useState<AssignmentRecord[]>([]);
   const [view, setView] = useState<"board" | "list">("board");
   const [selected, setSelected] = useState<string | null>(null);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
+  const [supportingRecordsLoading, setSupportingRecordsLoading] = useState(false);
+  const [supportingRecordsError, setSupportingRecordsError] = useState<string | null>(null);
   const generation = useRef(0);
-  const openedCollapsedUntilOpenedStagesRef = useRef<string[]>([]);
-  const refreshIssuesRef = useRef<((initial: boolean) => void) | null>(null);
+  const boardBodyRef = useRef<HTMLDivElement | null>(null);
+  const [typeFilter, setTypeFilter] = useState<string | null>("all");
+  const showsContentItems = subject !== "assignment";
+  const contentItemColumnKeyPrefix = `${contentItemBoardType()}/`;
+  const boardType = subject === "assignment" ? ASSIGNMENT_BOARD_TYPE : contentItemBoardType();
+  const deskAssignmentIssues = useMemo(() => subject === "desk" && deskId
+    ? projectAssignmentBoard(assignments.filter(assignment => deskContainsAssignment(assignment, deskId))) : [], [assignments, deskId, subject]);
+  const columnStateConfig = useMemo(() => subject === "contentItem" ? contentItemBoardConfig([])
+    : subject === "desk" ? deskBoardConfig(deskAssignmentIssues)
+    : assignmentBoardConfig(assignmentBoardIssues), [assignmentBoardIssues, deskAssignmentIssues, subject]);
+  const columnState = useBoardColumnState({ config: columnStateConfig, storageKey: `papyrus.cms.columns.v1.${SITE_BRAND.id}.${subject}` });
+  const openedCollapsedUntilOpenedStages = useMemo(() => !showsContentItems ? [] : getContentItemStageDefinitions()
+    .filter(definition => definition.collapsedUntilOpened && !columnState.collapsedColumns.has(`${contentItemColumnKeyPrefix}${definition.key}`))
+    .map(definition => definition.key), [contentItemColumnKeyPrefix, columnState.collapsedColumns, showsContentItems]);
+  const pagedContentItems = usePagedContentItemVersions({ enabled: allowed && showsContentItems, openedCollapsedUntilOpenedStages });
   useEffect(() => {
     setLowMotion(readLocalReaderSettings().motion === "low");
     return subscribeReaderSettingsChanges(settings => setLowMotion(settings.motion === "low"));
   }, []);
   useEffect(() => {
     const request = ++generation.current;
-    setIssues([]); setSelected(null); setError(null);
-    if (!allowed) { setLoading(false); return; }
-    const loadIssues = () => subject === "contentItem"
-      ? Promise.all([
-        Promise.all([loadNewsroomContentItemVersions({ includeCollapsedUntilOpenedStages: openedCollapsedUntilOpenedStagesRef.current }), loadNewsroomPublishedContentItemVersions()]).then(([workingVersions, publishedVersions]) => [...workingVersions, ...publishedVersions]),
-        loadEveryNewsroomAssignment(),
-      ]).then(([contentItemVersions, assignments]) => projectContentItemBoard({ contentItemVersions, assignments }))
-      : loadEveryNewsroomAssignment().then(projectAssignmentBoard);
+    setAssignmentBoardIssues([]); setPublishedVersions([]); setAssignments([]); setSelected(null); setSupportingRecordsError(null);
+    if (!allowed) { setSupportingRecordsLoading(false); return; }
+    const loadSupportingRecords = () => subject !== "assignment"
+      ? Promise.all([loadNewsroomPublishedContentItemVersions(), loadEveryNewsroomAssignment()]).then(([published, everyAssignment]) => {
+        if (generation.current === request) { setPublishedVersions(published); setAssignments(everyAssignment); }
+      })
+      : loadEveryNewsroomAssignment().then(everyAssignment => {
+        if (generation.current === request) setAssignmentBoardIssues(projectAssignmentBoard(everyAssignment));
+      });
     const refresh = (initial: boolean) => {
-      if (initial) setLoading(true);
-      loadIssues().then(loadedIssues => {
-        if (generation.current !== request) return;
-        setIssues(loadedIssues);
-        setError(null);
+      if (initial) setSupportingRecordsLoading(true);
+      loadSupportingRecords().then(() => {
+        if (generation.current === request) setSupportingRecordsError(null);
       }).catch((reason: unknown) => {
-        if (generation.current === request && initial) setError(reason instanceof Error ? reason.message : "Could not load newsroom records.");
-      }).finally(() => { if (generation.current === request && initial) setLoading(false); });
+        if (generation.current === request && initial) setSupportingRecordsError(reason instanceof Error ? reason.message : "Could not load newsroom records.");
+      }).finally(() => { if (generation.current === request && initial) setSupportingRecordsLoading(false); });
     };
-    refreshIssuesRef.current = refresh;
     refresh(true);
     const refreshWhenVisible = () => { if (document.visibilityState === "visible") refresh(false); };
     const interval = window.setInterval(refreshWhenVisible, BOARD_REFRESH_INTERVAL_MILLISECONDS);
     document.addEventListener("visibilitychange", refreshWhenVisible);
     return () => { generation.current = request + 1; window.clearInterval(interval); document.removeEventListener("visibilitychange", refreshWhenVisible); };
   }, [allowed, subject]);
-  const config = useMemo(() => subject === "contentItem" ? contentItemBoardConfig(issues) : assignmentBoardConfig(issues), [issues, subject]);
-  const boardType = subject === "contentItem" ? contentItemBoardType() : ASSIGNMENT_BOARD_TYPE;
-  const columnState = useBoardColumnState({ config, storageKey: `papyrus.cms.columns.v1.${SITE_BRAND.id}.${subject}` });
-  const openedCollapsedUntilOpenedStageKeys = useMemo(() => subject !== "contentItem" ? "" : getContentItemStageDefinitions()
-    .filter(definition => definition.collapsedUntilOpened && !columnState.collapsedColumns.has(`${boardType}/${definition.key}`))
-    .map(definition => definition.key).join(","), [boardType, columnState.collapsedColumns, subject]);
+  const issues = useMemo(() => {
+    if (subject === "assignment") return assignmentBoardIssues;
+    if (subject === "contentItem") return projectContentItemBoard({ contentItemVersions: [...pagedContentItems.versions, ...publishedVersions], assignments });
+    const versionsOnDesk = [...pagedContentItems.versions, ...publishedVersions].filter(version => deskId && deskContainsContentItem(version, deskId));
+    return [...projectContentItemBoard({ contentItemVersions: versionsOnDesk, assignments: assignments.filter(assignment => deskId && deskContainsAssignment(assignment, deskId)) }), ...deskAssignmentIssues];
+  }, [assignmentBoardIssues, assignments, deskAssignmentIssues, deskId, pagedContentItems.versions, publishedVersions, subject]);
+  const loading = supportingRecordsLoading || (showsContentItems && pagedContentItems.loading);
+  const error = supportingRecordsError ?? (showsContentItems ? pagedContentItems.error : null);
+  const config = useMemo(() => subject === "contentItem" ? contentItemBoardConfig(issues) : subject === "desk" ? deskBoardConfig(issues) : assignmentBoardConfig(issues), [issues, subject]);
+  const columnStageFromElement = (element: Element | null) => {
+    const columnKey = element?.closest("[data-column-key]")?.getAttribute("data-column-key");
+    return columnKey?.startsWith(contentItemColumnKeyPrefix) ? columnKey.slice(contentItemColumnKeyPrefix.length) : null;
+  };
+  const loadMoreWhenColumnIsNearItsEnd = (columnScroll: HTMLElement) => {
+    const distanceToEnd = columnScroll.scrollHeight - columnScroll.scrollTop - columnScroll.clientHeight;
+    const stage = columnStageFromElement(columnScroll);
+    if (stage && distanceToEnd < COLUMN_LOAD_MORE_DISTANCE_PIXELS) pagedContentItems.loadMoreForStage(stage);
+  };
+  const handleBoardScroll = (event: React.UIEvent<HTMLDivElement>) => {
+    const target = event.target as HTMLElement;
+    if (showsContentItems && target.classList?.contains("kb-column-scroll")) loadMoreWhenColumnIsNearItsEnd(target);
+  };
   useEffect(() => {
-    openedCollapsedUntilOpenedStagesRef.current = openedCollapsedUntilOpenedStageKeys ? openedCollapsedUntilOpenedStageKeys.split(",") : [];
-    if (openedCollapsedUntilOpenedStageKeys) refreshIssuesRef.current?.(false);
-  }, [openedCollapsedUntilOpenedStageKeys]);
-  const pageTitle = subject === "contentItem" ? getContentItemName().plural : "Assignments";
+    if (!showsContentItems) return;
+    boardBodyRef.current?.querySelectorAll<HTMLElement>(".kb-column-scroll").forEach(loadMoreWhenColumnIsNearItsEnd);
+  });
+  const deskTitle = session?.shell.dashboard?.newsroomSections?.find(section => section.id === deskId)?.title ?? (deskId ? displayNewsroomSectionShortTitle({ id: deskId } as NewsroomSectionRecord) : "Desk");
+  const pageTitle = subject === "contentItem" ? getContentItemName().plural : subject === "desk" ? deskTitle : "Assignments";
   const issue = issues.find(item => item.id === selected);
   if (!allowed) return <NewsDeskAccessGate shell={session?.shell ?? null} />;
-  return <NewsroomOpsShell activeTab={subject === "contentItem" ? "articles" : "assignments"} appTitle={SITE_BRAND.appTitle} backLabel={SITE_BRAND.backToHomeLabel} pageTitle={pageTitle}
+  return <NewsroomOpsShell activeTab={subject === "contentItem" ? "articles" : subject === "desk" ? "desks" : "assignments"} appTitle={SITE_BRAND.appTitle} backLabel={SITE_BRAND.backToHomeLabel} pageTitle={pageTitle}
     headerActions={<>
-      <div role="group" aria-label="Record presentation" className="organizer-board-view-toggle"><button type="button" aria-pressed={view === "board"} onClick={() => setView("board")}>Board</button><button type="button" aria-pressed={view === "list"} onClick={() => setView("list")}>List</button></div>
-      {subject === "contentItem" && (
-        <Link className={cn(buttonVariants({ size: "sm" }))} data-newsroom-article-new href={getNewsroomNavHref(newsroomHref("articles", "new"))}>
-          <PlusIcon aria-hidden="true" />
+      <span role="status" className="organizer-board-note">{loading ? "Loading records…" : `${issues.length} records loaded.`}</span>
+      <div role="group" aria-label="Record presentation" className="organizer-board-view-toggle"><button type="button" className="organizer-header-button" aria-pressed={view === "board"} onClick={() => setView("board")}>Board</button><button type="button" className="organizer-header-button" aria-pressed={view === "list"} onClick={() => setView("list")}>List</button></div>
+      {showsContentItems && (
+        <Link className="organizer-header-button" data-newsroom-article-new href={getNewsroomNavHref(newsroomHref("articles", "new"))}>
+          <PlusIcon size={14} aria-hidden="true" />
           {`New ${getContentItemName().singular.toLowerCase()}`}
         </Link>
       )}
     </>}>
     <div className="organizer-native-board papyrus-newsprint-board" data-color-mode={theme}>
       {error && <NewsroomOpsStatusBanner tone="error">{error}</NewsroomOpsStatusBanner>}
-      <p role="status" className="organizer-board-note">{loading ? "Loading records…" : `${issues.length} records loaded.`}</p>
-      <div className="organizer-board-body" data-detail-open={Boolean(issue)}>
-        <IssueCollection issues={issues} config={config} query={{ type: boardType }} view={view}
+      {subject === "desk" && <IssueTypeFilter config={config} value={typeFilter} onChange={setTypeFilter} name="Record type" className="organizer-board-type-filter" />}
+      <div className="organizer-board-body" data-detail-open={Boolean(issue)} ref={boardBodyRef} onScrollCapture={handleBoardScroll}>
+        <IssueCollection issues={issues} config={config} query={{ type: subject === "desk" ? issueTypeFromFilter(typeFilter) : boardType }} view={view}
           motion={lowMotion ? STATIC_MOTION : undefined}
           collapsedColumns={columnState.collapsedColumns} onToggleCollapse={columnState.toggleColumn} initialScroll="start"
           selectedIssueId={selected} detailOpen={Boolean(issue)} onSelectIssue={item => setSelected(item.id)} ariaLabel={pageTitle}

package/components/newsroom-organizer.css

@@ -20,7 +20,7 @@ body:has(.newsroom-organizer)>[data-staging-banner]{flex-shrink:0}
 .organizer-destinations a[aria-current=page]{border-bottom:2px solid var(--org-ink);color:var(--org-ink)}
 .newsroom-organizer :is(a,button):focus-visible,.organizer-menu :is(a,button):focus-visible{outline:2px solid currentColor;outline-offset:-3px}
 .organizer-workspace{display:flex;flex-direction:column;min-height:0;min-width:0;overflow:hidden;padding:0 16px}
-.organizer-topbar{height:57px;min-height:57px;display:flex;align-items:center;gap:16px;border-bottom:1px solid var(--org-ink)}
+.organizer-topbar{height:48px;min-height:48px;display:flex;align-items:center;gap:16px;border-bottom:1px solid var(--org-ink)}
 .organizer-masthead{font:900 28px Newsroom Display,Georgia,serif;white-space:nowrap;max-width:30vw;overflow:hidden;text-overflow:ellipsis}
 .organizer-topbar h1{font:400 12px Newsroom UI,system-ui;flex:1;min-width:0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;margin:0}
 .organizer-toggle{display:flex;align-items:center;justify-content:center;width:36px;min-height:36px;padding:0;border:1px solid var(--org-line);flex-shrink:0}
@@ -36,11 +36,12 @@ body:has(.newsroom-organizer)>[data-staging-banner]{flex-shrink:0}
 .organizer-account-popup [role=menuitem]{min-height:40px;font-size:12px}.organizer-account-popup .reader-auth{display:contents}.organizer-account-popup .reader-auth__error{display:block;white-space:normal;font-size:11px;padding:8px}
 .organizer-bottom-nav{display:none}
 .organizer-main:has(.organizer-native-board){display:flex;overflow:hidden}
-.organizer-native-board{display:flex;flex-direction:column;flex:1;min-height:0;min-width:0;gap:12px}
+.organizer-native-board{display:flex;flex-direction:column;flex:1;min-height:0;min-width:0;gap:8px}
 .organizer-board-view-toggle{display:flex;gap:4px;flex-shrink:0}
-.organizer-board-view-toggle button{min-height:36px;padding:4px 12px;border:1px solid var(--org-line)}
-.organizer-board-view-toggle button[aria-pressed=true]{background:var(--org-ink);color:var(--org-paper)}
-.organizer-board-note{font-size:11px;line-height:1.5;margin:0;color:var(--org-muted)}
+.organizer-header-button{display:inline-flex;align-items:center;gap:6px;min-height:36px;padding:4px 12px;border:1px solid var(--org-line);font:inherit;color:inherit;background:transparent;text-decoration:none;white-space:nowrap;cursor:pointer}
+.organizer-header-button[aria-pressed=true]{background:var(--org-ink);color:var(--org-paper)}
+.organizer-board-note{font-size:11px;line-height:1.5;margin:0;color:var(--org-muted);white-space:nowrap}
+@media(min-width:901px){.newsroom-organizer[data-sidebar-collapsed=false] .organizer-masthead{display:none}}
 .organizer-board-body{position:relative;display:grid;grid-template-columns:minmax(0,1fr);flex:1;min-width:0;min-height:0;gap:16px}
 .organizer-board-body[data-detail-open=true]{grid-template-columns:minmax(0,1fr) minmax(280px,360px)}
 .organizer-board-body>.kb-issue-collection{height:100%;min-height:0;overflow:auto}
@@ -50,6 +51,7 @@ body:has(.newsroom-organizer)>[data-staging-banner]{flex-shrink:0}
 .organizer-menu .organizer-destinations{overflow-y:auto}.organizer-menu .organizer-destinations section{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}.organizer-menu .organizer-destinations h3{grid-column:1/-1;font-size:12px;text-transform:none;margin:0 0 4px}
 .organizer-menu .organizer-destinations a{border:1px solid var(--org-line);padding:12px;color:var(--org-ink)}
 @media(max-width:900px){
+ .organizer-board-note{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0)}
  .newsroom-organizer,.newsroom-organizer[data-sidebar-collapsed=true]{grid-template-columns:minmax(0,1fr);grid-template-rows:minmax(0,1fr) auto}
  .organizer-sidebar,.organizer-toggle{display:none}.organizer-workspace{padding:0 16px}.organizer-topbar{gap:8px;height:55px;min-height:55px}
  .organizer-masthead{font-size:24px;max-width:36vw}.organizer-topbar h1{font-size:10px}.organizer-account-header{display:flex}.organizer-header-actions{gap:4px;max-width:35%}

package/components/topic-steering-workspace.tsx

@@ -13297,7 +13297,7 @@ function buildUiAnalysisReindexAssignmentPlan({
     createdBy: actorLabel,
     createdAt: now,
     updatedAt: now,
-    newsroomFeedKey: "assignments",
+    newsroomFeedKey: "operations",
     metadata,
   };
   const event: AssignmentEventRecord = {

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

@@ -135,6 +135,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",
@@ -219,6 +220,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 +352,7 @@
       "optional": true
     }
   },
-  "version": "1.4.0-next.2",
+  "version": "1.4.0-next.3",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",
@@ -376,7 +378,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 +389,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",

package/renderers/pretext/rhythm-article-page.tsx

@@ -13,6 +13,7 @@ import { PresentationFooter } from "../../components/presentation-footer";
 import { PresentationHeader } from "../../components/presentation-header";
 import { useBlogHeaderObstacles } from "../../components/use-blog-header-obstacles";
 import { useRhythmOverlay } from "../../components/use-rhythm-overlay";
+import { useMeasuredWidth } from "./presentation-shared";
 import { BLOG_RHYTHM, getFeaturedLayoutStyle, getRhythmShellStyle } from "./rhythm-shell-style";
 
 const BlogPageBackground = SITE_BRAND.components?.BlogPageBackground ?? GenericBlogPageBackground;
@@ -135,24 +136,6 @@ export function RhythmArticlePage({
   );
 }
 
-function useMeasuredWidth(ref: RefObject<HTMLElement | null>): number {
-  const [width, setWidth] = useState(0);
-  useEffect(() => {
-    const node = ref.current;
-    if (!node) return;
-    const update = () => setWidth(Math.max(1, Math.floor(node.getBoundingClientRect().width)));
-    update();
-    const observer = new ResizeObserver(update);
-    observer.observe(node);
-    window.addEventListener("resize", update);
-    return () => {
-      observer.disconnect();
-      window.removeEventListener("resize", update);
-    };
-  }, [ref]);
-  return width;
-}
-
 function useViewportWidth(): number {
   const [width, setWidth] = useState(0);
   useEffect(() => {

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.4.0-next.2",
+  "version": "1.4.0-next.3",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",