@anthusai/papyrus 1.0.0-next.52 → 1.0.0-next.54

package/amplify/functions/content-actions/handler.py

@@ -7,6 +7,7 @@ from typing import Any
 from papyrus_content.edge_invalidation import distribution_ids_from_environment, invalidate_revalidated_paths
 from papyrus_content.graphql_authoring import create_authoring_client
 from papyrus_content.markus_renderer.derive import derive_body
+from papyrus_content.projection.deploy_render import deploy_render, drift_metric_line
 from papyrus_content.projection.engine import project, project_all, project_item_pages
 from papyrus_content.projection.runtime import (
     DEAD_LETTER_QUEUE_ENV,
@@ -146,6 +147,18 @@ def schedule_unpurged_invalidation(keys: list[str]) -> None:
     schedule_projection_task({"task": "invalidate", "keys": keys}, "edge invalidation failed")
 
 
+def run_deploy_render_task(client) -> dict:
+    """Render every published page after a backend deploy, then report drift (a dry run: nothing is deleted)."""
+    context = projection_context(client)
+    report = deploy_render(context)
+    print(drift_metric_line(report))
+    if report.render.unpurged:
+        schedule_unpurged_invalidation(report.render.unpurged)
+    if not report.ok:
+        raise ProjectionTaskFailed("; ".join([*report.render.errors, *report.drift.errors]))
+    return report.to_dict()
+
+
 def run_projection_task(task: dict) -> dict:
     """An asynchronous projection task. Raising makes Lambda retry it, then send the event to the dead letter queue."""
     client, _claims = create_authoring_client()
@@ -157,8 +170,8 @@ def run_projection_task(task: dict) -> dict:
             schedule_projection_task({"task": "item-pages", "exceptItemId": task["itemId"]}, "follow-up")
     elif task.get("task") == "all":
         report = project_all(projection_context(client))
-    elif task.get("task") == "all":
-        report = project_all(projection_context(client))
+    elif task.get("task") == "deploy-render":
+        return run_deploy_render_task(client)
     elif task.get("task") == "invalidate":
         invalidate = projection_context(client).invalidate
         if invalidate is None:

package/amplify/publication/reproject-on-deploy.js

@@ -1,31 +1,73 @@
+import { CustomResource, Duration } from "aws-cdk-lib";
+import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
 import { PolicyStatement } from "aws-cdk-lib/aws-iam";
-import { AwsCustomResource, AwsCustomResourcePolicy, PhysicalResourceId } from "aws-cdk-lib/custom-resources";
-export const REPROJECT_ON_DEPLOY_TIMEOUT_SECONDS = 300;
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import { Provider } from "aws-cdk-lib/custom-resources";
+export const REPROJECT_ON_DEPLOY_TIMEOUT_SECONDS = 900;
+export const DEPLOY_RENDER_METRIC_NAMESPACE = "Papyrus/Projection";
+export const DEPLOY_RENDER_DRIFT_METRIC_NAME = "DeployRenderDrift";
+export const DEPLOY_RENDER_TASK = "deploy-render";
+const FAILURE_MESSAGE_LIMIT = 600;
+const RESULT_SUMMARY_LIMIT = 900;
 export function reprojectDeployToken(environment, now = Date.now) {
     const buildJobId = (environment.AWS_JOB_ID ?? "").trim();
     return buildJobId !== "" ? `job-${buildJobId}` : `time-${now()}`;
 }
 /**
- * Starts the content-actions `all` projection task (asynchronously) every time the stack deploys.
- * The token is in the request, so CloudFormation sees a changed property on each deploy.
+ * Runs inside the deploy: invokes the content-actions Lambda synchronously, so a render that fails fails the
+ * stack update (and with it the Amplify build) with the failure in the build log. The Lambda's result, which
+ * includes the drift check, is written to its log and returned as the resource's data.
+ */
+export const DEPLOY_RENDER_HANDLER_SOURCE = `
+const { LambdaClient, InvokeCommand } = require("@aws-sdk/client-lambda");
+
+exports.handler = async (event) => {
+  if (event.RequestType === "Delete") return { PhysicalResourceId: event.PhysicalResourceId };
+  const properties = event.ResourceProperties;
+  const client = new LambdaClient({ maxAttempts: 1 });
+  const response = await client.send(new InvokeCommand({
+    FunctionName: properties.FunctionName,
+    InvocationType: "RequestResponse",
+    Payload: JSON.stringify({ projectionTask: { task: properties.Task, deployToken: properties.DeployToken } }),
+  }));
+  const text = Buffer.from(response.Payload || []).toString("utf8");
+  console.log("deploy render result: " + text);
+  if (response.FunctionError) {
+    throw new Error("The post-deploy render failed (" + response.FunctionError + "): " + text.slice(0, ${FAILURE_MESSAGE_LIMIT}));
+  }
+  return { PhysicalResourceId: "reproject-" + properties.DeployToken, Data: { Result: text.slice(0, ${RESULT_SUMMARY_LIMIT}) } };
+};
+`;
+/**
+ * Renders every published page after each backend deploy and checks the site store for drift (a dry run:
+ * nothing is deleted). The token is a property, so CloudFormation runs the resource again on every deploy.
  */
 export function addReprojectOnDeploy(stack, contentActions, deployToken) {
-    const invocation = {
-        service: "Lambda",
-        action: "invoke",
-        parameters: {
-            FunctionName: contentActions.functionName,
-            InvocationType: "Event",
-            Payload: JSON.stringify({ projectionTask: { task: "all", deployToken } }),
-        },
-        physicalResourceId: PhysicalResourceId.of(`reproject-${deployToken}`),
-    };
-    return new AwsCustomResource(stack, "ReprojectOnDeploy", {
-        onCreate: invocation,
-        onUpdate: invocation,
-        installLatestAwsSdk: false,
-        policy: AwsCustomResourcePolicy.fromStatements([
-            new PolicyStatement({ actions: ["lambda:InvokeFunction"], resources: [contentActions.functionArn] }),
-        ]),
+    const handler = new lambda.Function(stack, "DeployRenderHandler", {
+        runtime: lambda.Runtime.NODEJS_20_X,
+        handler: "index.handler",
+        code: lambda.Code.fromInline(DEPLOY_RENDER_HANDLER_SOURCE),
+        timeout: Duration.seconds(REPROJECT_ON_DEPLOY_TIMEOUT_SECONDS),
+        description: "Starts the post-deploy render of the site and fails the deploy if it cannot finish.",
+    });
+    handler.addToRolePolicy(new PolicyStatement({ actions: ["lambda:InvokeFunction"], resources: [contentActions.functionArn] }));
+    const provider = new Provider(stack, "DeployRenderProvider", { onEventHandler: handler });
+    new cloudwatch.Alarm(stack, "DeployRenderDriftAlarm", {
+        metric: new cloudwatch.Metric({
+            namespace: DEPLOY_RENDER_METRIC_NAMESPACE,
+            metricName: DEPLOY_RENDER_DRIFT_METRIC_NAME,
+            dimensionsMap: { FunctionName: contentActions.functionName },
+            statistic: "Maximum",
+            period: Duration.days(1),
+        }),
+        evaluationPeriods: 1,
+        threshold: 1,
+        comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+        treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+        alarmDescription: "The last post-deploy render found drift between the published content and the site store (stale pages, orphan pages or redirects). Nothing was deleted; run papyrus ops content project --reconcile to repair.",
+    });
+    return new CustomResource(stack, "ReprojectOnDeploy", {
+        serviceToken: provider.serviceToken,
+        properties: { FunctionName: contentActions.functionName, Task: DEPLOY_RENDER_TASK, DeployToken: deployToken },
     });
 }

package/amplify/publication/reproject-on-deploy.ts

@@ -1,9 +1,15 @@
-import { Stack } from "aws-cdk-lib";
+import { CustomResource, Duration, Stack } from "aws-cdk-lib";
+import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
 import { PolicyStatement } from "aws-cdk-lib/aws-iam";
-import type { IFunction } from "aws-cdk-lib/aws-lambda";
-import { AwsCustomResource, AwsCustomResourcePolicy, PhysicalResourceId } from "aws-cdk-lib/custom-resources";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import { Provider } from "aws-cdk-lib/custom-resources";
 
-export const REPROJECT_ON_DEPLOY_TIMEOUT_SECONDS = 300;
+export const REPROJECT_ON_DEPLOY_TIMEOUT_SECONDS = 900;
+export const DEPLOY_RENDER_METRIC_NAMESPACE = "Papyrus/Projection";
+export const DEPLOY_RENDER_DRIFT_METRIC_NAME = "DeployRenderDrift";
+export const DEPLOY_RENDER_TASK = "deploy-render";
+const FAILURE_MESSAGE_LIMIT = 600;
+const RESULT_SUMMARY_LIMIT = 900;
 
 export function reprojectDeployToken(environment: Record<string, string | undefined>, now: () => number = Date.now): string {
   const buildJobId = (environment.AWS_JOB_ID ?? "").trim();
@@ -11,26 +17,62 @@ export function reprojectDeployToken(environment: Record<string, string | undefi
 }
 
 /**
- * Starts the content-actions `all` projection task (asynchronously) every time the stack deploys.
- * The token is in the request, so CloudFormation sees a changed property on each deploy.
+ * Runs inside the deploy: invokes the content-actions Lambda synchronously, so a render that fails fails the
+ * stack update (and with it the Amplify build) with the failure in the build log. The Lambda's result, which
+ * includes the drift check, is written to its log and returned as the resource's data.
  */
-export function addReprojectOnDeploy(stack: Stack, contentActions: IFunction, deployToken: string): AwsCustomResource {
-  const invocation = {
-    service: "Lambda",
-    action: "invoke",
-    parameters: {
-      FunctionName: contentActions.functionName,
-      InvocationType: "Event",
-      Payload: JSON.stringify({ projectionTask: { task: "all", deployToken } }),
-    },
-    physicalResourceId: PhysicalResourceId.of(`reproject-${deployToken}`),
-  };
-  return new AwsCustomResource(stack, "ReprojectOnDeploy", {
-    onCreate: invocation,
-    onUpdate: invocation,
-    installLatestAwsSdk: false,
-    policy: AwsCustomResourcePolicy.fromStatements([
-      new PolicyStatement({ actions: ["lambda:InvokeFunction"], resources: [contentActions.functionArn] }),
-    ]),
+export const DEPLOY_RENDER_HANDLER_SOURCE = `
+const { LambdaClient, InvokeCommand } = require("@aws-sdk/client-lambda");
+
+exports.handler = async (event) => {
+  if (event.RequestType === "Delete") return { PhysicalResourceId: event.PhysicalResourceId };
+  const properties = event.ResourceProperties;
+  const client = new LambdaClient({ maxAttempts: 1 });
+  const response = await client.send(new InvokeCommand({
+    FunctionName: properties.FunctionName,
+    InvocationType: "RequestResponse",
+    Payload: JSON.stringify({ projectionTask: { task: properties.Task, deployToken: properties.DeployToken } }),
+  }));
+  const text = Buffer.from(response.Payload || []).toString("utf8");
+  console.log("deploy render result: " + text);
+  if (response.FunctionError) {
+    throw new Error("The post-deploy render failed (" + response.FunctionError + "): " + text.slice(0, ${FAILURE_MESSAGE_LIMIT}));
+  }
+  return { PhysicalResourceId: "reproject-" + properties.DeployToken, Data: { Result: text.slice(0, ${RESULT_SUMMARY_LIMIT}) } };
+};
+`;
+
+/**
+ * Renders every published page after each backend deploy and checks the site store for drift (a dry run:
+ * nothing is deleted). The token is a property, so CloudFormation runs the resource again on every deploy.
+ */
+export function addReprojectOnDeploy(stack: Stack, contentActions: lambda.IFunction, deployToken: string): CustomResource {
+  const handler = new lambda.Function(stack, "DeployRenderHandler", {
+    runtime: lambda.Runtime.NODEJS_20_X,
+    handler: "index.handler",
+    code: lambda.Code.fromInline(DEPLOY_RENDER_HANDLER_SOURCE),
+    timeout: Duration.seconds(REPROJECT_ON_DEPLOY_TIMEOUT_SECONDS),
+    description: "Starts the post-deploy render of the site and fails the deploy if it cannot finish.",
+  });
+  handler.addToRolePolicy(new PolicyStatement({ actions: ["lambda:InvokeFunction"], resources: [contentActions.functionArn] }));
+  const provider = new Provider(stack, "DeployRenderProvider", { onEventHandler: handler });
+  new cloudwatch.Alarm(stack, "DeployRenderDriftAlarm", {
+    metric: new cloudwatch.Metric({
+      namespace: DEPLOY_RENDER_METRIC_NAMESPACE,
+      metricName: DEPLOY_RENDER_DRIFT_METRIC_NAME,
+      dimensionsMap: { FunctionName: contentActions.functionName },
+      statistic: "Maximum",
+      period: Duration.days(1),
+    }),
+    evaluationPeriods: 1,
+    threshold: 1,
+    comparisonOperator: cloudwatch.ComparisonOperator.GREATER_THAN_OR_EQUAL_TO_THRESHOLD,
+    treatMissingData: cloudwatch.TreatMissingData.NOT_BREACHING,
+    alarmDescription:
+      "The last post-deploy render found drift between the published content and the site store (stale pages, orphan pages or redirects). Nothing was deleted; run papyrus ops content project --reconcile to repair.",
+  });
+  return new CustomResource(stack, "ReprojectOnDeploy", {
+    serviceToken: provider.serviceToken,
+    properties: { FunctionName: contentActions.functionName, Task: DEPLOY_RENDER_TASK, DeployToken: deployToken },
   });
 }

package/app/[year]/[month]/[day]/[articleSlug]/page.tsx

@@ -4,9 +4,14 @@ import { getCachedEditionItem, loadCachedEditionContent } from "../../../../../l
 import { getEditionDatePath, parseEditionArticleRoute } from "../../../../../lib/edition-routes";
 import { buildPresentationFooterEntries } from "../../../../../lib/presentation-footer";
 import { SITE_BRAND } from "../../../../../lib/site-brand";
+import { generateEditionItemStaticParams } from "../../../../../lib/reader-static-params";
 // Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
 export const revalidate = 60;
 
+export async function generateStaticParams() {
+  return generateEditionItemStaticParams();
+}
+
 type DateScopedArticlePageProps = {
   params: Promise<{
     year: string;

package/app/[year]/[month]/[day]/page/[pageNumber]/page.tsx

@@ -2,9 +2,14 @@ import { notFound, redirect } from "next/navigation";
 import { EditionRoutePage } from "../../edition-route-page";
 import { parseEditionPageRoute } from "../../../../../../lib/edition-routes";
 import { getDefaultPretextLayout, getForcedPresentation } from "../../../../../../lib/site-brand";
+import { generateEditionPageStaticParams } from "../../../../../../lib/reader-static-params";
 // Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
 export const revalidate = 60;
 
+export async function generateStaticParams() {
+  return generateEditionPageStaticParams();
+}
+
 type EditionPageRouteProps = {
   params: Promise<{
     year: string;

package/app/[year]/[month]/[day]/section/[sectionKey]/page.tsx

@@ -2,9 +2,14 @@ import { notFound, redirect } from "next/navigation";
 import { EditionRoutePage } from "../../edition-route-page";
 import { createSectionKey } from "../../../../../../lib/edition-sections";
 import { parseEditionSectionRoute } from "../../../../../../lib/edition-routes";
+import { generateEditionSectionStaticParams } from "../../../../../../lib/reader-static-params";
 // Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
 export const revalidate = 60;
 
+export async function generateStaticParams() {
+  return generateEditionSectionStaticParams();
+}
+
 type EditionSectionRouteProps = {
   params: Promise<{
     year: string;

package/app/api/revalidate/route.ts

@@ -10,6 +10,7 @@ import {
   editionItemCacheTag,
 } from "../../../lib/cached-content-repository";
 import { isAuthorizedRevalidateRequest } from "../../../lib/revalidate-secret";
+import { prewarmPaths, resolvePrewarmOrigin } from "../../../lib/revalidate-prewarm";
 import { getEditionArticlePath, getEditionDatePath } from "../../../lib/edition-routes";
 
 export const dynamic = "force-dynamic";
@@ -20,6 +21,7 @@ type RevalidateRequestBody = {
   itemSlugs?: string[];
   paths?: string[];
   tags?: string[];
+  prewarm?: boolean;
 };
 
 export async function POST(request: Request) {
@@ -87,9 +89,14 @@ export async function POST(request: Request) {
     revalidatedPaths.add(normalized);
   }
 
+  const prewarmed = body.prewarm === false
+    ? []
+    : await prewarmPaths(resolvePrewarmOrigin(request.url), [...revalidatedPaths]);
+
   return NextResponse.json({
     ok: true,
     revalidatedTags: [...revalidatedTags],
     revalidatedPaths: [...revalidatedPaths],
+    prewarmed,
   });
 }

package/app/page.tsx

@@ -2,6 +2,7 @@ import { getSiteRenderer } from "../lib/site-renderer";
 import { contentRepository, getScenarioIdParam } from "../lib/content-repository";
 import type { EditionContent } from "../lib/content-types";
 import { createEditionSectionPlan } from "../lib/edition-sections";
+import { getCachedLatestPublishedEdition, loadCachedEditionContent } from "../lib/cached-content-repository";
 import { getEditionDatePath } from "../lib/edition-routes";
 import {
   EMPTY_EDITION_PLACEHOLDER_SLUG,
@@ -77,7 +78,7 @@ export default async function Home({ searchParams }: HomePageProps) {
       );
     }
 
-    const latestEdition = await contentRepository.getLatestPublishedEdition();
+    const latestEdition = await getCachedLatestPublishedEdition();
     if (latestEdition) redirect(getEditionDatePath(latestEdition.editionDate));
     return <siteRenderer.renderEdition content={createEmptyGraphQLEdition()} />;
   }
@@ -88,9 +89,9 @@ export default async function Home({ searchParams }: HomePageProps) {
 }
 
 async function loadLatestGraphQLEdition(): Promise<EditionContent | null> {
-  const latestEdition = await contentRepository.getLatestPublishedEdition();
+  const latestEdition = await getCachedLatestPublishedEdition();
   if (!latestEdition) return null;
-  return contentRepository.loadEditionContent({ editionDate: latestEdition.editionDate });
+  return loadCachedEditionContent({ editionDate: latestEdition.editionDate });
 }
 
 async function loadFirstPublishedEditionPath(): Promise<string | undefined> {

package/lib/graphql-content-repository.ts

@@ -21,6 +21,7 @@ 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 { withRateLimitRetry } from "./rate-limit-retry";
 import { getContentSource } from "./site-env";
 
 const DEFAULT_EDITION_SLUG = "current";
@@ -157,17 +158,19 @@ async function withReaderGraphQLContext<T>(operation: () => Promise<T>): Promise
     return runWithContentSource(source, operation, client);
   }
   return runWithContentSource(source, () =>
-    runWithAmplifyServerContext({
-      nextServerContext: null,
-      operation: async () => {
-        readerContextClient = generateClient<Schema>({ authMode: authMode() });
-        try {
-          return await operation();
-        } finally {
-          readerContextClient = null;
-        }
-      },
-    }),
+    withRateLimitRetry(() =>
+      runWithAmplifyServerContext({
+        nextServerContext: null,
+        operation: async () => {
+          readerContextClient = generateClient<Schema>({ authMode: authMode() });
+          try {
+            return await operation();
+          } finally {
+            readerContextClient = null;
+          }
+        },
+      }),
+    ),
   );
 }
 

package/lib/rate-limit-retry.ts

@@ -0,0 +1,27 @@
+export const RATE_LIMIT_RETRY_ATTEMPTS = 6;
+export const RATE_LIMIT_RETRY_BASE_MILLISECONDS = 300;
+
+export function isRateLimitError(error: unknown): boolean {
+  if (!error || typeof error !== "object") return false;
+  const { name, message } = error as { name?: unknown; message?: unknown };
+  const text = `${typeof name === "string" ? name : ""} ${typeof message === "string" ? message : ""}`;
+  return /TooManyRequests|ThrottlingException|Rate exceeded|Unauthorized[\s\S]*set the \\?"authMode\\?"/i.test(text);
+}
+
+export async function withRateLimitRetry<T>(
+  operation: () => Promise<T>,
+  options: { attempts?: number; baseMilliseconds?: number; sleep?: (milliseconds: number) => Promise<void>; random?: () => number } = {},
+): Promise<T> {
+  const attempts = options.attempts ?? RATE_LIMIT_RETRY_ATTEMPTS;
+  const baseMilliseconds = options.baseMilliseconds ?? RATE_LIMIT_RETRY_BASE_MILLISECONDS;
+  const sleep = options.sleep ?? ((milliseconds: number) => new Promise<void>((resolve) => setTimeout(resolve, milliseconds)));
+  const random = options.random ?? Math.random;
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (attempt >= attempts || !isRateLimitError(error)) throw error;
+      await sleep(baseMilliseconds * 2 ** (attempt - 1) * (0.5 + random()));
+    }
+  }
+}

package/lib/reader-static-params.ts

@@ -1,3 +1,4 @@
+import type { ContentRepository, EditionContent } from "./content-types";
 import { graphqlContentRepository } from "./graphql-content-repository";
 import { SITE_BRAND } from "./site-brand";
 import { getContentSource } from "./site-env";
@@ -32,11 +33,23 @@ type EditionDateStaticParam = {
   day: string;
 };
 
-export async function generateEditionDateStaticParams(): Promise<EditionDateStaticParam[]> {
-  if (process.env.NODE_ENV === "development") return [];
-  if (!siteEnumeratesReaderRoutesAtBuild()) return [];
+const PUBLISHED_EDITION_ENUMERATION_LIMIT = 100;
+const DEEP_ROUTE_EDITION_LIMIT = 10;
+const RESERVED_DATE_CHILD_SEGMENTS = new Set(["page", "section"]);
+
+type EnumerationRepository = Pick<ContentRepository, "listPublishedEditions" | "loadEditionContent">;
+
+function shouldEnumerateAtBuild(): boolean {
+  if (process.env.NODE_ENV === "development") return false;
+  return siteEnumeratesReaderRoutesAtBuild();
+}
+
+export async function generateEditionDateStaticParams(
+  repository: EnumerationRepository = graphqlContentRepository,
+): Promise<EditionDateStaticParam[]> {
+  if (!shouldEnumerateAtBuild()) return [];
 
-  const { editions } = await graphqlContentRepository.listPublishedEditions({ limit: 100 });
+  const { editions } = await repository.listPublishedEditions({ limit: PUBLISHED_EDITION_ENUMERATION_LIMIT });
   const params: EditionDateStaticParam[] = [];
   for (const edition of editions) {
     const route = editionDateToStaticParam(edition.editionDate);
@@ -45,6 +58,61 @@ export async function generateEditionDateStaticParams(): Promise<EditionDateStat
   return params;
 }
 
+async function loadRecentEditionContents(repository: EnumerationRepository): Promise<EditionContent[]> {
+  const { editions } = await repository.listPublishedEditions({ limit: PUBLISHED_EDITION_ENUMERATION_LIMIT });
+  const recent = [...editions]
+    .sort((left, right) => right.editionDate.localeCompare(left.editionDate))
+    .slice(0, DEEP_ROUTE_EDITION_LIMIT);
+  return Promise.all(recent.map((edition) => repository.loadEditionContent({ editionDate: edition.editionDate })));
+}
+
+export async function generateEditionItemStaticParams(
+  repository: EnumerationRepository = graphqlContentRepository,
+): Promise<Array<EditionDateStaticParam & { articleSlug: string }>> {
+  if (!shouldEnumerateAtBuild()) return [];
+
+  const params: Array<EditionDateStaticParam & { articleSlug: string }> = [];
+  for (const content of await loadRecentEditionContents(repository)) {
+    const date = editionDateToStaticParam(content.editionDate);
+    if (!date) continue;
+    for (const item of content.items) {
+      if (RESERVED_DATE_CHILD_SEGMENTS.has(item.slug.toLowerCase())) continue;
+      params.push({ ...date, articleSlug: item.slug });
+    }
+  }
+  return params;
+}
+
+export async function generateEditionPageStaticParams(
+  repository: EnumerationRepository = graphqlContentRepository,
+): Promise<Array<EditionDateStaticParam & { pageNumber: string }>> {
+  if (!shouldEnumerateAtBuild()) return [];
+
+  const params: Array<EditionDateStaticParam & { pageNumber: string }> = [];
+  for (const content of await loadRecentEditionContents(repository)) {
+    const date = editionDateToStaticParam(content.editionDate);
+    if (!date) continue;
+    for (let pageNumber = 2; pageNumber <= content.layoutPlan.pages.length; pageNumber += 1) {
+      params.push({ ...date, pageNumber: String(pageNumber) });
+    }
+  }
+  return params;
+}
+
+export async function generateEditionSectionStaticParams(
+  repository: EnumerationRepository = graphqlContentRepository,
+): Promise<Array<EditionDateStaticParam & { sectionKey: string }>> {
+  if (!shouldEnumerateAtBuild()) return [];
+
+  const params: Array<EditionDateStaticParam & { sectionKey: string }> = [];
+  for (const content of await loadRecentEditionContents(repository)) {
+    const date = editionDateToStaticParam(content.editionDate);
+    if (!date) continue;
+    for (const section of content.sections) params.push({ ...date, sectionKey: section.key });
+  }
+  return params;
+}
+
 export async function generateArticleStaticParams(): Promise<Array<{ slug: string }>> {
   if (process.env.NODE_ENV === "development") return [];
   if (!siteEnumeratesReaderRoutesAtBuild()) return [];
@@ -64,6 +132,6 @@ function editionDateToStaticParam(editionDate: string): EditionDateStaticParam |
   return {
     year: match[1],
     month: monthName,
-    day: String(Number(match[3])),
+    day: match[3],
   };
 }

package/lib/revalidate-prewarm.ts

@@ -0,0 +1,53 @@
+export const PREWARM_ORIGIN_ENV = "PAPYRUS_PREWARM_ORIGIN";
+export const PREWARM_CONCURRENCY = 4;
+export const PREWARM_MAX_PATHS = 40;
+export const PREWARM_TIMEOUT_MILLISECONDS = 25_000;
+export const PREWARM_REQUEST_HEADER = "x-papyrus-prewarm";
+
+export type PrewarmFetch = (url: string, init: { headers: Record<string, string>; signal: AbortSignal; redirect: "manual" }) => Promise<{ status: number }>;
+
+export type PrewarmResult = {
+  path: string;
+  status: number | null;
+  milliseconds: number;
+};
+
+export function resolvePrewarmOrigin(requestUrl: string, environment: Record<string, string | undefined> = process.env): string {
+  const configured = environment[PREWARM_ORIGIN_ENV]?.trim();
+  if (configured) return configured.replace(/\/+$/, "");
+  return new URL(requestUrl).origin;
+}
+
+export async function prewarmPaths(
+  origin: string,
+  paths: string[],
+  options: { fetchPage?: PrewarmFetch; now?: () => number } = {},
+): Promise<PrewarmResult[]> {
+  const fetchPage = options.fetchPage ?? (fetch as unknown as PrewarmFetch);
+  const now = options.now ?? Date.now;
+  const queue = [...new Set(paths)].filter((path) => path.startsWith("/")).slice(0, PREWARM_MAX_PATHS);
+  const results: PrewarmResult[] = [];
+
+  async function worker(): Promise<void> {
+    for (let path = queue.shift(); path !== undefined; path = queue.shift()) {
+      const startedAt = now();
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), PREWARM_TIMEOUT_MILLISECONDS);
+      try {
+        const response = await fetchPage(`${origin}${path}`, {
+          headers: { [PREWARM_REQUEST_HEADER]: "1" },
+          signal: controller.signal,
+          redirect: "manual",
+        });
+        results.push({ path, status: response.status, milliseconds: now() - startedAt });
+      } catch {
+        results.push({ path, status: null, milliseconds: now() - startedAt });
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(PREWARM_CONCURRENCY, queue.length) }, worker));
+  return results;
+}

package/package.json

@@ -197,6 +197,7 @@
     "./lib/pretext-layout": "./lib/pretext-layout.ts",
     "./lib/public-placeholder-config": "./lib/public-placeholder-config.ts",
     "./lib/publication-items": "./lib/publication-items.ts",
+    "./lib/rate-limit-retry": "./lib/rate-limit-retry.ts",
     "./lib/reader-base-path": "./lib/reader-base-path.ts",
     "./lib/reader-cache-lifetime": "./lib/reader-cache-lifetime.ts",
     "./lib/reader-route-config": "./lib/reader-route-config.ts",
@@ -210,6 +211,7 @@
     "./lib/renderer-config": "./lib/renderer-config.ts",
     "./lib/renderer": "./lib/renderer.ts",
     "./lib/reporting-story-budget": "./lib/reporting-story-budget.ts",
+    "./lib/revalidate-prewarm": "./lib/revalidate-prewarm.ts",
     "./lib/revalidate-secret": "./lib/revalidate-secret.ts",
     "./lib/robots-policy": "./lib/robots-policy.ts",
     "./lib/root-route-redirect": "./lib/root-route-redirect.ts",
@@ -308,7 +310,7 @@
       "optional": true
     }
   },
-  "version": "1.0.0-next.52",
+  "version": "1.0.0-next.54",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-sdk/client-cognito-identity-provider": "3.1045.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0-next.52",
+  "version": "1.0.0-next.54",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",
@@ -16,7 +16,8 @@
       "reader": true,
       "hasDefault": true,
       "exports": [
-        "generateMetadata"
+        "generateMetadata",
+        "generateStaticParams"
       ],
       "config": {
         "revalidate": "60"
@@ -37,7 +38,9 @@
       "file": "app/[year]/[month]/[day]/page/[pageNumber]/page.tsx",
       "reader": true,
       "hasDefault": true,
-      "exports": [],
+      "exports": [
+        "generateStaticParams"
+      ],
       "config": {
         "revalidate": "60"
       }
@@ -46,7 +49,9 @@
       "file": "app/[year]/[month]/[day]/section/[sectionKey]/page.tsx",
       "reader": true,
       "hasDefault": true,
-      "exports": [],
+      "exports": [
+        "generateStaticParams"
+      ],
       "config": {
         "revalidate": "60"
       }