@anthusai/papyrus 0.0.0 → 1.0.0-next.1

package/infra/amplify-app-shell.ts

@@ -0,0 +1,155 @@
+export type AmplifyAppShellSiteConfig = {
+  /** CDK context selector and stack id suffix. */
+  siteId: string;
+  /** Amplify app name (also the CloudFormation stack-friendly id). */
+  appName: string;
+  /** Human description shown in the Amplify console. */
+  description: string;
+  /** GitHub repo URL the CMS deploys from. */
+  repository: string;
+  /** Amplify platform. Papyrus CMS is always WEB_COMPUTE (Next.js SSR). */
+  platform: "WEB_COMPUTE";
+  /** Deploy branch. */
+  branchName: string;
+  /** Branch environment variables (PAPYRUS_SITE_BRAND etc.). */
+  environment: Record<string, string>;
+  /**
+   * Secrets Manager secret name holding the GitHub access token used by
+   * Amplify to clone the repo. CDK reads it via a dynamic reference so the
+   * token never lands in the CloudFormation template. Populate the secret
+   * before deploying. Replace the initial token with a dedicated fine-grained
+   * PAT scoped to this repo.
+   */
+  githubTokenSecretName: string;
+  /** Custom domain for the CMS (newsroom.<site>.us). Apex stays on the reader. */
+  domainName: string;
+  /** Route 53 hosted zone id for the domain. */
+  hostedZoneId: string;
+  /** Build compute type. */
+  buildComputeType?: "STANDARD" | "STANDARD_8GB";
+  /** Enable branch auto-build so pushes trigger deploys. */
+  enableAutoBuild?: boolean;
+};
+
+import { Construct } from "constructs";
+import { Stack, StackProps, SecretValue } from "aws-cdk-lib";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as amplify from "aws-cdk-lib/aws-amplify";
+
+
+/**
+ * Provisions the Amplify *app shell* for a Papyrus publication CMS:
+ *
+ *   - AWS::Amplify::App (WEB_COMPUTE, GitHub repo connection via PAT in Secrets Manager)
+ *   - AWS::Amplify::Branch (main, with PAPYRUS_SITE_BRAND env vars)
+ *   - AWS::Amplify::Domain (newsroom.<site>.us on the site's Route 53 zone)
+ *   - IAM service role (backend deploy) + compute role (SSR rendering)
+ *
+ * The Papyrus *backend* (AppSync, Storage, Lambda) is NOT created here. It
+ * deploys via `ampx pipeline-deploy` from the repo `amplify.yml` once Amplify
+ * CI runs a build on the branch. This stack only creates the container the
+ * backend deploys into, so the app is never "created manually" in the console.
+ *
+ * The GitHub access token is read from Secrets Manager by dynamic reference,
+ * so the token value never appears in the synthesized template.
+ */
+export class AmplifyAppShellStack extends Stack {
+  public readonly appId: string;
+  public readonly defaultDomain: string;
+
+  constructor(scope: Construct, id: string, config: AmplifyAppShellSiteConfig, props?: StackProps) {
+    super(scope, id, props);
+
+    const githubToken = SecretValue.secretsManager(config.githubTokenSecretName).unsafeUnwrap();
+
+    // Service role Amplify assumes to deploy the backend (ampx pipeline-deploy
+    // creates AppSync, Storage, Lambda, etc., so it needs broad permissions).
+    const serviceRole = new iam.Role(this, "AmplifyServiceRole", {
+      assumedBy: new iam.ServicePrincipal("amplify.amazonaws.com"),
+      description: `Backend deploy service role for Amplify app ${config.appName}`,
+      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName("AdministratorAccess")],
+    });
+
+    // WEB_COMPUTE (Next.js SSR) requires a compute role for the rendering server.
+    const computeRole = new iam.Role(this, "AmplifyComputeRole", {
+      assumedBy: new iam.ServicePrincipal("amplify.amazonaws.com"),
+      description: `SSR compute role for Amplify app ${config.appName}`,
+      managedPolicies: [
+        iam.ManagedPolicy.fromAwsManagedPolicyName("service-role/AWSLambdaBasicExecutionRole"),
+        iam.ManagedPolicy.fromAwsManagedPolicyName("CloudWatchLogsFullAccess"),
+      ],
+    });
+
+    const app = new amplify.CfnApp(this, "App", {
+      name: config.appName,
+      description: config.description,
+      platform: config.platform,
+      repository: config.repository,
+      accessToken: githubToken,
+      iamServiceRole: serviceRole.roleArn,
+      computeRoleArn: computeRole.roleArn,
+      buildSpec: this.buildSpec(),
+      customRules: [{ source: "/<*>", target: "/index.html", status: "404-200" }],
+    });
+
+    this.appId = app.attrAppId;
+    this.defaultDomain = `${app.attrAppId}.amplifyapp.com`;
+
+    const branch = new amplify.CfnBranch(this, "Branch", {
+      appId: app.attrAppId,
+      branchName: config.branchName,
+      stage: "PRODUCTION",
+      enableAutoBuild: config.enableAutoBuild ?? true,
+      enablePerformanceMode: false,
+      environmentVariables: Object.entries(config.environment).map(([key, value]) => ({
+        name: key,
+        value,
+      })),
+    });
+    branch.addResourceDependency(app);
+
+    const domain = new amplify.CfnDomain(this, "Domain", {
+      appId: app.attrAppId,
+      domainName: config.domainName,
+      subDomainSettings: [{ branchName: config.branchName, prefix: "" }],
+    });
+    domain.addResourceDependency(branch);
+
+    this.exportValue(app.attrAppId, { description: `Amplify app id for ${config.appName}` });
+  }
+
+  /**
+   * Build spec mirrors the repo root amplify.yml so the app deploys the full
+   * Papyrus backend + Next.js frontend on every build. Inlined because Amplify
+   * needs a buildSpec on the app for the first deploy before the repo is cloned.
+   */
+  private buildSpec(): string {
+    return [
+      "version: 1",
+      "backend:",
+      "  phases:",
+      "    build:",
+      "      commands:",
+      "        - npm install --cache .npm --prefer-offline",
+      "        - |",
+      "          if [ -z \"${PAPYRUS_CONSOLE_RESPONDER_IMAGE_URI:-}\" ]; then",
+      "            export PAPYRUS_CONSOLE_RESPONDER_ALLOW_LOCAL_BUILD=true",
+      "          fi",
+      "        - npx ampx pipeline-deploy --debug --branch $AWS_BRANCH --app-id $AWS_APP_ID",
+      "frontend:",
+      "  phases:",
+      "    build:",
+      "      commands:",
+      "        - env | grep -e '^PAPYRUS_CONTENT_SOURCE=' -e '^PAPYRUS_EDITION_SLUG=' -e '^PAPYRUS_REVALIDATE_SECRET=' >> .env.production",
+      "        - npm run build",
+      "  artifacts:",
+      "    baseDirectory: .next",
+      "    files:",
+      "      - '**/*'",
+      "  cache:",
+      "    paths:",
+      "      - .next/cache/**/*",
+      "      - .npm/**/*",
+    ].join("\n");
+  }
+}

package/infra/index.js

@@ -0,0 +1,12 @@
+// aws-cdk-lib and constructs are OPTIONAL peers of @anthusai/papyrus: only a publication's infra/ package installs them.
+try {
+  await import("aws-cdk-lib");
+  await import("constructs");
+} catch (error) {
+  throw new Error(
+    "@anthusai/papyrus/infra needs aws-cdk-lib and constructs, which are optional peer dependencies. " +
+      "Install them in the package that imports this entry (your infra/ folder): npm install aws-cdk-lib constructs. " +
+      "(" + (error && error.code) + ")",
+  );
+}
+export const { AmplifyAppShellStack } = await import("./amplify-app-shell.js");

package/lib/amplify-outputs-guard.ts

@@ -0,0 +1,24 @@
+const PRODUCTION_GRAPHQL_HOST = "64hviw";
+const PRODUCTION_USER_POOL_ID = "us-east-1_40Uot7WSv";
+
+export function isProductionAmplifyOutputs(outputs: Record<string, unknown> | null): boolean {
+  if (!outputs) return false;
+  const graphqlUrl = String((outputs.data as { url?: string } | undefined)?.url ?? "");
+  const userPoolId = String((outputs.auth as { user_pool_id?: string } | undefined)?.user_pool_id ?? "");
+  return graphqlUrl.includes(PRODUCTION_GRAPHQL_HOST) || userPoolId === PRODUCTION_USER_POOL_ID;
+}
+
+export function assertSandboxAmplifyOutputsForDev(outputs: Record<string, unknown>): void {
+  if (process.env.NODE_ENV === "production") return;
+  if (!isProductionAmplifyOutputs(outputs)) return;
+  const graphqlUrl = String((outputs.data as { url?: string } | undefined)?.url ?? "");
+  throw new Error(
+    [
+      "Papyrus dev is configured for production Amplify (amplify_outputs.json → " +
+        (graphqlUrl || "production AppSync") +
+        ").",
+      "Run `npm run outputs:sandbox` or restart with `npm run dev` (runs ensure-sandbox-amplify-outputs first).",
+      "Use ~/Projects/Papyrus-production for production deploys only.",
+    ].join(" "),
+  );
+}

package/lib/amplify-outputs-path.ts

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function getAmplifyOutputsPath(): string {
+  const explicit = process.env.PAPYRUS_AMPLIFY_OUTPUTS?.trim();
+  if (explicit) {
+    return path.isAbsolute(explicit) ? explicit : path.join(process.cwd(), explicit);
+  }
+  return path.join(process.cwd(), "amplify_outputs.json");
+}
+
+export function readAmplifyOutputsFile(): Record<string, unknown> | null {
+  const outputsPath = getAmplifyOutputsPath();
+  if (!fs.existsSync(outputsPath)) return null;
+  return JSON.parse(fs.readFileSync(outputsPath, "utf8")) as Record<string, unknown>;
+}

package/lib/amplify-server-runtime.ts

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import { createServerRunner } from "@aws-amplify/adapter-nextjs";
+import { Amplify, type ResourcesConfig } from "aws-amplify";
+import { assertSandboxAmplifyOutputsForDev } from "./amplify-outputs-guard";
+import { getAmplifyOutputsPath } from "./amplify-outputs-path";
+
+type AmplifyServerRuntime = ReturnType<typeof createServerRunner> & {
+  config: ResourcesConfig;
+};
+
+let cachedRuntime: AmplifyServerRuntime | null = null;
+
+export function getAmplifyServerRuntime(): AmplifyServerRuntime {
+  if (cachedRuntime) return cachedRuntime;
+
+  const config = loadAmplifyOutputs();
+  Amplify.configure(config, { ssr: true });
+  cachedRuntime = {
+    ...createServerRunner({ config }),
+    config,
+  };
+  return cachedRuntime;
+}
+
+export function hasAmplifyOutputs(): boolean {
+  return fs.existsSync(getAmplifyOutputsPath());
+}
+
+function loadAmplifyOutputs(): ResourcesConfig {
+  const outputsPath = getAmplifyOutputsPath();
+  if (!fs.existsSync(outputsPath)) {
+    throw new Error(
+      "Papyrus requires amplify_outputs.json for GraphQL content. Run `npm run outputs:sandbox` or `npm run sandbox` first.",
+    );
+  }
+
+  const raw = JSON.parse(fs.readFileSync(outputsPath, "utf8")) as ResourcesConfig & {
+    auth?: { identity_pool_id?: string; user_pool_client_id?: string; user_pool_id?: string };
+  };
+  assertSandboxAmplifyOutputsForDev(raw as Record<string, unknown>);
+
+  // Reader SSR uses Cognito identity-pool guest credentials (no expiring AppSync API keys).
+  const cognito = (raw as { Auth?: { Cognito?: Record<string, unknown> } }).Auth?.Cognito ?? {};
+  const legacyAuth = raw.auth;
+  return {
+    ...raw,
+    Auth: {
+      Cognito: {
+        ...cognito,
+        identityPoolId:
+          (cognito.identityPoolId as string | undefined)
+          ?? legacyAuth?.identity_pool_id,
+        userPoolClientId:
+          (cognito.userPoolClientId as string | undefined)
+          ?? legacyAuth?.user_pool_client_id,
+        userPoolId:
+          (cognito.userPoolId as string | undefined)
+          ?? legacyAuth?.user_pool_id,
+        allowGuestAccess: true,
+      },
+    },
+  } as ResourcesConfig;
+}

package/lib/archive-data.ts

@@ -0,0 +1,30 @@
+import { listCachedPublishedEditions } from "./cached-content-repository";
+import { getEditionDatePath } from "./edition-routes";
+import { ARCHIVE_BATCH_SIZE, type ArchiveEditionsResponse } from "./archive-types";
+
+type ArchiveBatchOptions = {
+  limit?: number;
+  nextToken?: string | null;
+};
+
+export async function loadArchiveEditionPreviews({ limit = ARCHIVE_BATCH_SIZE, nextToken }: ArchiveBatchOptions = {}): Promise<ArchiveEditionsResponse> {
+  const safeLimit = clampArchiveLimit(limit);
+  const { editions, nextToken: nextCursor } = await listCachedPublishedEditions({
+    limit: safeLimit,
+    nextToken,
+  });
+  const previews = editions.map((edition) => ({
+    edition,
+    href: getEditionDatePath(edition.editionDate),
+  }));
+
+  return {
+    previews,
+    nextCursor,
+  };
+}
+
+export function clampArchiveLimit(limit: number): number {
+  if (!Number.isFinite(limit)) return ARCHIVE_BATCH_SIZE;
+  return Math.max(1, Math.min(ARCHIVE_BATCH_SIZE, Math.floor(limit)));
+}

package/lib/archive-types.ts

@@ -0,0 +1,15 @@
+import type { EditionRouteSummary } from "./content-types";
+
+export const ARCHIVE_BATCH_SIZE = 12;
+export const ARCHIVE_PREVIEW_WIDTH = 1280;
+export const ARCHIVE_PREVIEW_HEIGHT = 900;
+
+export type ArchiveEditionPreview = {
+  edition: EditionRouteSummary;
+  href: string;
+};
+
+export type ArchiveEditionsResponse = {
+  previews: ArchiveEditionPreview[];
+  nextCursor?: string | null;
+};

package/lib/articles.ts

@@ -0,0 +1,320 @@
+export type ArticleImageLayout = {
+  minHeight: number;
+  preferredHeight: number;
+  maxHeight: number;
+  aspectRatio: number;
+  crop: "cover" | "contain";
+  wrapsText: boolean;
+  inlineFloat?: {
+    minColumnCount?: number;
+    columnSpan?: number;
+    widthRatio?: number;
+    narrowWidthRatio?: number;
+    maxWidthRatio?: number;
+    minWidth?: number;
+  };
+  focalPoint?: {
+    x: number;
+    y: number;
+  };
+};
+
+export type ArticleImageThemeVariants = {
+  dark?: {
+    src: string;
+  };
+};
+
+export type ArticleVideoThemeVariants = {
+  light?: { src: string };
+  dark?: { src: string };
+};
+
+export type ArticleImage = {
+  src: string;
+  alt: string;
+  caption?: string;
+  credit: string;
+  layout?: ArticleImageLayout;
+  themeVariants?: ArticleImageThemeVariants;
+};
+
+export type ArticleImageAsset = ArticleImage & {
+  id: string;
+  type: "image";
+  roles?: Array<"lead" | "continuation" | "continuationInset" | "feature" | "thumbnail">;
+};
+
+export type ArticleVideoAsset = {
+  id?: string;
+  type: "video";
+  src: string;
+  posterSrc?: string;
+  alt: string;
+  caption?: string;
+  credit: string;
+  durationSeconds?: number;
+  roles?: Array<"lead" | "feature" | "thumbnail">;
+  themeVariants?: ArticleVideoThemeVariants;
+};
+
+export type ArticleAsset = ArticleImageAsset | ArticleVideoAsset;
+
+export type Article = {
+  slug: string;
+  shortSlug?: string;
+  section: string;
+  headline: string;
+  deck: string;
+  excerpt?: string;
+  byline: string;
+  dateline: string;
+  image?: ArticleImage;
+  video?: ArticleVideoAsset;
+  assets?: ArticleAsset[];
+  pullQuotes?: string[];
+  body: string[];
+};
+
+export const editionDate = "Wednesday, May 13, 2026";
+
+export const articles: Article[] = [
+  {
+    slug: "agent-procedure-patterns",
+    shortSlug: "AGENTS",
+    section: "AI/ML",
+    headline: "The Next Agent Breakthrough Is a Checklist",
+    deck:
+      "Developers are learning that reliable agents need less freedom, not more: state machines, scoped tools, policy gates, and step-by-step procedure.",
+    byline: "Papyrus Staff",
+    dateline: "NEWSROOM",
+    image: {
+      src: "/seed-art/workflow-lanes.png",
+      alt: "An abstract workflow showing bounded editorial stages and handoffs",
+      caption: "Bounded agents sit between rigid scripts and open-ended tool use.",
+      credit: "Papyrus seed art",
+      layout: {
+        minHeight: 120,
+        preferredHeight: 190,
+        maxHeight: 360,
+        aspectRatio: 1.5009,
+        crop: "contain",
+        wrapsText: true,
+      },
+    },
+    pullQuotes: [
+      "The practical breakthrough is not giving agents a bigger sandbox.",
+      "A tiny tool-calling model can follow agent steps as long as the workflow is enforced outside the prompt.",
+    ],
+    body: [
+      "Developers are learning that reliable agents need less freedom, not more: state machines, scoped tools, policy gates, and step-by-step procedure. The most interesting argument this week was not about a new frontier model. It was about how much freedom an AI agent should be allowed to have.",
+      "Across demos, comments, and tool launches, builders kept circling the same answer: the practical breakthrough is not giving agents a bigger sandbox, but putting them inside a procedure. That marks a quiet reversal in the agent story. The first wave of agent demos sold autonomy: ask for an outcome and let the model decide what to do. The newer work is more cautious and more useful.",
+      "It treats agency as a dial, not a switch. At one end are scripts, workflow engines, and RPA jobs: predictable, auditable, and brittle when reality changes. At the other end are open-ended agents that can plan, browse, call tools, edit files, and recover from surprises, but may also wander, repeat themselves, or take unsafe actions. The emerging middle ground is bounded agency.",
+      "A model can improvise, but only inside states, allowed tools, review gates, and traceable transitions. The Statewright project drew attention because it says part of this out loud. Its author argues that agentic problem solving becomes more reliable when the problem is made smaller instead of the model larger.",
+      "A planning state can get read-only tools. An implementation state can get edit tools. A testing state can get test commands. The model cannot skip the workflow because the workflow is enforced outside the prompt. That pattern is showing up elsewhere. A tiny tool-calling model can follow agent steps as long as the next action is constrained by a procedure.",
+      "The lesson is not that agents are over. It is that they need architecture. The frontier is shifting from open-ended instruction following to systems that decide where the model is allowed to be creative and where the software should be boring. In practice, the checklist may be the most important agent interface.",
+    ],
+  },
+  {
+    slug: "schools-reading-lab",
+    shortSlug: "READING",
+    section: "Education",
+    headline: "Reading Labs Replace Remediation With Daily Practice",
+    deck:
+      "Teachers are testing short, frequent literacy blocks that use live diagnostics without turning classrooms into test prep centers.",
+    byline: "Jon Bell",
+    dateline: "NORTHLINE",
+    image: {
+      src: "https://images.unsplash.com/photo-1509062522246-3755977927d7?auto=format&fit=crop&w=1000&q=80",
+      alt: "Students working together at a classroom table",
+      caption: "Students rotate through short reading-practice stations built around live diagnostics.",
+      credit: "Classroom notebook",
+      layout: {
+        minHeight: 120,
+        preferredHeight: 220,
+        maxHeight: 420,
+        aspectRatio: 4 / 3,
+        crop: "cover",
+        wrapsText: true,
+      },
+    },
+    pullQuotes: [
+      "The blocks last eighteen minutes. That is the point.",
+      "The data is deliberately small: enough to choose tomorrow's grouping.",
+    ],
+    body: [
+      "At 9:10 each morning, the fifth grade at Bellwether School breaks into a rhythm that looks more like music rehearsal than remediation. One group reads aloud with a teacher, one marks unfamiliar words in a science passage, one records a short explanation, and one works through a vocabulary ladder at the back table.",
+      "The blocks last eighteen minutes. That is the point. Administrators wanted a model that could happen every day without swallowing social studies, art, or recess. The district's older intervention program pulled students from class twice a week and often arrived too late to change what happened in the next lesson.",
+      "Now teachers receive a same-day view of fluency, comprehension, and vocabulary signals. The data is deliberately small: enough to choose tomorrow's grouping, not enough to rank children publicly. Teachers can override every recommendation, and many do.",
+      "Early results are uneven but promising. Students who had stalled on multisyllabic decoding are moving fastest. English learners show gains when the passages connect to science and local history units. The hardest cases remain students who can decode accurately but lose the thread of an argument after the second paragraph.",
+      "The district is watching teacher workload closely. A literacy coach visits each building twice a week, and the software vendor is barred from sending automated messages to families. Principals say the model will survive only if it feels like instruction rather than surveillance.",
+    ],
+  },
+  {
+    slug: "market-hall",
+    shortSlug: "MARKET",
+    section: "Business",
+    headline: "Old Market Hall Finds a Second Life as a Food Factory",
+    deck:
+      "Small producers are sharing cold rooms, packaging lines, and a retail counter in a building once written off as obsolete.",
+    byline: "Ilya Stone",
+    dateline: "EASTBOROUGH",
+    image: {
+      src: "https://images.unsplash.com/photo-1555396273-367ea4eb4db5?auto=format&fit=crop&w=1000&q=80",
+      alt: "A busy restaurant kitchen with stainless steel counters",
+      caption: "The renovated market hall combines prep kitchens, storefront counters, and shared cold storage.",
+      credit: "Kitchen file",
+      layout: {
+        minHeight: 110,
+        preferredHeight: 210,
+        maxHeight: 380,
+        aspectRatio: 4 / 3,
+        crop: "cover",
+        wrapsText: false,
+      },
+    },
+    pullQuotes: [
+      "The economics depend on sharing.",
+      "That counter has become its own kind of research lab.",
+    ],
+    body: [
+      "The market hall's loading dock used to open twice a week. Now it opens before dawn. Bakers roll in racks of proofed dough, a salsa maker unloads crates of tomatillos, and a coffee roaster threads sacks of beans through a doorway that still bears the name of a grocer who closed in 1988.",
+      "The renovation was less glamorous than the ribbon cutting suggested. Contractors replaced cracked drains, raised the electrical service, and carved one cavernous floor into a set of certified production rooms. The city provided low-interest financing because small food companies kept leaving town when they outgrew home kitchens but could not afford private facilities.",
+      "The economics depend on sharing. Tenants reserve equipment by the hour and pay more for freezer space than for office space. A single compliance manager handles inspections, labeling questions, and recall drills. On Saturdays, a retail counter lets customers buy the products made during the week.",
+      "That counter has become its own kind of research lab. Producers can test packaging, pricing, and flavors before committing to wholesale runs. The most popular item so far is a fermented pepper sauce that began as a farmers market experiment and now ships to three regional chains.",
+      "Neighbors who feared another boutique food court have been cautiously won over by the number of industrial jobs. The hall employs dishwashers, packers, drivers, and maintenance workers, not only chefs with investors. The question is whether rents can stay low once the building becomes fashionable again.",
+    ],
+  },
+  {
+    slug: "river-court",
+    section: "Civic Life",
+    headline: "A Tiny Courtroom Tries to Keep Evictions From Becoming Homelessness",
+    deck:
+      "Mediators, rent ledgers, and emergency aid sit in the same hallway as judges in a new housing docket.",
+    byline: "Anika Rao",
+    dateline: "MILL COUNTY",
+    image: {
+      src: "https://images.unsplash.com/photo-1589578527966-fdac0f44566c?auto=format&fit=crop&w=1000&q=80",
+      alt: "Sunlight through the columns of a courthouse",
+      caption: "Court administrators are balancing public-record access with case-management automation.",
+      credit: "Courthouse file",
+      layout: {
+        minHeight: 120,
+        preferredHeight: 230,
+        maxHeight: 420,
+        aspectRatio: 1.5,
+        crop: "cover",
+        wrapsText: true,
+      },
+    },
+    pullQuotes: [
+      "The first question has changed from who is at fault to whether the tenancy can be stabilized.",
+      "The shelter system has not opened an overflow wing this spring.",
+    ],
+    body: [
+      "The housing docket meets in Courtroom 2B, a narrow room with a flickering clock and a stack of folding chairs outside the door. By 8:30, landlords, tenants, lawyers, and caseworkers have filled the hallway. Some hold lease packets. Some hold money orders. Almost everyone is checking a phone.",
+      "The premise is simple: most eviction cases turn on missed payments that are smaller than the public cost of sheltering a displaced family. The county now places rental assistance screeners, legal aid lawyers, and mediators next to the courtroom so agreements can be reached before a writ is issued.",
+      "Judges still hear contested cases, and landlords can still recover possession. But the first question has changed from who is at fault to whether the tenancy can be stabilized. A tenant with a new job may need a payment plan. A landlord with a small mortgage may need partial payment within days. A caseworker may be able to close the gap with emergency funds.",
+      "The docket has reduced default judgments because tenants are more likely to appear when help is available on site. It has also exposed how thin the safety net remains. Assistance funds run out before the month does, and many renters arrive only after fees have doubled the original balance.",
+      "County leaders are debating whether to make the docket permanent. The strongest argument may be the quietest one: the shelter system has not opened an overflow wing this spring.",
+    ],
+  },
+  {
+    slug: "night-trains",
+    section: "Travel",
+    headline: "Night Trains Return With Sleeper Cars and Skeptics",
+    deck:
+      "A revived overnight route promises downtown-to-downtown travel, but reliability will decide whether curiosity becomes habit.",
+    byline: "Theo Mercer",
+    dateline: "CENTRAL STATION",
+    image: {
+      src: "https://images.unsplash.com/photo-1474487548417-781cb71495f3?auto=format&fit=crop&w=1000&q=80",
+      alt: "A passenger train waiting at a platform",
+      caption: "Regional rail planners are testing later departures before committing to permanent schedules.",
+      credit: "Rail archive",
+      layout: {
+        minHeight: 110,
+        preferredHeight: 210,
+        maxHeight: 360,
+        aspectRatio: 1.5,
+        crop: "cover",
+        wrapsText: false,
+      },
+    },
+    pullQuotes: [
+      "The real test comes in winter, when novelty fades.",
+      "A moving bedroom must be dependable enough for business and family visits.",
+    ],
+    body: [
+      "The new sleeper train leaves at 10:42 p.m., late enough for dinner and early enough for a child to fall asleep before the suburbs thin out. By morning it reaches the capital, sliding under the old glass roof while commuters are still buying coffee.",
+      "Rail officials have tried this before. Overnight service faded as cheap flights multiplied, maintenance windows shrank, and older cars became expensive to keep in service. This revival is different in two ways: the route uses refurbished cars with private rooms, and the schedule is aimed at travelers who would otherwise lose a day to airports.",
+      "The train's supporters talk about carbon, comfort, and city-center convenience. Its critics talk about freight congestion, missed connections, and the long memory of routes that launched with enthusiasm and died quietly two timetables later.",
+      "The first month is nearly sold out, helped by nostalgia and a marketing campaign heavy on brass lamps and linen sheets. The real test comes in winter, when novelty fades and travelers decide whether a moving bedroom is dependable enough for business, family visits, and holidays.",
+    ],
+  },
+  {
+    slug: "climate-ledger",
+    section: "Science",
+    headline: "Researchers Build a Climate Ledger for City Blocks",
+    deck:
+      "A block-by-block model gives planners a sharper picture of heat, shade, runoff, and retrofit payoffs.",
+    byline: "Celeste Ng",
+    dateline: "WEST QUAY",
+    image: {
+      src: "https://images.unsplash.com/photo-1446776811953-b23d57bd21aa?auto=format&fit=crop&w=1000&q=80",
+      alt: "A satellite view of Earth and weather systems",
+      caption: "Small climate ledgers increasingly rely on satellite checks instead of annual surveys.",
+      credit: "Remote sensing",
+      layout: {
+        minHeight: 120,
+        preferredHeight: 240,
+        maxHeight: 440,
+        aspectRatio: 1.5,
+        crop: "cover",
+        wrapsText: true,
+      },
+    },
+    pullQuotes: [
+      "The output is not a single score but a set of tradeoffs.",
+      "A block can now be flagged as data-poor rather than quietly misclassified.",
+    ],
+    body: [
+      "City climate maps have usually been blunt instruments. They show neighborhoods that are hotter, wetter, or more vulnerable than others, but they rarely tell a planner which block should get trees before pavement, which roof should get reflective coating, or which alley can absorb stormwater before it reaches a basement.",
+      "A research team at West Quay University is trying to narrow the unit of action. Their model combines tree canopy, roof material, surface temperature, drainage complaints, utility burden, and building age into a ledger for each block. The output is not a single score but a set of tradeoffs.",
+      "On one block, shade trees may reduce afternoon heat but interfere with buried utilities. On another, a cool-roof program may help renters only if paired with rules that prevent landlords from passing the cost through immediately. A third block may need porous pavement more than shade because runoff is the dominant risk.",
+      "The team built the tool with public data where possible and marked uncertain estimates in plain language. Community groups pushed for that feature after seeing earlier maps turn shaky data into confident colors. A block can now be flagged as data-poor rather than quietly misclassified.",
+      "The city plans to use the ledger in next year's capital budget. Researchers warn that the model should guide site visits, not replace them. A spreadsheet can see heat islands. It cannot see a grandmother who sits on the same stoop every afternoon because it is the only shaded place on the block.",
+    ],
+  },
+];
+
+export function getArticle(slug: string): Article | undefined {
+  return articles.find((article) => article.slug === slug);
+}
+
+export function getArticleText(article: Article): string {
+  return article.body.join("\n\n");
+}
+
+export function getArticleImageAssets(article: Article): ArticleImageAsset[] {
+  const imageAssets = article.assets?.filter((asset): asset is ArticleImageAsset => asset.type === "image") ?? [];
+  if (imageAssets.length > 0) return imageAssets;
+  if (!article.image) return [];
+
+  return [
+    {
+      ...article.image,
+      id: `${article.slug}-primary-image`,
+      type: "image",
+      roles: ["lead", "continuation", "continuationInset"],
+    },
+  ];
+}
+
+export function getArticleVideoAsset(article: Article): ArticleVideoAsset | undefined {
+  const videoAssets = article.assets?.filter((asset): asset is ArticleVideoAsset => asset.type === "video") ?? [];
+  if (videoAssets.length > 0) {
+    return videoAssets.find((asset) => asset.roles?.includes("lead")) ?? videoAssets[0];
+  }
+  return article.video;
+}