@anthusai/papyrus 2.0.0-next.41 → 2.0.0-next.43

package/amplify/plugins/reader-steering/papyrus.plugin.ts

@@ -15,14 +15,16 @@ export type { ReaderSteeringConfig };
 export const READER_STEERING_OUTPUT_KEY = "readerSteering";
 export const SNAPSHOT_SCHEDULE_PREFIX = "papyrus-reader-snapshot-";
 export const READER_SNAPSHOT_TASK = { projectionTask: { task: "reader-snapshot" } };
+export const READER_SCHEDULED_SNAPSHOT_TASK = { projectionTask: { task: "reader-snapshot", retirementPoll: true } };
+export const READER_POLL_SECRET_PARAMETER_ENV = "PAPYRUS_READER_POLL_SECRET_PARAMETER";
 
 export const readerSteeringManifest: PluginManifest = {
   name: "reader-steering",
   contract: 1,
-  models: ["ReaderProfile", "ReaderHandle", "ReaderVote"],
-  mutations: [],
+  models: ["ReaderProfile", "ReaderHandle", "ReaderVote", "ReaderSubmission", "ReaderComment", "ReaderReport", "ModerationAction"],
+  mutations: ["moderateReader"],
   guest: { mutations: [] },
-  newsroomPanels: [],
+  newsroomPanels: [{ id: "moderation", label: "Moderation" }],
   staticAssets: ["_plugins/papyrus-reader@1.js", "_plugins/papyrus-reader@1.css"],
 };
 
@@ -31,6 +33,9 @@ export function readerActionsSettings(config: ReaderSteeringConfig, allowInterim
   return {
     dimensions: config.dimensions,
     limits: config.limits,
+    submissions: config.submissions,
+    comments: config.comments,
+    moderation: config.moderation,
     reservedHandles: config.reservedHandles,
     allowInterimSubjects,
     snapshotDebounceSeconds: 60,
@@ -41,6 +46,7 @@ export function readerActionsSettings(config: ReaderSteeringConfig, allowInterim
 export function readerSnapshotSettings(config: ReaderSteeringConfig) {
   return {
     dimensions: config.dimensions,
+    submissions: config.submissions,
     karma: config.karma,
     ranking: config.ranking,
     hypeMinimum: config.snapshot.hypeMinimum,
@@ -53,12 +59,66 @@ export function interimSubjectsAllowedAtSynth(environment: Record<string, string
   return ["development", "test"].includes((environment.SITE_ENV ?? "").trim()) && environment.NODE_ENV !== "production";
 }
 
+/**
+ * The scheduled run polls Prospectus through the CMS route /api/reader/retired (docs/reader-steering.md), so it needs the
+ * site origin and the poll secret parameter that the app-shell stack generates (`cms.readerRetirementPoll`); both reach the
+ * backend build as branch variables. It also deletes and re-keys rows, and keeps its cursor in the rate table.
+ */
+function wireRetirementPoll(readerLambda: LambdaFunction, contentActions: LambdaFunction, tables: Record<string, ITable>) {
+  const origin = (process.env.PAPYRUS_SITE_ORIGIN ?? "").trim();
+  const parameterName = (process.env[READER_POLL_SECRET_PARAMETER_ENV] ?? "").trim();
+  if (!origin.startsWith("https://") || !parameterName.startsWith("/")) {
+    throw new Error(
+      "reader-steering retirementPoll needs PAPYRUS_SITE_ORIGIN (an https origin) and PAPYRUS_READER_POLL_SECRET_PARAMETER (an SSM parameter name). The app-shell template sets both on the production branch when site.json has cms.readerRetirementPoll: true; see docs/reader-steering.md.",
+    );
+  }
+  const rateTable = readerLambda.node.scope?.node.tryFindChild("PapyrusReaderRateWindows") as ITable | undefined;
+  if (!rateTable) throw new Error("reader-steering retirementPoll could not find the reader-actions rate table to keep its cursor in");
+  tables.ReaderVote.grantReadWriteData(contentActions);
+  tables.ReaderHandle.grantReadWriteData(contentActions);
+  rateTable.grantReadWriteData(contentActions);
+  contentActions.addEnvironment("PAPYRUS_READER_RATE_TABLE", rateTable.tableName);
+  contentActions.addEnvironment("PAPYRUS_READER_POLL_URL", origin);
+  contentActions.addEnvironment(READER_POLL_SECRET_PARAMETER_ENV, parameterName);
+  const stack = Stack.of(contentActions);
+  contentActions.addToRolePolicy(
+    new PolicyStatement({
+      effect: Effect.ALLOW,
+      actions: ["ssm:GetParameter"],
+      resources: [`arn:${stack.partition}:ssm:${stack.region}:${stack.account}:parameter${parameterName}`],
+    }),
+  );
+}
+
+/**
+ * AI moderation (`moderation.mode: ai`). The debounced run becomes a run of reader-actions itself (a one-off schedule that
+ * invokes this function), which judges the new items and then asks content-actions for the snapshot. So the scheduler role may
+ * invoke reader-actions, reader-actions may invoke content-actions (its ARN is already in the environment) and may read exactly
+ * one SSM SecureString: the API key, which the plugin never creates and never receives.
+ */
+function wireAiModeration(readerLambda: LambdaFunction, contentActions: LambdaFunction, schedulerRole: Role, apiKeyParameter: string) {
+  const stack = Stack.of(readerLambda);
+  readerLambda.grantInvoke(schedulerRole);
+  contentActions.grantInvoke(readerLambda);
+  readerLambda.addToRolePolicy(
+    new PolicyStatement({
+      effect: Effect.ALLOW,
+      actions: ["ssm:GetParameter"],
+      resources: [`arn:${stack.partition}:ssm:${stack.region}:${stack.account}:parameter${apiKeyParameter}`],
+    }),
+  );
+}
+
 export const readerSteeringPlugin: PapyrusPlugin<ReaderSteeringConfig, { readerActions: typeof readerActions }> = {
   manifest: readerSteeringManifest,
   resolveConfig: resolveReaderSteeringConfig,
   functions: () => ({ readerActions }),
   schemaDefinitions: readerSteeringSchemaDefinitions,
-  publicSettings: (config) => ({ contract: readerSteeringManifest.contract, dimensions: config.dimensions }),
+  publicSettings: (config) => ({
+    contract: readerSteeringManifest.contract,
+    dimensions: config.dimensions,
+    moderation: { mode: config.moderation.mode },
+  }),
   wire(backend, config, context: PluginWiringContext) {
     const lambda = backend.readerActions.resources.lambda as LambdaFunction;
     const tables = backend.data.resources.tables as Record<string, ITable>;
@@ -68,15 +128,25 @@ export const readerSteeringPlugin: PapyrusPlugin<ReaderSteeringConfig, { readerA
       ["PAPYRUS_READER_PROFILE_TABLE", "ReaderProfile"],
       ["PAPYRUS_READER_HANDLE_TABLE", "ReaderHandle"],
       ["PAPYRUS_READER_VOTE_TABLE", "ReaderVote"],
+      ["PAPYRUS_READER_SUBMISSION_TABLE", "ReaderSubmission"],
+      ["PAPYRUS_READER_COMMENT_TABLE", "ReaderComment"],
+      ["PAPYRUS_READER_REPORT_TABLE", "ReaderReport"],
+      ["PAPYRUS_READER_ACTION_TABLE", "ModerationAction"],
     ] as const) {
       tables[model].grantReadWriteData(lambda);
       lambda.addEnvironment(variable, tables[model].tableName);
       contentActions.addEnvironment(variable, tables[model].tableName);
     }
+    // Promoting a submission writes one draft Item (a version 1 draft; nothing is published by this function).
+    tables.Item.grantWriteData(lambda);
+    lambda.addEnvironment("PAPYRUS_READER_ITEM_TABLE", tables.Item.tableName);
     tables.PublishedItem.grantReadData(lambda);
     lambda.addEnvironment("PAPYRUS_READER_PUBLISHED_ITEM_TABLE", tables.PublishedItem.tableName);
     tables.ReaderVote.grantReadData(contentActions);
     tables.ReaderProfile.grantReadWriteData(contentActions);
+    // The snapshot reads submissions, and the review step writes their signals and moderation state.
+    tables.ReaderSubmission.grantReadWriteData(contentActions);
+    tables.ReaderComment.grantReadWriteData(contentActions);
 
     lambda.addEnvironment("PAPYRUS_READER_SETTINGS", JSON.stringify(readerActionsSettings(config, interimSubjectsAllowedAtSynth())));
     if (config.reservedConcurrency !== undefined) {
@@ -104,16 +174,25 @@ export const readerSteeringPlugin: PapyrusPlugin<ReaderSteeringConfig, { readerA
     lambda.addEnvironment("PAPYRUS_READER_SCHEDULER_ROLE_ARN", schedulerRole.roleArn);
     contentActions.addEnvironment("PAPYRUS_READER_SNAPSHOT_SETTINGS", JSON.stringify(readerSnapshotSettings(config)));
 
+    if (config.moderation.ai) wireAiModeration(lambda, contentActions, schedulerRole, config.moderation.ai.apiKeyParameter);
+
     lambda.addPermission("InvokeFromCmsCompute", {
       principal: new ArnPrincipal(config.computeRoleArn),
       action: "lambda:InvokeFunction",
     });
 
+    if (config.retirementPoll) wireRetirementPoll(lambda, contentActions, tables);
+
     if (config.snapshot.schedule) {
       new Rule(context.createStack("reader-steering-schedule"), "ReaderSnapshotSchedule", {
-        description: "Rebuilds the reader snapshot (time decay, Rising) and polls nothing else.",
+        description: "Rebuilds the reader snapshot (time decay, Rising) and, when enabled, applies Prospectus subject retirements.",
         schedule: Schedule.rate(Duration.hours(config.snapshot.intervalHours)),
-        targets: [new LambdaFunctionTarget(contentActions, { event: RuleTargetInput.fromObject(READER_SNAPSHOT_TASK), retryAttempts: 0 })],
+        targets: [
+          new LambdaFunctionTarget(contentActions, {
+            event: RuleTargetInput.fromObject(config.retirementPoll ? READER_SCHEDULED_SNAPSHOT_TASK : READER_SNAPSHOT_TASK),
+            retryAttempts: 0,
+          }),
+        ],
       });
     }
 

package/amplify/plugins/reader-steering/schema.js

@@ -1,8 +1,10 @@
 import { a } from "@aws-amplify/backend";
+import { readerActions } from "./function/resource.js";
 /**
  * Staff and IAM only: no guest, API key or reader rule on any model. The reader-actions function writes the
  * tables directly with its own role, and editors may list them; admins may delete. `id` is the lookup key:
- * the siteSubject for a profile, the lowercase handle for a claim and `subjectKey#readerId#dimension` for a vote.
+ * the siteSubject for a profile, the lowercase handle for a claim, `subjectKey#readerId#dimension` for a vote and
+ * `sub-<sha256 of the canonical URL>` for a submission (so a canonical URL is one submission).
  */
 const staffOnly = (allow) => [allow.group("editor").to(["read"]), allow.group("admin").to(["read", "delete"])];
 export function readerSteeringSchemaDefinitions() {
@@ -17,6 +19,7 @@ export function readerSteeringSchemaDefinitions() {
             karma: a.integer(),
         })
             .disableOperations(["subscriptions"])
+            .secondaryIndexes((index) => [index("readerId").name("profilesByReader").queryField("listReaderProfilesByReader")])
             .authorization(staffOnly),
         ReaderHandle: a
             .model({
@@ -36,5 +39,102 @@ export function readerSteeringSchemaDefinitions() {
         })
             .disableOperations(["subscriptions"])
             .authorization(staffOnly),
+        ReaderComment: a
+            .model({
+            id: a.id().required(),
+            subjectKey: a.string().required(),
+            readerId: a.string().required(),
+            body: a.string().required(),
+            parentId: a.string(),
+            ratingContext: a.json(),
+            state: a.string().required(),
+            signals: a.json(),
+            moderation: a.string().required(),
+            reportCount: a.integer(),
+            reviewedAt: a.datetime(),
+            editedAt: a.datetime(),
+            deletedAt: a.datetime(),
+            createdAt: a.datetime().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .secondaryIndexes((index) => [index("moderation").sortKeys(["createdAt"]).name("commentsByModeration").queryField("listReaderCommentsByModerationAndCreatedAt")])
+            .authorization(staffOnly),
+        ReaderSubmission: a
+            .model({
+            id: a.id().required(),
+            canonicalUrl: a.string().required(),
+            domain: a.string().required(),
+            title: a.string().required(),
+            kind: a.string().required(),
+            note: a.string(),
+            readerId: a.string().required(),
+            state: a.string().required(),
+            similar: a.string().array(),
+            signals: a.json(),
+            extractionState: a.string().required(),
+            itemId: a.string(),
+            moderation: a.string().required(),
+            reportCount: a.integer(),
+            reviewedAt: a.datetime(),
+            createdAt: a.datetime().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .secondaryIndexes((index) => [
+            index("domain").sortKeys(["createdAt"]).name("submissionsByDomain").queryField("listReaderSubmissionsByDomainAndCreatedAt"),
+            index("moderation").sortKeys(["createdAt"]).name("submissionsByModeration").queryField("listReaderSubmissionsByModerationAndCreatedAt"),
+        ])
+            .authorization(staffOnly),
+        ReaderReport: a
+            .model({
+            id: a.id().required(),
+            targetType: a.string().required(),
+            target: a.string().required(),
+            reporterReaderId: a.string().required(),
+            reason: a.string().required(),
+            state: a.string().required(),
+            closedAt: a.datetime(),
+            createdAt: a.datetime().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .secondaryIndexes((index) => [index("target").sortKeys(["createdAt"]).name("reportsByTarget").queryField("listReaderReportsByTargetAndCreatedAt")])
+            .authorization(staffOnly),
+        ModerationAction: a
+            .model({
+            id: a.id().required(),
+            by: a.string().required(),
+            actorSub: a.string().required(),
+            action: a.string().required(),
+            targetType: a.string().required(),
+            target: a.string().required(),
+            reason: a.string(),
+            fromState: a.string().required(),
+            toState: a.string().required(),
+            fromModeration: a.string(),
+            toModeration: a.string(),
+            undoOf: a.string(),
+            undoneBy: a.string(),
+            at: a.datetime().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .secondaryIndexes((index) => [index("target").sortKeys(["at"]).name("actionsByTarget").queryField("listModerationActionsByTargetAndAt")])
+            .authorization(staffOnly),
+        ModerationReceipt: a.customType({
+            status: a.string().required(),
+            id: a.string(),
+            error: a.string(),
+            message: a.string(),
+        }),
+        moderateReader: a
+            .mutation()
+            .arguments({
+            action: a.string().required(),
+            targetType: a.string().required(),
+            target: a.string().required(),
+            reason: a.string(),
+            undoOf: a.string(),
+        })
+            .returns(a.ref("ModerationReceipt"))
+            .authorization((allow) => [allow.group("editor"), allow.group("admin")])
+            .handler(a.handler.function(readerActions)),
     };
 }

package/amplify/plugins/reader-steering/schema.ts

@@ -1,9 +1,11 @@
 import { a } from "@aws-amplify/backend";
+import { readerActions } from "./function/resource";
 
 /**
  * Staff and IAM only: no guest, API key or reader rule on any model. The reader-actions function writes the
  * tables directly with its own role, and editors may list them; admins may delete. `id` is the lookup key:
- * the siteSubject for a profile, the lowercase handle for a claim and `subjectKey#readerId#dimension` for a vote.
+ * the siteSubject for a profile, the lowercase handle for a claim, `subjectKey#readerId#dimension` for a vote and
+ * `sub-<sha256 of the canonical URL>` for a submission (so a canonical URL is one submission).
  */
 const staffOnly = (allow: any) => [allow.group("editor").to(["read"]), allow.group("admin").to(["read", "delete"])];
 
@@ -19,6 +21,7 @@ export function readerSteeringSchemaDefinitions() {
         karma: a.integer(),
       })
       .disableOperations(["subscriptions"])
+      .secondaryIndexes((index) => [index("readerId").name("profilesByReader").queryField("listReaderProfilesByReader")])
       .authorization(staffOnly),
     ReaderHandle: a
       .model({
@@ -38,5 +41,102 @@ export function readerSteeringSchemaDefinitions() {
       })
       .disableOperations(["subscriptions"])
       .authorization(staffOnly),
+    ReaderComment: a
+      .model({
+        id: a.id().required(),
+        subjectKey: a.string().required(),
+        readerId: a.string().required(),
+        body: a.string().required(),
+        parentId: a.string(),
+        ratingContext: a.json(),
+        state: a.string().required(),
+        signals: a.json(),
+        moderation: a.string().required(),
+        reportCount: a.integer(),
+        reviewedAt: a.datetime(),
+        editedAt: a.datetime(),
+        deletedAt: a.datetime(),
+        createdAt: a.datetime().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .secondaryIndexes((index) => [index("moderation").sortKeys(["createdAt"]).name("commentsByModeration").queryField("listReaderCommentsByModerationAndCreatedAt")])
+      .authorization(staffOnly),
+    ReaderSubmission: a
+      .model({
+        id: a.id().required(),
+        canonicalUrl: a.string().required(),
+        domain: a.string().required(),
+        title: a.string().required(),
+        kind: a.string().required(),
+        note: a.string(),
+        readerId: a.string().required(),
+        state: a.string().required(),
+        similar: a.string().array(),
+        signals: a.json(),
+        extractionState: a.string().required(),
+        itemId: a.string(),
+        moderation: a.string().required(),
+        reportCount: a.integer(),
+        reviewedAt: a.datetime(),
+        createdAt: a.datetime().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .secondaryIndexes((index) => [
+        index("domain").sortKeys(["createdAt"]).name("submissionsByDomain").queryField("listReaderSubmissionsByDomainAndCreatedAt"),
+        index("moderation").sortKeys(["createdAt"]).name("submissionsByModeration").queryField("listReaderSubmissionsByModerationAndCreatedAt"),
+      ])
+      .authorization(staffOnly),
+    ReaderReport: a
+      .model({
+        id: a.id().required(),
+        targetType: a.string().required(),
+        target: a.string().required(),
+        reporterReaderId: a.string().required(),
+        reason: a.string().required(),
+        state: a.string().required(),
+        closedAt: a.datetime(),
+        createdAt: a.datetime().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .secondaryIndexes((index) => [index("target").sortKeys(["createdAt"]).name("reportsByTarget").queryField("listReaderReportsByTargetAndCreatedAt")])
+      .authorization(staffOnly),
+    ModerationAction: a
+      .model({
+        id: a.id().required(),
+        by: a.string().required(),
+        actorSub: a.string().required(),
+        action: a.string().required(),
+        targetType: a.string().required(),
+        target: a.string().required(),
+        reason: a.string(),
+        fromState: a.string().required(),
+        toState: a.string().required(),
+        fromModeration: a.string(),
+        toModeration: a.string(),
+        undoOf: a.string(),
+        undoneBy: a.string(),
+        at: a.datetime().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .secondaryIndexes((index) => [index("target").sortKeys(["at"]).name("actionsByTarget").queryField("listModerationActionsByTargetAndAt")])
+      .authorization(staffOnly),
+    ModerationReceipt: a.customType({
+      status: a.string().required(),
+      id: a.string(),
+      error: a.string(),
+      message: a.string(),
+    }),
+    moderateReader: a
+      .mutation()
+      .arguments({
+        action: a.string().required(),
+        targetType: a.string().required(),
+        target: a.string().required(),
+        reason: a.string(),
+        undoOf: a.string(),
+      })
+      .returns(a.ref("ModerationReceipt"))
+      .authorization((allow) => [allow.group("editor"), allow.group("admin")])
+      .handler(a.handler.function(readerActions)),
   };
 }

package/amplify/plugins/registry.js

@@ -1,7 +1,9 @@
+import { newsletterPlugin } from "./newsletter/papyrus.plugin.js";
 import { readerSteeringPlugin } from "./reader-steering/papyrus.plugin.js";
 import { signupPlugin } from "./signup/papyrus.plugin.js";
 /** Plugins are packaged with Papyrus and pinned by its version: there is no registry to fetch from. */
 export const KNOWN_PLUGINS = {
+    newsletter: newsletterPlugin,
     "reader-steering": readerSteeringPlugin,
     signup: signupPlugin,
 };

package/amplify/plugins/registry.ts

@@ -1,9 +1,11 @@
 import type { PapyrusPlugin, PluginRequest } from "./types";
+import { newsletterPlugin } from "./newsletter/papyrus.plugin";
 import { readerSteeringPlugin } from "./reader-steering/papyrus.plugin";
 import { signupPlugin } from "./signup/papyrus.plugin";
 
 /** Plugins are packaged with Papyrus and pinned by its version: there is no registry to fetch from. */
 export const KNOWN_PLUGINS: Record<string, PapyrusPlugin<any, any>> = {
+  newsletter: newsletterPlugin,
   "reader-steering": readerSteeringPlugin,
   signup: signupPlugin,
 };

package/amplify/plugins/types.ts

@@ -10,6 +10,8 @@ export type PluginManifest = {
   /** Public contract version. Bump it when a mutation input, a model field, an element name or an attribute changes. No compatibility shims. */
   contract: number;
   models: string[];
+  /** Custom queries it adds (operations that read). */
+  queries?: string[];
   mutations: string[];
   /** What an anonymous visitor may call. Everything else is closed to guests. */
   guest: { mutations: string[] };

package/app/api/newsletter/confirm/route.ts

@@ -0,0 +1,13 @@
+import type { NextRequest } from "next/server";
+import { handleNewsletterConfirmPage, handleNewsletterConfirmPost } from "../../../../lib/newsletter-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function GET(request: NextRequest) {
+  return handleNewsletterConfirmPage(request);
+}
+
+export function POST(request: NextRequest) {
+  return handleNewsletterConfirmPost(request);
+}

package/app/api/newsletter/preferences/route.ts

@@ -0,0 +1,13 @@
+import type { NextRequest } from "next/server";
+import { handleNewsletterPreferences } from "../../../../lib/newsletter-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function GET(request: NextRequest) {
+  return handleNewsletterPreferences(request);
+}
+
+export function POST(request: NextRequest) {
+  return handleNewsletterPreferences(request);
+}

package/app/api/newsletter/subscribe/route.ts

@@ -0,0 +1,9 @@
+import type { NextRequest } from "next/server";
+import { handleNewsletterSubscribe } from "../../../../lib/newsletter-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function POST(request: NextRequest) {
+  return handleNewsletterSubscribe(request);
+}

package/app/api/newsletter/unsubscribe/route.ts

@@ -0,0 +1,13 @@
+import type { NextRequest } from "next/server";
+import { handleNewsletterUnsubscribe } from "../../../../lib/newsletter-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function GET(request: NextRequest) {
+  return handleNewsletterUnsubscribe(request);
+}
+
+export function POST(request: NextRequest) {
+  return handleNewsletterUnsubscribe(request);
+}

package/app/api/reader/comment/delete/route.ts

@@ -0,0 +1,9 @@
+import type { NextRequest } from "next/server";
+import { handleReaderRequest } from "../../../../../lib/reader-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function POST(request: NextRequest) {
+  return handleReaderRequest(request, "comment-delete");
+}

package/app/api/reader/comment/edit/route.ts

@@ -0,0 +1,9 @@
+import type { NextRequest } from "next/server";
+import { handleReaderRequest } from "../../../../../lib/reader-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function POST(request: NextRequest) {
+  return handleReaderRequest(request, "comment-edit");
+}

package/app/api/reader/comment/route.ts

@@ -0,0 +1,9 @@
+import type { NextRequest } from "next/server";
+import { handleReaderRequest } from "../../../../lib/reader-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function POST(request: NextRequest) {
+  return handleReaderRequest(request, "comment");
+}

package/app/api/reader/report/route.ts

@@ -0,0 +1,9 @@
+import type { NextRequest } from "next/server";
+import { handleReaderRequest } from "../../../../lib/reader-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function POST(request: NextRequest) {
+  return handleReaderRequest(request, "report");
+}

package/app/api/reader/submit/route.ts

@@ -0,0 +1,9 @@
+import type { NextRequest } from "next/server";
+import { handleReaderRequest } from "../../../../lib/reader-api";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+export function POST(request: NextRequest) {
+  return handleReaderRequest(request, "submit");
+}