@anthusai/papyrus 5.39.0 → 5.41.0

package/lib/papyrus-private-chat-client.ts

@@ -0,0 +1,81 @@
+export type PapyrusPrivateChatChannel = {
+  channel_id: string;
+  participants: Array<{ kind: string; actor_id: string }>;
+};
+
+export type PapyrusPrivateChatMessage = {
+  message_id: string;
+  channel_id: string;
+  seq: number;
+  author_kind: "human" | "bot";
+  body: string;
+  addressed_to_bot_id: string | null;
+  created_at: string;
+};
+
+export type PapyrusPrivateChatSendResult = {
+  message: PapyrusPrivateChatMessage;
+  turn_id: string | null;
+};
+
+export type PapyrusPrivateChatFetch = typeof globalThis.fetch;
+
+const CHAT_API = "/api/newsroom/chat";
+
+async function requestJson<T>(path: string, init: RequestInit, fetcher: PapyrusPrivateChatFetch): Promise<T> {
+  const response = await fetcher(`${CHAT_API}/${path}`, {
+    ...init,
+    credentials: "same-origin",
+    cache: "no-store",
+  });
+  const payload = await response.json().catch(() => null) as Record<string, unknown> | null;
+  if (!response.ok) {
+    const error = typeof payload?.error === "string" ? payload.error
+      : typeof payload?.detail === "string" ? payload.detail
+        : `Private chat request failed (${response.status}).`;
+    throw new Error(error);
+  }
+  if (!payload || typeof payload !== "object") throw new Error("Private chat returned an invalid response.");
+  return payload as T;
+}
+
+/** Open the current editor's server-derived private channel using the signed same-origin session cookie. */
+export async function openPapyrusPrivateChat(fetcher: PapyrusPrivateChatFetch = globalThis.fetch): Promise<PapyrusPrivateChatChannel> {
+  const result = await requestJson<PapyrusPrivateChatChannel>("private-channel", { method: "POST" }, fetcher);
+  if (!result.channel_id?.trim() || !Array.isArray(result.participants)) {
+    throw new Error("Private chat returned an invalid channel.");
+  }
+  return result;
+}
+
+/** Read only the private channel returned by the host's authenticated open request. */
+export async function listPapyrusPrivateChatMessages(
+  channelId: string,
+  fetcher: PapyrusPrivateChatFetch = globalThis.fetch,
+): Promise<PapyrusPrivateChatMessage[]> {
+  if (!channelId.trim()) throw new Error("A private chat channel is required.");
+  const result = await requestJson<{ messages?: unknown }>(`channels/${encodeURIComponent(channelId)}/messages`, { method: "GET" }, fetcher);
+  if (!Array.isArray(result.messages)) throw new Error("Private chat returned an invalid message list.");
+  return result.messages as PapyrusPrivateChatMessage[];
+}
+
+/** One explicit send. The browser sends neither its tenant nor author or bot identity. */
+export async function sendPapyrusPrivateChatMessage(
+  channelId: string,
+  body: string,
+  idempotencyKey: string,
+  fetcher: PapyrusPrivateChatFetch = globalThis.fetch,
+): Promise<PapyrusPrivateChatSendResult> {
+  if (!channelId.trim() || !body.trim() || !idempotencyKey.trim()) {
+    throw new Error("A channel, message and idempotency key are required.");
+  }
+  const result = await requestJson<PapyrusPrivateChatSendResult>(`channels/${encodeURIComponent(channelId)}/messages`, {
+    method: "POST",
+    headers: { "content-type": "application/json", "idempotency-key": idempotencyKey },
+    body: JSON.stringify({ body }),
+  }, fetcher);
+  if (!result.message?.message_id || result.message.channel_id !== channelId) {
+    throw new Error("Private chat returned an invalid sent message.");
+  }
+  return result;
+}

package/lib/prospectus-session.ts

@@ -1,5 +1,6 @@
 import { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from "node:crypto";
 import { GetParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+import type { NextRequest } from "next/server";
 import { readAmplifyOutputsFile } from "./amplify-outputs-path";
 import {
   ProspectusSiteAccounts,
@@ -42,6 +43,20 @@ export interface ProspectusSignedInSession {
   siteSubject?: string;
 }
 
+/** Open the existing sealed Prospectus session cookie for one server request. */
+export function signedInProspectusSession(
+  request: Pick<NextRequest, "cookies">,
+  sealingSecret: string,
+  nowInSeconds?: number,
+): ProspectusSignedInSession | null {
+  return openProspectusCookie<ProspectusSignedInSession>(
+    sealingSecret,
+    PROSPECTUS_SESSION_COOKIE,
+    request.cookies.get(PROSPECTUS_SESSION_COOKIE)?.value,
+    nowInSeconds,
+  );
+}
+
 function sealingKeyForCookie(sealingSecret: string, cookieName: string): Buffer {
   if (sealingSecret.length < MINIMUM_SEALING_SECRET_LENGTH) throw new Error("The Prospectus session sealing secret is too short.");
   return Buffer.from(hkdfSync("sha256", sealingSecret, SEALED_COOKIE_KEY_DERIVATION_SALT, cookieName, 32));

package/lib/prospectus-sign-in-routes.ts

@@ -12,6 +12,7 @@ import {
   PROSPECTUS_SESSION_COOKIE,
   openProspectusCookie,
   resolveProspectusSignInRuntime,
+  signedInProspectusSession,
   sameSiteReturnPath,
   sealProspectusCookie,
   sealedCookieAttributes,
@@ -115,18 +116,7 @@ function signInFailedRedirect(request: NextRequest, options: ProspectusSignInRou
   return NextResponse.redirect(target, { status: 303, headers: NO_STORE_HEADERS });
 }
 
-export function signedInProspectusSession(
-  request: NextRequest,
-  sealingSecret: string,
-  nowInSeconds?: number,
-): ProspectusSignedInSession | null {
-  return openProspectusCookie<ProspectusSignedInSession>(
-    sealingSecret,
-    PROSPECTUS_SESSION_COOKIE,
-    request.cookies.get(PROSPECTUS_SESSION_COOKIE)?.value,
-    nowInSeconds,
-  );
-}
+export { signedInProspectusSession } from "./prospectus-session";
 
 /** `returnTo` from the query (a link) or, for the POST form the reader plugin's button submits, from the form body. */
 async function requestedReturnPath(request: NextRequest): Promise<string | null> {

package/lib/review-client.ts

@@ -100,18 +100,21 @@ export async function markReviewRead(userKey: string, requestId: string, now: Da
 
 const MAX_TITLE_LOOKUPS = 40;
 
-/** Titles of the stories that review requests are about, by lineage id. A story that cannot be read simply has no entry (the card falls back to the id). */
-export async function loadStoryTitles(ids: string[]): Promise<Record<string, string>> {
+/** Titles of the stories that review requests are about, by lineage id, and the ids of stories that no longer exist (no version of the lineage remains). A story that cannot be read simply has no entry (the card falls back to the id). */
+export async function loadStoryTitles(ids: string[]): Promise<{ titles: Record<string, string>; deleted: string[] }> {
   const titles: Record<string, string> = {};
+  const deleted: string[] = [];
   await Promise.all([...new Set(ids)].slice(0, MAX_TITLE_LOOKUPS).map(async (id) => {
     const result = await run(
       `query StoryTitle($lineageId: ID!) { listItemsByLineageAndVersion(lineageId: $lineageId, limit: 50) { items { versionNumber headline title } } }`,
       { lineageId: id },
     );
+    // Only a clean, empty answer means the story is gone; a failed lookup says nothing.
+    if (!result.errors?.length && result.data?.listItemsByLineageAndVersion && !(result.data.listItemsByLineageAndVersion.items ?? []).filter(Boolean).length) deleted.push(id);
     const items = (result.data?.listItemsByLineageAndVersion?.items ?? []).filter(Boolean) as { versionNumber?: number; headline?: string; title?: string }[];
     const newest = items.sort((a, b) => (b.versionNumber ?? 0) - (a.versionNumber ?? 0))[0];
     const title = newest?.headline || newest?.title;
     if (title) titles[id] = title;
   }));
-  return titles;
+  return { titles, deleted };
 }

package/lib/review-requests.ts

@@ -13,7 +13,7 @@ import type { RelevanceDecisionView } from "./relevance-decisions";
 
 export type ReviewMode = "flag" | "soft_review" | "hard_gate";
 export type ReviewState = "open" | "answered" | "timed_out" | "withdrawn";
-export type ReviewDecision = "approve" | "reject" | "feedback";
+export type ReviewDecision = "approve" | "acknowledge" | "reject" | "feedback";
 export type ReviewSteer = "adjust" | "not_this_kind";
 
 export type ReviewAnswer = { decision: ReviewDecision; feedback: string | null; steer: ReviewSteer | null; by: string; at: string };
@@ -89,6 +89,7 @@ export type AnswerInput = { decision: ReviewDecision; feedback?: string | null;
 /** The update for an answer, or an Error saying why it is refused. Applied with the condition state = open. */
 export function answerUpdate(request: ReviewRequest, input: AnswerInput, by: string, now: Date): Record<string, unknown> {
   if (request.state !== "open") throw new Error(`This request is ${request.state.replace("_", " ")}${request.state === "timed_out" ? ` (${PROCEEDED_WITHOUT_REVIEW})` : ""} and can no longer be answered.`);
+  if (input.decision === "acknowledge" && request.mode !== "flag") throw new Error("Only a flag is acknowledged; approve or reject this one.");
   const feedback = input.feedback?.trim() || null;
   const steer = input.steer ?? null;
   if (input.decision === "feedback" && !feedback && !steer) throw new Error("Write a note, or choose \"Not this kind of thing\".");
@@ -126,12 +127,13 @@ export function nextText(request: ReviewRequest): string {
   if (request.state === "timed_out") return `Proceeded without review on ${formatWhen(request.updatedAt)}.`;
   if (request.state === "withdrawn") return "Withdrawn by the step that raised it.";
   const answer = request.answer;
-  return answer ? `${answerWords(answer)} by ${answer.by} on ${formatWhen(answer.at)}.` : "Answered.";
+  return answer ? `${answerWords(answer, request)} by ${answer.by} on ${formatWhen(answer.at)}.` : "Answered.";
 }
 
-export function answerWords(answer: ReviewAnswer): string {
+export function answerWords(answer: ReviewAnswer, request?: Pick<ReviewRequest, "mode">): string {
   if (answer.steer === "not_this_kind") return "Steered: not this kind of thing";
-  if (answer.decision === "approve") return "Approved";
+  if (answer.decision === "acknowledge") return "Acknowledged";
+  if (answer.decision === "approve") return request?.mode === "flag" ? "Acknowledged" : "Approved";
   if (answer.decision === "reject") return "Rejected";
   return "Steered with a note";
 }
@@ -146,8 +148,8 @@ export function steeringText(request: ReviewRequest): string | null {
 }
 
 /** What a request is about, in words: a story shows its title (the id when the title is not known), anything else its type and id. */
-export function subjectLabel(subject: { type: string; id: string }, titles: Readonly<Record<string, string>> = {}): string {
-  if (subject.type === "story") return titles[subject.id] ?? `story ${subject.id}`;
+export function subjectLabel(subject: { type: string; id: string }, titles: Readonly<Record<string, string>> = {}, deleted: ReadonlySet<string> = new Set()): string {
+  if (subject.type === "story") return deleted.has(subject.id) ? `story ${subject.id} (story deleted)` : titles[subject.id] ?? `story ${subject.id}`;
   return `${subject.type.replace("_", " ")} ${subject.id}`;
 }
 

package/lib/shared-chat-admission.ts

@@ -0,0 +1,182 @@
+/**
+ * Code-local trust contract for a site-hosted shared chat adapter.
+ *
+ * This module does not verify JWT signatures and is not an HTTP endpoint. The
+ * hosting server must inject a real verifier and authoritative membership
+ * resolver. Never construct VerifiedChatCredential from request JSON.
+ */
+
+export type TokenUse = string;
+
+/** Claims returned only after the injected host verifier has validated the JWT. */
+export interface VerifiedChatCredential {
+  subject: string;
+  issuer: string;
+  audiences: readonly string[];
+  clientId?: string;
+  tokenUse?: TokenUse;
+  expiresAtEpochSeconds: number;
+  notBeforeEpochSeconds?: number;
+  issuedAtEpochSeconds?: number;
+}
+
+export interface AudienceRule {
+  /** Explicitly choose which JWT claim is authoritative for this host. */
+  claim: "aud" | "client_id";
+  expectedValue: string;
+}
+
+export interface ChatHostTrustProfile {
+  issuer: string;
+  audienceRule: AudienceRule;
+  /** Must be configured by the host after verifying its actual token contract. */
+  acceptedTokenUses: readonly TokenUse[];
+  configuredSiteId: string;
+  clockSkewSeconds?: number;
+}
+
+export interface ChatRequest {
+  authorization?: string;
+  channelId: string;
+  idempotencyKey: string;
+  message: { text: string; authorSub?: string; accountId?: string; siteId?: string };
+}
+
+export interface ChatMembership {
+  accountId: string;
+  siteId: string;
+  editorSub: string;
+  active: boolean;
+  /** Host-derived authorization for the editorial chat surface (editor/admin policy). */
+  canUseEditorialChat: boolean;
+}
+
+export interface TranscriptOwner {
+  accountId: string;
+  siteId: string;
+  editorSub: string;
+  channelId: string;
+}
+
+export interface SharedChatAdmissionDependencies {
+  trust: ChatHostTrustProfile;
+  nowEpochSeconds?: () => number;
+  verifyCredential: (rawCredential: string) => Promise<VerifiedChatCredential | null>;
+  resolveMembership: (subject: string, configuredSiteId: string) => Promise<ChatMembership | null>;
+  resolveTranscriptOwner: (channelId: string) => Promise<TranscriptOwner | null>;
+}
+
+export interface AdmittedChatMessage {
+  owner: TranscriptOwner;
+  idempotencyKey: string;
+  /** Stable canonical representation used for payload-reuse detection. */
+  payloadFingerprint: string;
+}
+
+export class ChatAdmissionError extends Error {
+  readonly code: "unauthorized" | "forbidden" | "invalid_request" | "idempotency_conflict";
+
+  constructor(code: ChatAdmissionError["code"]) {
+    super(code);
+    this.name = "ChatAdmissionError";
+    this.code = code;
+  }
+}
+
+const reject = (code: ChatAdmissionError["code"]): never => { throw new ChatAdmissionError(code); };
+
+function bearerToken(value: string | undefined): string {
+  const match = value?.match(/^Bearer ([^\s]+)$/i);
+  if (!match) return reject("unauthorized");
+  return match[1];
+}
+
+function assertCredential(credential: VerifiedChatCredential, trust: ChatHostTrustProfile, now: number): void {
+  const skew = Math.max(0, trust.clockSkewSeconds ?? 0);
+  if (!trust.issuer || credential.issuer !== trust.issuer) reject("unauthorized");
+  if (!trust.acceptedTokenUses.length || !credential.tokenUse || !trust.acceptedTokenUses.includes(credential.tokenUse)) reject("unauthorized");
+  if (!Number.isFinite(credential.expiresAtEpochSeconds) || now - skew >= credential.expiresAtEpochSeconds) reject("unauthorized");
+  if (credential.notBeforeEpochSeconds !== undefined && now + skew < credential.notBeforeEpochSeconds) reject("unauthorized");
+  if (credential.issuedAtEpochSeconds !== undefined && now + skew < credential.issuedAtEpochSeconds) reject("unauthorized");
+
+  const audienceMatches = trust.audienceRule.claim === "aud"
+    ? credential.audiences.includes(trust.audienceRule.expectedValue)
+    : credential.clientId === trust.audienceRule.expectedValue;
+  if (!audienceMatches) reject("unauthorized");
+}
+
+/** Authenticate, derive the current host membership, and enforce private channel ownership. */
+export async function admitSharedChatMessage(
+  request: ChatRequest,
+  dependencies: SharedChatAdmissionDependencies,
+): Promise<AdmittedChatMessage> {
+  if (!request.channelId || !request.message.text.trim() || !/^[A-Za-z0-9._~-]{16,128}$/.test(request.idempotencyKey)) {
+    return reject("invalid_request");
+  }
+
+  const rawCredential = bearerToken(request.authorization);
+  const credential = await dependencies.verifyCredential(rawCredential);
+  if (!credential) return reject("unauthorized");
+  const now = (dependencies.nowEpochSeconds ?? (() => Date.now() / 1000))();
+  assertCredential(credential, dependencies.trust, now);
+
+  const membership = await dependencies.resolveMembership(credential.subject, dependencies.trust.configuredSiteId);
+  if (!membership || !membership.active || !membership.canUseEditorialChat
+    || membership.editorSub !== credential.subject || membership.siteId !== dependencies.trust.configuredSiteId) {
+    return reject("forbidden");
+  }
+  if ((request.message.authorSub && request.message.authorSub !== membership.editorSub)
+    || (request.message.accountId && request.message.accountId !== membership.accountId)
+    || (request.message.siteId && request.message.siteId !== membership.siteId)) {
+    return reject("forbidden");
+  }
+
+  const expectedOwner: TranscriptOwner = {
+    accountId: membership.accountId,
+    siteId: membership.siteId,
+    editorSub: membership.editorSub,
+    channelId: request.channelId,
+  };
+  const actualOwner = await dependencies.resolveTranscriptOwner(request.channelId);
+  if (!actualOwner || actualOwner.accountId !== expectedOwner.accountId || actualOwner.siteId !== expectedOwner.siteId
+    || actualOwner.editorSub !== expectedOwner.editorSub || actualOwner.channelId !== expectedOwner.channelId) {
+    return reject("forbidden");
+  }
+
+  return {
+    owner: expectedOwner,
+    idempotencyKey: request.idempotencyKey,
+    payloadFingerprint: JSON.stringify([request.channelId, request.message.text]),
+  };
+}
+
+export interface IdempotencyRequest<T> {
+  /** Storage must atomically scope key by the derived owner and operation. */
+  scope: string;
+  key: string;
+  payloadFingerprint: string;
+  run: () => Promise<T>;
+}
+
+/**
+ * Store contract for replay-safe writes. Production implementations must be
+ * atomic/durable (for example conditional put + canonical result); this module
+ * deliberately supplies no in-memory production store.
+ */
+export interface ChatIdempotencyStore {
+  executeOnce<T>(request: IdempotencyRequest<T>): Promise<T>;
+}
+
+export function runAdmittedChatMessage<T>(
+  admission: AdmittedChatMessage,
+  store: ChatIdempotencyStore,
+  operation: () => Promise<T>,
+): Promise<T> {
+  const { accountId, siteId, editorSub, channelId } = admission.owner;
+  return store.executeOnce({
+    scope: JSON.stringify(["chat-message", accountId, siteId, editorSub, channelId]),
+    key: admission.idempotencyKey,
+    payloadFingerprint: admission.payloadFingerprint,
+    run: operation,
+  });
+}

package/lib/site-origin-value.ts

@@ -0,0 +1,50 @@
+import type { NextRequest } from "next/server";
+import { getSiteEnv } from "./site-env";
+
+type EnvironmentVariables = Record<string, string | undefined>;
+
+export const SITE_ORIGIN_ENV = "PAPYRUS_SITE_ORIGIN";
+
+export class SiteOriginNotConfiguredError extends Error {
+  readonly status = 503;
+  readonly code = "site_origin_not_configured";
+}
+
+function isLoopbackHostname(hostname: string): boolean {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+
+function configuredOrigin(value: string): string {
+  const invalid = () => new SiteOriginNotConfiguredError(`${SITE_ORIGIN_ENV} must be an https origin such as https://example.com with no path.`);
+  let parsed: URL;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw invalid();
+  }
+  if (parsed.protocol !== "https:" || parsed.origin !== value) throw invalid();
+  return parsed.origin;
+}
+
+function siteEnvOrNull(environment: EnvironmentVariables): string | null {
+  try {
+    return getSiteEnv(environment);
+  } catch {
+    return null;
+  }
+}
+
+/** The site's public origin from trusted configuration, never Host or forwarded headers. */
+export function publicSiteOrigin(request: Pick<NextRequest, "nextUrl">, environment: EnvironmentVariables = process.env): string {
+  const configured = (environment[SITE_ORIGIN_ENV] ?? "").trim();
+  if (configured) return configuredOrigin(configured);
+  const { hostname, origin } = request.nextUrl;
+  const developing = siteEnvOrNull(environment) === "development" && environment.NODE_ENV !== "production";
+  if (isLoopbackHostname(hostname) && developing) return origin;
+  throw new SiteOriginNotConfiguredError(`${SITE_ORIGIN_ENV} is not set; this site cannot tell its public origin.`);
+}
+
+/** An absolute URL on the site's trusted public origin. */
+export function publicSiteUrl(path: string, request: Pick<NextRequest, "nextUrl">, environment: EnvironmentVariables = process.env): URL {
+  return new URL(path, publicSiteOrigin(request, environment));
+}

package/lib/site-origin.ts

@@ -1,67 +1,8 @@
-import { NextResponse, type NextRequest } from "next/server";
-import { getSiteEnv } from "./site-env";
+import { NextResponse } from "next/server";
+import { SiteOriginNotConfiguredError } from "./site-origin-value";
 
-type EnvironmentVariables = Record<string, string | undefined>;
-
-export const SITE_ORIGIN_ENV = "PAPYRUS_SITE_ORIGIN";
-
-/**
- * The site's public origin cannot be read from the request on Amplify SSR (WEB_COMPUTE):
- * there `request.nextUrl.origin` is the compute adapter's internal https://localhost:3000.
- * It also must never be derived from Host or X-Forwarded-* headers, which a client can set.
- * The one trusted source is PAPYRUS_SITE_ORIGIN, set by the app shell from the site's host.
- */
-export class SiteOriginNotConfiguredError extends Error {
-  readonly status = 503;
-  readonly code = "site_origin_not_configured";
-}
+export { SITE_ORIGIN_ENV, SiteOriginNotConfiguredError, publicSiteOrigin, publicSiteUrl } from "./site-origin-value";
 
 export function siteOriginNotConfiguredResponse(error: SiteOriginNotConfiguredError): NextResponse {
   return NextResponse.json({ error: error.code, message: error.message }, { status: error.status, headers: { "cache-control": "no-store" } });
 }
-
-function isLoopbackHostname(hostname: string): boolean {
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
-}
-
-function configuredOrigin(value: string): string {
-  const invalid = () => new SiteOriginNotConfiguredError(`${SITE_ORIGIN_ENV} must be an https origin such as https://example.com with no path.`);
-  let parsed: URL;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw invalid();
-  }
-  if (parsed.protocol !== "https:" || parsed.origin !== value) throw invalid();
-  return parsed.origin;
-}
-
-function siteEnvOrNull(environment: EnvironmentVariables): string | null {
-  try {
-    return getSiteEnv(environment);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * The site's public origin, from trusted configuration.
- * - PAPYRUS_SITE_ORIGIN set: it must be an https origin with no path; it is used as is.
- * - Unset: `request.nextUrl.origin` only when it is loopback, SITE_ENV resolves to development
- *   and NODE_ENV is not production (a local `next dev` server). Anything else, production and staging included, throws
- *   SiteOriginNotConfiguredError so routes answer 503 instead of redirecting to localhost.
- */
-export function publicSiteOrigin(request: Pick<NextRequest, "nextUrl">, environment: EnvironmentVariables = process.env): string {
-  const configured = (environment[SITE_ORIGIN_ENV] ?? "").trim();
-  if (configured) return configuredOrigin(configured);
-  const { hostname, origin } = request.nextUrl;
-  // SITE_ENV defaults to development when a runtime never received it, so NODE_ENV=production also closes the fallback.
-  const developing = siteEnvOrNull(environment) === "development" && environment.NODE_ENV !== "production";
-  if (isLoopbackHostname(hostname) && developing) return origin;
-  throw new SiteOriginNotConfiguredError(`${SITE_ORIGIN_ENV} is not set; this site cannot tell its public origin.`);
-}
-
-/** An absolute URL on the site's public origin, for redirects. Fails closed like publicSiteOrigin. */
-export function publicSiteUrl(path: string, request: Pick<NextRequest, "nextUrl">, environment: EnvironmentVariables = process.env): URL {
-  return new URL(path, publicSiteOrigin(request, environment));
-}

package/package.json

@@ -117,7 +117,9 @@
     "./components/newsroom-theme": "./components/newsroom-theme.tsx",
     "./components/newsroom-topics-view": "./components/newsroom-topics-view.tsx",
     "./components/notification-center": "./components/notification-center.tsx",
+    "./components/papyrus-console-conversation": "./components/papyrus-console-conversation.tsx",
     "./components/papyrus-console-shell": "./components/papyrus-console-shell.tsx",
+    "./components/papyrus-private-chat-panel": "./components/papyrus-private-chat-panel.tsx",
     "./components/pictogram-figure": "./components/pictogram-figure.tsx",
     "./components/presentation-footer": "./components/presentation-footer.tsx",
     "./components/presentation-header": "./components/presentation-header.tsx",
@@ -271,7 +273,10 @@
     "./lib/newsroom-sections": "./lib/newsroom-sections.ts",
     "./lib/newsroom-topics": "./lib/newsroom-topics.ts",
     "./lib/oauth-redirect-priority": "./lib/oauth-redirect-priority.ts",
+    "./lib/papyrus-chat-admission": "./lib/papyrus-chat-admission.ts",
+    "./lib/papyrus-hosted-chat": "./lib/papyrus-hosted-chat.ts",
     "./lib/papyrus-object-kinds": "./lib/papyrus-object-kinds.ts",
+    "./lib/papyrus-private-chat-client": "./lib/papyrus-private-chat-client.ts",
     "./lib/papyrus-web-locations": "./lib/papyrus-web-locations.ts",
     "./lib/pilobol-sample": "./lib/pilobol-sample.ts",
     "./lib/plugin-settings": "./lib/plugin-settings.ts",
@@ -315,11 +320,13 @@
     "./lib/robots-policy": "./lib/robots-policy.ts",
     "./lib/root-route-redirect": "./lib/root-route-redirect.ts",
     "./lib/semantic-graph": "./lib/semantic-graph.ts",
+    "./lib/shared-chat-admission": "./lib/shared-chat-admission.ts",
     "./lib/shared-credentials-provider": "./lib/shared-credentials-provider.ts",
     "./lib/signup-csv": "./lib/signup-csv.ts",
     "./lib/site-brand-tenant": "./lib/site-brand-tenant.ts",
     "./lib/site-brand": "./lib/site-brand.ts",
     "./lib/site-env": "./lib/site-env.ts",
+    "./lib/site-origin-value": "./lib/site-origin-value.ts",
     "./lib/site-origin": "./lib/site-origin.ts",
     "./lib/site-renderer": "./lib/site-renderer.ts",
     "./lib/site-section-suggestions": "./lib/site-section-suggestions.ts",
@@ -369,6 +376,7 @@
     "./app/api/newsletter/state/route": "./app/api/newsletter/state/route.ts",
     "./app/api/newsletter/subscribe/route": "./app/api/newsletter/subscribe/route.ts",
     "./app/api/newsletter/unsubscribe/route": "./app/api/newsletter/unsubscribe/route.ts",
+    "./app/api/newsroom/chat/[...path]/route": "./app/api/newsroom/chat/[...path]/route.ts",
     "./app/api/newsroom/curation/context/route": "./app/api/newsroom/curation/context/route.ts",
     "./app/api/newsroom/curation/priming/route": "./app/api/newsroom/curation/priming/route.ts",
     "./app/api/newsroom/curation/publication/route": "./app/api/newsroom/curation/publication/route.ts",
@@ -448,7 +456,7 @@
       "optional": true
     }
   },
-  "version": "5.39.0",
+  "version": "5.41.0",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",
@@ -485,6 +493,7 @@
     "anthus-vultus": "github:AnthusAI/Vultus#af98d57",
     "aws-amplify": "^6.17.0",
     "aws-jwt-verify": "4.0.1",
+    "chatticus": "https://github.com/AnthusAI/Chatticus/archive/db862e386119f97922cf303fd00ef0505d86a08a.tar.gz",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.39.0",
+  "version": "5.41.0",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",
@@ -229,6 +229,18 @@
         "runtime": "\"nodejs\""
       }
     },
+    {
+      "file": "app/api/newsroom/chat/[...path]/route.ts",
+      "hasDefault": false,
+      "exports": [
+        "GET",
+        "POST"
+      ],
+      "config": {
+        "dynamic": "\"force-dynamic\"",
+        "runtime": "\"nodejs\""
+      }
+    },
     {
       "file": "app/api/newsroom/curation/context/route.ts",
       "hasDefault": false,

package/src/with-papyrus.mjs

@@ -50,7 +50,7 @@ export function staticGenerationSettings() {
   };
 }
 
-export const DEFAULT_TRANSPILE_PACKAGES = ["@anthusai/papyrus", "cyclotron"];
+export const DEFAULT_TRANSPILE_PACKAGES = ["@anthusai/papyrus", "cyclotron", "chatticus"];
 
 export function mergeTranspilePackages(existing = []) {
   return [...new Set([...existing, ...DEFAULT_TRANSPILE_PACKAGES])];