@anthusai/papyrus 1.3.0 → 1.4.0-next.10

package/lib/furniture.ts

@@ -0,0 +1,385 @@
+import {
+  type ArticleFrameChromeSpec,
+  type ChromeTextSlotSpec,
+  type LayoutMediaSpec,
+  type LayoutPullQuoteSpec,
+  type ResponsivePlacementAnchor,
+  type ResponsivePlacementSpec,
+  type ResponsiveSpanPolicy,
+  type ResponsiveVerticalPlacement,
+} from "./layout-plan";
+import { type ArticlePublicationItem, getPublicationItemImageAssets } from "./publication-items";
+import {
+  reserveRhythmRows,
+  snapDownToRhythm,
+  snapPreferredHeightToRhythm,
+  snapPreservedImageHeightToRhythm,
+  snapToNearestRhythm,
+  type VerticalRhythm,
+} from "./blog-rhythm";
+import { type ArticleImageAsset } from "./articles";
+import {
+  type LayoutConfig,
+  type MediaVariant,
+  type PlacementVariant,
+  type PullQuoteVariant,
+  type SolvedImageFurniture,
+  type SolvedPullQuoteFurniture,
+} from "./layout-types";
+import {
+  FURNITURE_COLLISION_GUTTER,
+  IMAGE_CAPTION_FONT_SIZE,
+  IMAGE_CAPTION_HORIZONTAL_PADDING_EM,
+  PULL_QUOTE_VERTICAL_PADDING,
+  SERIF_TEXT_FONT,
+  clamp,
+  getSpanRect,
+} from "./layout-config";
+import { buildChromeFont, emToPx, measureWrappedTextBlock, parseEmOverride } from "./chrome-text";
+
+export function getMediaVariants(media: LayoutMediaSpec | undefined, config: LayoutConfig): MediaVariant[] {
+  if (!media) return [getNoMediaVariant(900)];
+  const variants = resolvePlacementVariants(media.placement, config).map((variant) => ({
+    ...variant,
+    assetRole: media.assetRole,
+    fallbackPenalty: variant.fallbackPenalty + Math.abs(variant.columnSpan - media.placement.span.preferred) * 900,
+  }));
+  if (media.required) return variants;
+  return [...variants, getNoMediaVariant(24_000)];
+}
+
+export function getNoMediaVariant(fallbackPenalty: number): MediaVariant {
+  return { id: "none", placement: null, columnStart: 0, columnSpan: 0, fallbackPenalty };
+}
+
+export function getPullQuoteVariants(
+  article: ArticlePublicationItem,
+  pullQuote: LayoutPullQuoteSpec | undefined,
+  config: LayoutConfig,
+): PullQuoteVariant[] {
+  const none = { id: "none", placement: null, columnStart: 0, columnSpan: 0, fallbackPenalty: 0 };
+  if (!pullQuote || !article.pullQuotes?.[0]) return [none];
+  const variants = pullQuote.placements.flatMap((placement, placementIndex) =>
+    resolvePlacementVariants(placement, config).map((variant) => ({
+      ...variant,
+      fallbackPenalty: variant.fallbackPenalty + placementIndex * 100,
+    })),
+  );
+  return pullQuote.required ? variants : [none, ...variants];
+}
+
+function resolvePlacementVariants(placement: ResponsivePlacementSpec, config: LayoutConfig): PlacementVariant[] {
+  const effectiveSpan = getEffectivePlacementSpanPolicy(placement, config.columnCount);
+  const collapsed = config.columnCount < effectiveSpan.min;
+  if (collapsed && placement.collapse === "omit") return [];
+  const spans = collapsed
+    ? [placement.collapse === "fullWidth" ? config.columnCount : 1]
+    : getSpanCandidates(effectiveSpan, config.columnCount);
+  return spans.flatMap((span, index) => {
+    const anchor = collapsed && placement.collapse === "inline" ? "inline" : placement.anchor ?? "left";
+    const columnStart = getColumnStartForPlacement(placement, resolveAnchor(anchor), span, config.columnCount, collapsed);
+    if (columnStart === null) return [];
+    return [{
+      id: `${resolveAnchor(anchor)}-span${span}-${placement.vertical}`,
+      placement,
+      columnStart,
+      columnSpan: span,
+      fallbackPenalty: index * 120 + (collapsed ? 320 : 0),
+    }];
+  });
+}
+
+function getEffectivePlacementSpanPolicy(
+  placement: ResponsivePlacementSpec,
+  columnCount: number,
+): ResponsiveSpanPolicy {
+  const override = placement.spanOverrides?.[String(columnCount)];
+  if (!override) return placement.span;
+  const clamped = clamp(override, placement.span.min, placement.span.max);
+  return { min: clamped, preferred: clamped, max: clamped };
+}
+
+export function resolvePreferredPlacementVariant(placement: ResponsivePlacementSpec, config: LayoutConfig): PlacementVariant | null {
+  return resolvePlacementVariants(placement, config)[0] ?? null;
+}
+
+export function createImageFurniture(
+  article: ArticlePublicationItem,
+  variant: MediaVariant,
+  config: LayoutConfig,
+  textHeight: number,
+  usedImageAssetIds: ReadonlySet<string> = new Set(),
+): SolvedImageFurniture | null {
+  if (!variant.placement || variant.columnSpan === 0) return null;
+  const asset = getPreferredImage(article, variant.placement, variant.assetRole, usedImageAssetIds);
+  if (!asset) return null;
+  const { x, width } = getSpanRect(config, variant.columnStart, variant.columnSpan);
+  const aspectRatio = getImageAspectRatio(asset);
+  const preferredHeight = Math.round(width / aspectRatio);
+  const canCropFrame = variant.placement.crop === "cropAllowed";
+  const shouldCropToFill = canCropFrame || asset.layout?.crop === "cover";
+  const minHeight = canCropFrame ? asset.layout?.minHeight ?? 140 : config.rhythm.rowHeight;
+  const maxHeight = canCropFrame ? asset.layout?.maxHeight ?? 420 : Number.POSITIVE_INFINITY;
+  const rawHeight = canCropFrame ? clamp(preferredHeight, minHeight, maxHeight) : preferredHeight;
+  const imageHeight = canCropFrame
+    ? snapPreferredHeightToRhythm(rawHeight, config.rhythm, minHeight, maxHeight)
+    : snapPreservedImageHeightToRhythm(rawHeight, config.rhythm, minHeight, maxHeight);
+  const caption = getImageCaption(asset);
+  const captionHeight = getImageCaptionHeight(caption, width, config.rhythm);
+  const height = imageHeight + captionHeight;
+  const y = getFurnitureY(variant.placement.vertical, height, textHeight, config);
+  const focalPoint = asset.layout?.focalPoint ?? { x: 0.5, y: 0.5 };
+  return {
+    kind: "image",
+    id: `${article.slug}-${variant.id}-image`,
+    assetId: asset.id,
+    src: asset.src,
+    themeVariants: asset.themeVariants,
+    alt: asset.alt,
+    caption,
+    credit: asset.credit,
+    templateId: `image-${variant.id}`,
+    columnStart: variant.columnStart,
+    columnSpan: variant.columnSpan,
+    x,
+    y,
+    width,
+    height,
+    imageHeight,
+    captionHeight,
+    captionFontSize: IMAGE_CAPTION_FONT_SIZE,
+    captionLineHeight: config.rhythm.rowHeight,
+    aspectRatio,
+    objectFit: shouldCropToFill ? "cover" : "contain",
+    objectPosition: `${Math.round(focalPoint.x * 100)}% ${Math.round(focalPoint.y * 100)}%`,
+    wrapsText: variant.placement.wrapsText,
+    preferredHeight: preferredHeight + captionHeight,
+  };
+}
+
+export function createPullQuoteFurniture(
+  article: ArticlePublicationItem,
+  variant: PullQuoteVariant,
+  config: LayoutConfig,
+  textHeight: number,
+  image: SolvedImageFurniture | null,
+  chrome?: ArticleFrameChromeSpec,
+): SolvedPullQuoteFurniture | null {
+  if (!variant.placement || variant.columnSpan === 0) return null;
+  const text = article.pullQuotes?.[0];
+  if (!text) return null;
+  const { x, width } = getSpanRect(config, variant.columnStart, variant.columnSpan);
+  const metrics = getPullQuoteMetrics(text, width, config, chrome?.pullQuote);
+  const y = getPullQuoteY({
+    x,
+    width,
+    height: metrics.height,
+    textHeight,
+    anchorRatio: getVerticalAnchorRatio(variant.placement.vertical),
+    image,
+    config,
+  });
+  if (y === null) return null;
+  return {
+    kind: "pullQuote",
+    id: `${article.slug}-${variant.id}-pullquote`,
+    text,
+    templateId: `pullquote-${variant.id}`,
+    columnStart: variant.columnStart,
+    columnSpan: variant.columnSpan,
+    x,
+    y,
+    width,
+    height: metrics.height,
+    fontSize: metrics.fontSize,
+    lineHeight: metrics.lineHeight,
+    wrapsText: true,
+  };
+}
+
+export function getPreferredImage(
+  article: ArticlePublicationItem,
+  _placement: ResponsivePlacementSpec,
+  assetRole: string | undefined,
+  usedImageAssetIds: ReadonlySet<string> = new Set(),
+): ArticleImageAsset | null {
+  const assets = getPublicationItemImageAssets(article).filter((asset) => !usedImageAssetIds.has(asset.id));
+  if (assetRole) {
+    const roleAsset = assets.find((asset) => asset.roles?.some((role) => role === assetRole));
+    if (roleAsset) return roleAsset;
+  }
+  return (
+    assets.find((asset) => asset.roles?.some((role) => role === "continuationInset")) ??
+    assets.find((asset) => asset.roles?.some((role) => role === "continuation")) ??
+    assets[0] ??
+    null
+  );
+}
+
+export function hasAvailablePreferredImage(
+  article: ArticlePublicationItem,
+  placement: ResponsivePlacementSpec,
+  assetRole: string | undefined,
+  usedImageAssetIds: ReadonlySet<string>,
+): boolean {
+  return getPreferredImage(article, placement, assetRole, usedImageAssetIds) !== null;
+}
+
+function getSpanCandidates(span: ResponsiveSpanPolicy, columnCount: number): number[] {
+  const min = Math.min(span.min, columnCount);
+  const max = Math.min(span.max, columnCount);
+  const preferred = clamp(span.preferred, min, max);
+  const candidates = [preferred, min, max];
+  return Array.from(new Set(candidates)).sort((left, right) => (
+    Math.abs(left - preferred) - Math.abs(right - preferred) || right - left
+  ));
+}
+
+function resolveAnchor(anchor: ResponsivePlacementAnchor): "left" | "right" | "center" | "inline" {
+  if (anchor === "outer") return "right";
+  if (anchor === "inner") return "left";
+  if (anchor === "inline") return "left";
+  return anchor;
+}
+
+function getColumnStart(anchor: "left" | "right" | "center" | "inline", span: number, columnCount: number): number {
+  if (anchor === "right") return Math.max(0, columnCount - span);
+  if (anchor === "center") return Math.max(0, Math.floor((columnCount - span) / 2));
+  return 0;
+}
+
+function getColumnStartForPlacement(
+  placement: ResponsivePlacementSpec,
+  anchor: "left" | "right" | "center" | "inline",
+  span: number,
+  columnCount: number,
+  collapsed: boolean,
+): number | null {
+  if (!placement.columnStart || collapsed) return getColumnStart(anchor, span, columnCount);
+  const requested = placement.columnStart - 1;
+  if (requested + span <= columnCount) return requested;
+  if (placement.collapse === "omit") return null;
+  if (placement.collapse === "fullWidth") return 0;
+  return getColumnStart("inline", Math.min(span, columnCount), columnCount);
+}
+
+function getFurnitureY(
+  verticalAnchor: ResponsiveVerticalPlacement,
+  height: number,
+  textHeight: number,
+  config: LayoutConfig,
+): number {
+  if (verticalAnchor === "top") return 0;
+  const minY = config.lineHeight * 2;
+  const maxY = Math.max(0, textHeight - height);
+  const ratio = getVerticalAnchorRatio(verticalAnchor);
+  const minimumY = Math.min(reserveRhythmRows(minY, config.rhythm), maxY);
+  const maximumY = snapDownToRhythm(maxY, config.rhythm);
+  if (maximumY < minimumY) return maximumY;
+  return clamp(snapToNearestRhythm(textHeight * ratio - height / 2, config.rhythm), minimumY, maximumY);
+}
+
+function getVerticalAnchorRatio(verticalAnchor: ResponsiveVerticalPlacement): number {
+  if (verticalAnchor === "top") return 0.12;
+  if (verticalAnchor === "upperThird") return 0.32;
+  if (verticalAnchor === "lowerThird") return 0.66;
+  return 0.5;
+}
+
+function getPullQuoteMetrics(
+  text: string,
+  width: number,
+  config: LayoutConfig,
+  overrides?: ChromeTextSlotSpec,
+): { height: number; fontSize: number; lineHeight: number } {
+  const narrow = config.columnCount === 1;
+  const fontSize = narrow ? 20 : 22;
+  const lineHeight = Math.ceil(emToPx(parseEmOverride(overrides?.lineHeight, 1.12), fontSize));
+  const paintHeight = Math.ceil(emToPx(parseEmOverride(overrides?.paintHeight, 1.18), fontSize));
+  const metrics = measureWrappedTextBlock(text, buildChromeFont({
+    fontSize,
+    fontFamily: SERIF_TEXT_FONT,
+    fontStyle: "italic",
+    lineHeightEm: lineHeight / fontSize,
+    paintHeightEm: paintHeight / fontSize,
+  }), width, lineHeight, paintHeight);
+  const marginBefore = Math.round(emToPx(parseEmOverride(overrides?.marginBefore, PULL_QUOTE_VERTICAL_PADDING / 2 / fontSize), fontSize));
+  const marginAfter = Math.round(emToPx(parseEmOverride(overrides?.marginAfter, PULL_QUOTE_VERTICAL_PADDING / 2 / fontSize), fontSize));
+  const minHeight = Math.ceil(emToPx(parseEmOverride(overrides?.minHeight, 0), fontSize));
+  const height = reserveRhythmRows(Math.max(metrics.height + marginBefore + marginAfter, minHeight), config.rhythm);
+  return { height, fontSize, lineHeight };
+}
+
+function getPullQuoteY({
+  x,
+  width,
+  height,
+  textHeight,
+  anchorRatio,
+  image,
+  config,
+}: {
+  x: number;
+  width: number;
+  height: number;
+  textHeight: number;
+  anchorRatio: number;
+  image: SolvedImageFurniture | null;
+  config: LayoutConfig;
+}): number | null {
+  const minY = config.lineHeight * 2;
+  const maxY = textHeight - height;
+  if (maxY < minY) return null;
+  const minimumY = reserveRhythmRows(minY, config.rhythm);
+  const maximumY = snapDownToRhythm(maxY, config.rhythm);
+  if (maximumY < minimumY) return null;
+  const preferredY = clamp(snapToNearestRhythm(textHeight * anchorRatio - height / 2, config.rhythm), minimumY, maximumY);
+  const preferredRect = { x, y: preferredY, width, height };
+  if (!image || !rectsOverlap(preferredRect, image, FURNITURE_COLLISION_GUTTER)) return preferredY;
+  const candidateYs = [
+    reserveRhythmRows(image.y + image.height + FURNITURE_COLLISION_GUTTER, config.rhythm),
+    snapDownToRhythm(image.y - height - FURNITURE_COLLISION_GUTTER, config.rhythm),
+  ]
+    .filter((candidateY) => candidateY >= minimumY && candidateY <= maximumY)
+    .sort((leftY, rightY) => Math.abs(leftY - preferredY) - Math.abs(rightY - preferredY));
+  return candidateYs.find((candidateY) => !rectsOverlap({ x, y: candidateY, width, height }, image, FURNITURE_COLLISION_GUTTER)) ?? null;
+}
+
+export function rectsOverlap(
+  a: { x: number; y: number; width: number; height: number },
+  b: { x: number; y: number; width: number; height: number },
+  gutter = 0,
+): boolean {
+  return (
+    a.x < b.x + b.width + gutter &&
+    a.x + a.width + gutter > b.x &&
+    a.y < b.y + b.height + gutter &&
+    a.y + a.height + gutter > b.y
+  );
+}
+
+export function getImageAspectRatio(asset: Pick<ArticleImageAsset, "layout">): number {
+  return asset.layout?.aspectRatio ?? 1.5;
+}
+
+export function getImageCaption(asset: Pick<ArticleImageAsset, "caption" | "credit">): string {
+  return (asset.caption ?? asset.credit).trim();
+}
+
+export function getImageCaptionHeight(caption: string, width: number, rhythm: VerticalRhythm): number {
+  if (!caption) return 0;
+  const contentWidth = Math.max(1, width - IMAGE_CAPTION_FONT_SIZE * IMAGE_CAPTION_HORIZONTAL_PADDING_EM);
+  const metrics = measureWrappedTextBlock(
+    caption,
+    `italic ${IMAGE_CAPTION_FONT_SIZE}px ${SERIF_TEXT_FONT}`,
+    contentWidth,
+    rhythm.rowHeight,
+    rhythm.rowHeight,
+  );
+  return reserveRhythmRows(Math.max(rhythm.rowHeight, metrics.height), rhythm);
+}
+
+export function getObjectPosition(asset: Pick<ArticleImageAsset, "layout">): string {
+  const focalPoint = asset.layout?.focalPoint ?? { x: 0.5, y: 0.5 };
+  return `${Math.round(focalPoint.x * 100)}% ${Math.round(focalPoint.y * 100)}%`;
+}

package/lib/graphql-content-repository.ts

@@ -20,7 +20,9 @@ import { BodyIrError, matchBodyImages, projectBodyIr, type BodyProjection, type
 import { SITE_BRAND } from "./site-brand";
 import { shouldFetchVideoScripts } from "./video-mode";
 import { collectVideoScriptTargets, parseVideoScriptRef, videomlItemSlug, type VideoScriptRef } from "./video-script";
-import { currentContentSource, currentRequestClient, runWithContentSource } from "./content-source-context";
+import { selectedTenantIdFromCookies } from "./prospectus-tenant";
+import { currentContentSource, currentRequestClient, currentTenantId, runWithContentSource } from "./content-source-context";
+import { rowBelongsToTenant, tenantScopedValue } from "./tenant-keys";
 import { withRateLimitRetry } from "./rate-limit-retry";
 import { getContentSource } from "./site-env";
 
@@ -70,6 +72,7 @@ type GraphQLEditionItem = {
 
 type GraphQLItem = {
   id: string;
+  tenantId?: string | null;
   versionNumber?: number | null;
   type: string;
   status: string;
@@ -152,9 +155,10 @@ async function withReaderGraphQLContext<T>(operation: () => Promise<T>): Promise
     // Drafts are read as the signed-in visitor: the client reads the session from the request cookies, and it is
     // kept in the request's async context (never a module global) so one visitor's session cannot serve another.
     const { cookies } = await import("next/headers");
-    await cookies();
+    const cookieStore = await cookies();
     const client = generateServerClientUsingCookies<Schema>({ config, cookies, authMode: "userPool" });
-    return runWithContentSource(source, operation, client);
+    const selectedTenantId = await selectedTenantIdFromCookies(cookieStore);
+    return runWithContentSource(source, operation, client, selectedTenantId);
   }
   return withRateLimitRetry(() =>
     runWithGuestAmplifyContext(() =>
@@ -587,6 +591,10 @@ type ItemSourceModel = {
   listPublishedItemsByTypeStatusAndPublishedAt: (input: { typeStatus: string }, options: ListOptions) => ListResponse<GraphQLItem>;
 };
 
+type TenantSlugSourceModel = {
+  publishedItemByTenantSlug: (input: { tenantSlug: string }, options: ListOptions) => ListResponse<GraphQLItem>;
+};
+
 type MediaAssetSourceModel = {
   listPublishedMediaAssetsByItemAndSortKey: (
     input: { publishedItemId: string },
@@ -671,20 +679,33 @@ function getPublishedEditionItemModel(): EditionItemSourceModel {
   return model as unknown as EditionItemSourceModel;
 }
 
+async function getItemWithinTenant(
+  tenantId: string | undefined,
+  lookup: Promise<GraphQLGetResponse<GraphQLItem>>,
+): Promise<GraphQLGetResponse<GraphQLItem>> {
+  const response = await lookup;
+  return rowBelongsToTenant(tenantId, response.data) ? response : { ...response, data: null };
+}
+
 function getPublishedItemModel(): ItemSourceModel {
+  const tenantId = currentTenantId();
   if (currentContentSource() === "drafts") {
     const model = getClient().models.Item;
     if (!model) throw missingProjectionModelError("Item");
     return {
-      get: (input, options) => model.get(input, options) as Promise<GraphQLGetResponse<GraphQLItem>>,
-      publishedItemBySlug: (input, options) => model.itemBySlug(input, options) as ListResponse<GraphQLItem>,
+      get: (input, options) =>
+        getItemWithinTenant(tenantId, model.get(input, options) as Promise<GraphQLGetResponse<GraphQLItem>>),
+      publishedItemBySlug: ({ slug }, options) =>
+        (tenantId
+          ? model.itemByTenantSlug({ tenantSlug: tenantScopedValue(tenantId, slug) }, options)
+          : model.itemBySlug({ slug }, options)) as ListResponse<GraphQLItem>,
       listPublishedItemsByTypeStatusAndPublishedAt: ({ typeStatus }, options) => {
         const itemType = typeStatus.split("#")[0];
         return listMergedAcrossStatuses<GraphQLItem>(
           [DRAFT_STATUS, PUBLISHED_STATUS],
           (status, pageOptions) =>
             model.listItemsByTypeStatusAndPublishedAt(
-              { typeStatus: `${itemType}#${status}` },
+              { typeStatus: tenantScopedValue(tenantId, `${itemType}#${status}`) },
               pageOptions,
             ) as ListResponse<GraphQLItem>,
           (item) => item.publishedAt ?? "",
@@ -695,7 +716,21 @@ function getPublishedItemModel(): ItemSourceModel {
   }
   const model = getClient().models.PublishedItem;
   if (!model) throw missingProjectionModelError("PublishedItem");
-  return model as unknown as ItemSourceModel;
+  const publishedModel = model as unknown as ItemSourceModel;
+  if (!tenantId) return publishedModel;
+  return {
+    get: (input, options) => getItemWithinTenant(tenantId, publishedModel.get(input, options)),
+    publishedItemBySlug: ({ slug }, options) =>
+      (model as unknown as TenantSlugSourceModel).publishedItemByTenantSlug(
+        { tenantSlug: tenantScopedValue(tenantId, slug) },
+        options,
+      ),
+    listPublishedItemsByTypeStatusAndPublishedAt: ({ typeStatus }, options) =>
+      publishedModel.listPublishedItemsByTypeStatusAndPublishedAt(
+        { typeStatus: tenantScopedValue(tenantId, typeStatus) },
+        options,
+      ),
+  };
 }
 
 function getPublishedMediaAssetModel(): MediaAssetSourceModel {

package/lib/item-stream.ts

@@ -0,0 +1,47 @@
+import type { EditionContent, EditionSection } from "./content-types";
+import { createEditionSectionPlan, createSectionKey } from "./edition-sections";
+import { getArticlePublicationItems, type ArticlePublicationItem } from "./publication-items";
+
+export const ITEM_STREAM_RECENT_EDITION_COUNT = 10;
+export const ITEM_STREAM_ITEM_LIMIT = 50;
+
+export type ItemStream = {
+  items: ArticlePublicationItem[];
+  sections: EditionSection[];
+  activeSectionKey: string | null;
+};
+
+/**
+ * Flattens published content into one newest-first stream of articles. The
+ * input is ordered newest first; a slug that appears twice keeps its newest entry.
+ */
+export function selectNewestStreamItems(
+  newestFirstContents: EditionContent[],
+  limit: number = ITEM_STREAM_ITEM_LIMIT,
+): ArticlePublicationItem[] {
+  const seenSlugs = new Set<string>();
+  const selected: ArticlePublicationItem[] = [];
+  for (const content of newestFirstContents) {
+    for (const item of getArticlePublicationItems(content.items)) {
+      if (seenSlugs.has(item.slug)) continue;
+      seenSlugs.add(item.slug);
+      selected.push(item);
+      if (selected.length >= limit) return selected;
+    }
+  }
+  return selected;
+}
+
+/** Builds the stream view: the sections found in the items, and the items filtered by an optional section key. */
+export function buildItemStream(items: ArticlePublicationItem[], sectionKey?: string | null): ItemStream {
+  const sections = createEditionSectionPlan(items);
+  const activeSectionKey = sectionKey ? createSectionKey(sectionKey) : null;
+  const activeSection = activeSectionKey ? sections.find((section) => section.key === activeSectionKey) : undefined;
+  if (!activeSection) return { items, sections, activeSectionKey: null };
+  const itemIds = new Set(activeSection.itemIds);
+  return {
+    items: items.filter((item) => itemIds.has(item.slug)),
+    sections,
+    activeSectionKey: activeSection.key,
+  };
+}

package/lib/labels.ts

@@ -0,0 +1,37 @@
+import { type ArticlePublicationItem } from "./publication-items";
+import { type ArticleFrameBlockSpec } from "./layout-plan";
+import { type ArticleFlow } from "./layout-types";
+
+export function formatContinuationJumpLabel(article: ArticlePublicationItem, pageNumber: number): string {
+  return `SEE ${getShortSlug(article) ?? "MORE"} ON ${formatSectionPage(pageNumber)}`;
+}
+
+export function getArticleFrameLabel(blockSpec: ArticleFrameBlockSpec, article: ArticlePublicationItem, flow: ArticleFlow): string {
+  if (blockSpec.startCursor !== "current") return article.section;
+  const previousRange = flow.placedRanges[flow.placedRanges.length - 1];
+  if (!previousRange) throw new Error(`Continuation block ${blockSpec.id} has no earlier text range to continue from`);
+  return formatContinuationSourceLabel(article, getPageNumberFromPageId(previousRange.pageId));
+}
+
+function getPageNumberFromPageId(pageId: string): number {
+  return Number(pageId.replace(/^page-/, ""));
+}
+
+function formatContinuationSourceLabel(article: ArticlePublicationItem, sourcePageNumber: number): string {
+  const shortSlug = getShortSlug(article);
+  const source = `FROM ${formatSectionPage(sourcePageNumber)}`;
+  return shortSlug ? `${shortSlug} ${source}` : source;
+}
+
+function getShortSlug(article: ArticlePublicationItem): string | null {
+  const shortSlug = article.shortSlug?.trim().toUpperCase();
+  return shortSlug || null;
+}
+
+function formatSectionPage(pageNumber: number): string {
+  return `A${pageNumber}`;
+}
+
+export function formatByline(article: ArticlePublicationItem): string {
+  return `${article.byline} / ${article.dateline}`.toUpperCase();
+}