@anthusai/papyrus 5.43.0-next.4 → 5.43.0-next.41

package/components/ui/auto-grow-textarea.tsx

@@ -0,0 +1,18 @@
+"use client";
+
+import { useLayoutEffect, useRef, type TextareaHTMLAttributes } from "react";
+
+/**
+ * A textarea as tall as its text. It never scrolls inside itself, so on a phone a swipe over it scrolls the page instead of
+ * getting caught in the box. (CSS `field-sizing: content` does the same where supported; the height is set here for the rest.)
+ */
+export function AutoGrowTextarea({ className, style, value, ...props }: TextareaHTMLAttributes<HTMLTextAreaElement>) {
+  const ref = useRef<HTMLTextAreaElement>(null);
+  useLayoutEffect(() => {
+    const element = ref.current;
+    if (!element) return;
+    element.style.height = "auto";
+    element.style.height = `${element.scrollHeight}px`;
+  }, [value]);
+  return <textarea {...props} className={className} ref={ref} rows={props.rows ?? 2} style={{ ...style, overflow: "hidden", resize: "none" }} value={value} />;
+}

package/components/use-conversation.ts

@@ -0,0 +1,84 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { ConversationAnchor, ConversationMessage } from "../lib/conversation";
+import { useConversationStore } from "./conversation-context";
+
+export type ConversationState = "loading" | "ready" | "error";
+
+/**
+ * One conversation's Messages. Posting shows the Message at once (marked pending) and swaps in the saved one; a failed save removes
+ * it again and rejects, so the caller can give the typed text back.
+ */
+export function useConversation(anchor: ConversationAnchor) {
+  const store = useConversationStore();
+  const [messages, setMessages] = useState<ConversationMessage[]>([]);
+  const [state, setState] = useState<ConversationState>("loading");
+  const [error, setError] = useState<string | null>(null);
+  const [attempt, setAttempt] = useState(0);
+  const pendingCount = useRef(0);
+  const anchorRef = useRef(anchor);
+  anchorRef.current = anchor;
+  const anchorKey = `${anchor.kind}#${anchor.lineageId ?? ""}`;
+
+  useEffect(() => {
+    if (!store) return;
+    let active = true;
+    setState("loading");
+    setError(null);
+    setMessages([]);
+    store.load(anchorRef.current).then((loaded) => {
+      if (!active) return;
+      setMessages((current) => [...loaded, ...current.filter((message) => message.pending)]);
+      setState("ready");
+    }).catch((failure) => {
+      if (!active) return;
+      setError(failure instanceof Error ? failure.message : "The conversation could not be loaded.");
+      setState("error");
+    });
+    return () => { active = false; };
+  }, [store, anchorKey, attempt]);
+
+  const retry = useCallback(() => setAttempt((current) => current + 1), []);
+
+  const post = useCallback(async (body: string, parentMessageId: string | null) => {
+    if (!store) throw new Error("Messages are not available here.");
+    pendingCount.current += 1;
+    const pendingId = `pending-${pendingCount.current}`;
+    const pending: ConversationMessage = {
+      id: pendingId,
+      parentMessageId,
+      authorLabel: store.authorLabel,
+      content: body.trim(),
+      createdAt: new Date().toISOString(),
+      sequenceNumber: Number.MAX_SAFE_INTEGER - 1000 + pendingCount.current,
+      pending: true,
+    };
+    setMessages((current) => [...current, pending]);
+    try {
+      const saved = await store.append({ anchor: anchorRef.current, body, parentMessageId });
+      setMessages((current) => current.map((message) => (message.id === pendingId ? saved : message)));
+    } catch (failure) {
+      setMessages((current) => current.filter((message) => message.id !== pendingId));
+      throw failure instanceof Error ? failure : new Error("Your message could not be saved.");
+    }
+  }, [store]);
+
+  return { available: Boolean(store), messages, state, error, retry, post };
+}
+
+/** Message counts per Reference lineage, for the feed cards. A failed read just shows no counts. */
+export function useReferenceMessageCounts(enabled: boolean) {
+  const store = useConversationStore();
+  const [counts, setCounts] = useState<ReadonlyMap<string, number>>(() => new Map());
+  useEffect(() => {
+    if (!store || !enabled) return;
+    let active = true;
+    store.counts().then((loaded) => { if (active) setCounts((current) => new Map([...loaded, ...current])); }).catch(() => undefined);
+    return () => { active = false; };
+  }, [store, enabled]);
+  const setCount = useCallback((lineageId: string, count: number) => {
+    setCounts((current) => (current.get(lineageId) === count || (count === 0 && !current.has(lineageId)) ? current : new Map(current).set(lineageId, count)));
+  }, []);
+  return { counts, setCount };
+}

package/components/use-media-query.ts

@@ -0,0 +1,16 @@
+"use client";
+
+import { useEffect, useState } from "react";
+
+/** True while the media query matches. False on the server and before the first effect, so the first paint is the wide layout. */
+export function useMediaQuery(query: string): boolean {
+  const [matches, setMatches] = useState(false);
+  useEffect(() => {
+    const mediaQuery = window.matchMedia(query);
+    const update = () => setMatches(mediaQuery.matches);
+    update();
+    mediaQuery.addEventListener("change", update);
+    return () => mediaQuery.removeEventListener("change", update);
+  }, [query]);
+  return matches;
+}

package/components/use-reference-preview-attachments.ts

@@ -0,0 +1,101 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import type { ReferenceAttachmentRecord, ReferenceRecord } from "../lib/category-repository";
+import { referenceLineageId } from "../lib/newsroom-references";
+import { loadReferenceAttachmentsForLineageId, loadStoragePathUrl } from "./news-desk-taxonomy-client";
+
+function normalizeReferenceDetailHttpUri(value: string | null | undefined): string | null {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  return null;
+}
+
+/** The attachments of one Reference (seeded, else read), with stored files turned into links. Shared by the References detail pane and the Needs me detail pane. */
+export function useReferencePreviewAttachments(
+  reference: ReferenceRecord | null,
+  referenceAttachments: ReferenceAttachmentRecord[],
+) {
+  const lineageId = reference ? referenceLineageId(reference) : "";
+  const seededAttachments = useMemo(
+    () => referenceAttachments.filter((attachment) => attachment.referenceLineageId === lineageId),
+    [lineageId, referenceAttachments],
+  );
+  const [attachments, setAttachments] = useState<ReferenceAttachmentRecord[]>(seededAttachments);
+  const [attachmentLinksById, setAttachmentLinksById] = useState<Record<string, string>>({});
+
+  useEffect(() => {
+    setAttachments(seededAttachments);
+  }, [seededAttachments]);
+
+  useEffect(() => {
+    if (!lineageId) return;
+    if (seededAttachments.length > 0) return;
+    let active = true;
+    void loadReferenceAttachmentsForLineageId(lineageId)
+      .then((loaded) => {
+        if (!active || !loaded.length) return;
+        setAttachments(loaded);
+      })
+      .catch(() => undefined);
+    return () => {
+      active = false;
+    };
+  }, [lineageId, seededAttachments.length]);
+
+  useEffect(() => {
+    if (!attachments.length) {
+      setAttachmentLinksById({});
+      return;
+    }
+    let active = true;
+    const staticLinks = new Map<string, string>();
+    const storageLookups: Array<{ id: string; storagePath: string }> = [];
+
+    for (const attachment of attachments) {
+      if (attachment.storagePath) {
+        storageLookups.push({ id: attachment.id, storagePath: attachment.storagePath });
+        continue;
+      }
+      const sourceHref = normalizeReferenceDetailHttpUri(attachment.sourceUri);
+      if (sourceHref) staticLinks.set(attachment.id, sourceHref);
+    }
+
+    if (!storageLookups.length) {
+      setAttachmentLinksById(Object.fromEntries(staticLinks.entries()));
+      return () => {
+        active = false;
+      };
+    }
+
+    setAttachmentLinksById(Object.fromEntries(staticLinks.entries()));
+    void Promise.all(storageLookups.map(async (lookup) => {
+      const result = await loadStoragePathUrl(lookup.storagePath);
+      return { id: lookup.id, url: result.url };
+    }))
+      .then((resolved) => {
+        if (!active) return;
+        const nextLinks = Object.fromEntries(staticLinks.entries());
+        for (const entry of resolved) {
+          if (entry.url) nextLinks[entry.id] = entry.url;
+        }
+        setAttachmentLinksById(nextLinks);
+      })
+      .catch(() => undefined);
+
+    return () => {
+      active = false;
+    };
+  }, [attachments]);
+
+  const previewAttachments = useMemo(
+    () => attachments.map((attachment) => ({
+      ...attachment,
+      sourceUri: attachmentLinksById[attachment.id] ?? attachment.sourceUri,
+    })),
+    [attachmentLinksById, attachments],
+  );
+
+  return previewAttachments;
+}

package/components/use-reference-ratings.ts

@@ -0,0 +1,189 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { ReferenceRejectionReasonCode } from "../lib/reference-policy";
+import type { ReviewChoice } from "./reference-review-card";
+import type { RatingFeedback } from "./decision-control";
+
+/** How long after the last keystroke a typed reason is saved on its own. */
+export const NOTE_AUTOSAVE_MS = 1200;
+
+export type ItemRating = {
+  /** The reason as typed, else as saved. In the store itself it stays undefined until touched, so an untouched field follows the record. */
+  note?: string;
+  reasonCode?: ReferenceRejectionReasonCode | null;
+  /** A vote that is waiting for a reason (Reject needs one) or is still saving. */
+  pending: ReviewChoice | null;
+  /** True while a Reject is waiting for its reason. */
+  askReason: boolean;
+  feedback: RatingFeedback;
+};
+
+const EMPTY: ItemRating = { pending: null, askReason: false, feedback: { phase: "idle" } };
+
+export type RatingSave = (id: string, choice: ReviewChoice, detail: { note: string; reasonCode: ReferenceRejectionReasonCode | null }) => Promise<void> | void;
+
+export type RatingController = {
+  get: (id: string) => ItemRating;
+  choose: (id: string, choice: ReviewChoice) => void;
+  setReason: (id: string, code: ReferenceRejectionReasonCode) => void;
+  setNote: (id: string, text: string) => void;
+  /** Save a typed reason now (on blur). */
+  commitNote: (id: string) => void;
+  cancelReason: (id: string) => void;
+};
+
+/**
+ * One store for the rating state of every item, shared by the grid card and the detail pane so a vote or a reason typed in either
+ * shows in both at once. `saved(id)` is the saved human answer; `seed(id)` the saved note and reason code.
+ *   vote, then reason  -> the reason is saved onto the existing decision (on blur, or after a short pause)
+ *   reason, then vote  -> the vote carries the reason
+ * A Reject needs a reason (the backend refuses one without): words or a reason code, whichever the surface asks for. With neither it
+ * waits as `pending` until one arrives; a typed reason is kept in the store until it is saved and is never dropped by a failed save.
+ */
+export function useRatingStore({ save, saved, seed, needsReason, sticky, saveNote }: {
+  save: RatingSave;
+  saved: (id: string) => ReviewChoice | null;
+  seed: (id: string) => { note: string; reasonCode: ReferenceRejectionReasonCode | null };
+  /** Whether a Reject on this item must wait for a reason code. Default yes (a Reference); an AI draft or an email asks nothing. */
+  needsReason?: (id: string) => boolean;
+  /**
+   * True for an item whose decision, once made, cannot be sent again (an AI draft moves its Proposal, a review request closes, a held email is
+   * queued). A reason typed after such a decision goes to `saveNote` instead, onto the decision that exists.
+   */
+  sticky?: (id: string) => boolean;
+  /** Saves the reason of an item that is already decided and sticky. Throws a sentence when it cannot. */
+  saveNote?: (id: string, note: string) => Promise<void>;
+}): RatingController {
+  const [items, setItems] = useState<Record<string, ItemRating>>({});
+  const itemsRef = useRef(items);
+  const latest = useRef({ save, saved, seed, needsReason, sticky, saveNote });
+  latest.current = { save, saved, seed, needsReason, sticky, saveNote };
+  const timers = useRef<Record<string, ReturnType<typeof setTimeout>>>({});
+  const inFlight = useRef<Set<string>>(new Set());
+  const dirty = useRef<Set<string>>(new Set());
+  const decidedHere = useRef<Set<string>>(new Set());
+  const noteInFlight = useRef<Set<string>>(new Set());
+
+  const patch = useCallback((id: string, change: Partial<ItemRating>) => {
+    const next = { ...itemsRef.current, [id]: { ...(itemsRef.current[id] ?? EMPTY), ...change } };
+    itemsRef.current = next;
+    setItems(next);
+  }, []);
+
+  // What a reader of the store sees: the touched value, else what is saved. (A saved reason therefore shows on the card too.)
+  const get = useCallback((id: string): ItemRating => {
+    const item = items[id] ?? EMPTY;
+    const seeded = latest.current.seed(id);
+    return { ...item, note: item.note ?? seeded.note, reasonCode: item.reasonCode !== undefined ? item.reasonCode : seeded.reasonCode };
+  }, [items]);
+
+  const values = (id: string) => {
+    const item = itemsRef.current[id] ?? EMPTY;
+    const seeded = latest.current.seed(id);
+    return { note: item.note ?? seeded.note, reasonCode: item.reasonCode !== undefined ? item.reasonCode : seeded.reasonCode };
+  };
+
+  /** True once a sticky item has its decision: from then on only its reason can change. */
+  const finalDecision = (id: string) => Boolean(latest.current.sticky?.(id) && latest.current.saveNote && (decidedHere.current.has(id) || latest.current.saved(id)));
+
+  /** A reason typed after the decision: saved onto it. The text stays in the store until it is saved, and a failed save never drops it. */
+  const saveNoteOnly = useCallback(async (id: string): Promise<void> => {
+    if (noteInFlight.current.has(id)) { dirty.current.add(`note:${id}`); return; }
+    noteInFlight.current.add(id);
+    dirty.current.delete(`note:${id}`);
+    const started = itemsRef.current[id]?.note;
+    const { note } = values(id);
+    patch(id, { feedback: { phase: "saving" } });
+    try {
+      await latest.current.saveNote!(id, note.trim());
+      const now = itemsRef.current[id];
+      patch(id, { feedback: { phase: "saved" }, ...(now?.note === started ? { note: undefined } : {}) });
+    } catch (failure) {
+      dirty.current.add(`note:${id}`); // still unsaved: tapping away, or the next pause, tries again
+      patch(id, { feedback: { phase: "error", message: failure instanceof Error ? failure.message : "Your note could not be saved. It is kept here; keep typing or tap away to try again." } });
+    } finally {
+      noteInFlight.current.delete(id);
+    }
+    if (itemsRef.current[id]?.feedback.phase !== "error" && dirty.current.delete(`note:${id}`)) void saveNoteOnly(id);
+  }, [patch]);
+
+  const commit = useCallback(async (id: string, choice: ReviewChoice) => {
+    if (finalDecision(id)) { void saveNoteOnly(id); return; }
+    const { note, reasonCode } = values(id);
+    // A typed reason is a reason, so a Reject with words goes at once rather than waiting. It carries no
+    // code the editor did not pick: the backend reads the words for the code they name, and files words
+    // that name none under "other". Only a Reject with neither words nor a code waits for one.
+    if (choice === "reject" && !reasonCode && !note.trim() && (latest.current.needsReason?.(id) ?? true)) { patch(id, { pending: "reject", askReason: true }); return; }
+    if (inFlight.current.has(id)) { dirty.current.add(id); return; }
+    inFlight.current.add(id);
+    dirty.current.delete(id);
+    const started = itemsRef.current[id] ?? EMPTY;
+    patch(id, { pending: choice, askReason: false, feedback: { phase: "saving" } });
+    try {
+      await latest.current.save(id, choice, { note: note.trim(), reasonCode: choice === "reject" ? reasonCode : null });
+      if (latest.current.sticky?.(id)) decidedHere.current.add(id);
+      // What was saved now follows the record again (another editor's update shows); anything typed meanwhile is kept. While another
+      // save is due (changed mid-save), the store keeps everything: the record may not show this save yet, and the next one sends it.
+      const now = itemsRef.current[id] ?? EMPTY;
+      const follow = !dirty.current.has(id);
+      patch(id, { pending: null, feedback: { phase: "saved" }, ...(follow && now.note === started.note ? { note: undefined } : {}), ...(follow && now.reasonCode === started.reasonCode ? { reasonCode: undefined } : {}) });
+    } catch (failure) {
+      // The typed reason stays in the store; only the vote is undone.
+      patch(id, { pending: null, feedback: { phase: "error", message: failure instanceof Error ? failure.message : "Your answer could not be saved. Tap it again to retry." } });
+    } finally {
+      inFlight.current.delete(id);
+    }
+    // Changed while saving (a reason chip tapped mid-save): save again. The record may not show the vote yet, so fall back to it.
+    if (dirty.current.has(id)) { dirty.current.delete(id); const again = itemsRef.current[id]?.pending ?? latest.current.saved(id) ?? choice; if (again) void commit(id, again); }
+  }, [patch, saveNoteOnly]);
+
+  const effective = (id: string): ReviewChoice | null => itemsRef.current[id]?.pending ?? latest.current.saved(id);
+
+  const choose = useCallback((id: string, choice: ReviewChoice) => {
+    if (finalDecision(id)) return; // a decision that cannot be sent again is only ever given a reason, never a second vote
+    if (effective(id) === choice && !itemsRef.current[id]?.askReason) return; // the chosen answer never unselects itself
+    void commit(id, choice);
+  }, [commit]);
+
+  const setReason = useCallback((id: string, code: ReferenceRejectionReasonCode) => {
+    patch(id, { reasonCode: code });
+    // Vote then reason: onto the existing (or waiting) decision. Reason then vote: stored, and the vote carries it.
+    if (effective(id) === "reject") void commit(id, "reject");
+  }, [commit, patch]);
+
+  const setNote = useCallback((id: string, text: string) => {
+    patch(id, { note: text, feedback: { phase: "idle" } });
+    dirty.current.add(`note:${id}`);
+    clearTimeout(timers.current[id]);
+    timers.current[id] = setTimeout(() => {
+      const choice = effective(id);
+      if (choice && dirty.current.delete(`note:${id}`)) void commit(id, choice);
+    }, NOTE_AUTOSAVE_MS);
+  }, [commit, patch]);
+
+  const commitNote = useCallback((id: string) => {
+    clearTimeout(timers.current[id]);
+    const choice = effective(id);
+    if (choice && dirty.current.delete(`note:${id}`)) void commit(id, choice);
+  }, [commit]);
+
+  const cancelReason = useCallback((id: string) => patch(id, { pending: null, askReason: false }), [patch]);
+
+  // Leaving the page (or closing the view) saves what was typed and not yet saved, rather than dropping it.
+  const leaving = useRef<() => void>(() => undefined);
+  leaving.current = () => {
+    for (const key of [...dirty.current]) {
+      if (!key.startsWith("note:")) continue;
+      const id = key.slice(5);
+      const choice = effective(id);
+      if (choice && dirty.current.delete(key)) void commit(id, choice);
+    }
+  };
+  useEffect(() => () => {
+    for (const timer of Object.values(timers.current)) clearTimeout(timer);
+    leaving.current();
+  }, []);
+
+  return { get, choose, setReason, setNote, commitNote, cancelReason };
+}

package/infra/amplify-app-shell.js

@@ -6,10 +6,26 @@ import { addCloudEmail } from "./cloud-email.js";
 import { parseCloudEmail } from "./cloud-email-config.js";
 import { GITHUB_OIDC_PROVIDER_HOST } from "./github-oidc-provider.js";
 import { cmsProductionBuildSpec, cmsStagingBuildSpec, readerBuildSpec } from "./build-specs.js";
-import { PROSPECTUS_PAPYRUS_SITE_ROUTES, hasCmsApp, isStagingEnabled, resolveRedirectSubDomainPrefix, resolveCmsHostName, resolveSiteOrigin, githubOidcSubjects, resolveGithubRepository, resolveProspectusAccountsEndpoint, resolveProspectusSessionSealingParameterName, resolveReaderPollSecretParameterName, resolveRevalidateSecretParameterName, resolveStackName, resolveStagingDomainName, resolveStoragePreviewPrefix } from "./site-config.js";
+import { PROSPECTUS_PAPYRUS_SITE_ROUTES, hasCmsApp, isStagingEnabled, resolveRedirectSubDomainPrefix, resolveCmsHostName, resolveSiteOrigin, githubOidcSubjects, resolveGithubRepository, resolveProspectusAccountsEndpoint, resolveProspectusSessionSealingParameterName, resolveReaderPollSecretParameterName, resolveRevalidateSecretParameterName, resolveStackName, resolveStagingDomainName, resolveChatStackName, chatExportName, CHAT_EXPORTED_RESOURCES, CHAT_ENVIRONMENT_NAMES, CHAT_PRIVATE_ASSISTANT_ID, CHAT_PRIVATE_ASSISTANT_NAME, resolveStoragePreviewPrefix } from "./site-config.js";
 function environmentVariables(variables) {
     return Object.entries(variables).map(([name, value]) => ({ name, value }));
 }
+/**
+ * The production branch's private chat environment. Only a site with an enabled `chat` block gets the flag and the
+ * resource names (imported from the chat data stack's exports, so that stack must be deployed first); every other
+ * site keeps the flag "false" and no chat variables, and its newsroom serves neither the chat route nor the UI.
+ */
+function chatEnvironment(config) {
+    const chatStackName = resolveChatStackName(config);
+    if (!chatStackName)
+        return { PAPYRUS_PRIVATE_CHAT_ENABLED: "false" };
+    return {
+        PAPYRUS_PRIVATE_CHAT_ENABLED: "true",
+        ...Object.fromEntries(CHAT_EXPORTED_RESOURCES.map((resource) => [CHAT_ENVIRONMENT_NAMES[resource], Fn.importValue(chatExportName(chatStackName, resource))])),
+        PAPYRUS_CHAT_PRIVATE_BOT_ID: CHAT_PRIVATE_ASSISTANT_ID,
+        PAPYRUS_CHAT_PRIVATE_BOT_NAME: CHAT_PRIVATE_ASSISTANT_NAME,
+    };
+}
 function readerCustomHeaders(rules) {
     if (!rules)
         return undefined;
@@ -199,7 +215,7 @@ export class AmplifyAppShellStack extends Stack {
             environmentVariables: environmentVariables({
                 ...config.cms.environment,
                 ...emailEnvironment,
-                PAPYRUS_PRIVATE_CHAT_ENABLED: config.cms.environment.PAPYRUS_PRIVATE_CHAT_ENABLED ?? "false",
+                ...(config.chat?.enabled ? chatEnvironment(config) : { PAPYRUS_PRIVATE_CHAT_ENABLED: config.cms.environment.PAPYRUS_PRIVATE_CHAT_ENABLED ?? "false" }),
                 PAPYRUS_COGNITO_DOMAIN_PREFIX: config.cms.cognitoDomainPrefix,
                 ...(config.cms.applyCognitoDomainPrefix ? { PAPYRUS_APPLY_COGNITO_DOMAIN_PREFIX: "true" } : {}),
                 PAPYRUS_OAUTH_REDIRECT_URLS: oauthRedirectUrls,

package/infra/amplify-app-shell.ts

@@ -7,12 +7,28 @@ import { addCloudEmail } from "./cloud-email";
 import { parseCloudEmail } from "./cloud-email-config";
 import { GITHUB_OIDC_PROVIDER_HOST } from "./github-oidc-provider";
 import { cmsProductionBuildSpec, cmsStagingBuildSpec, readerBuildSpec } from "./build-specs";
-import { AmplifyAppShellSiteConfig, PROSPECTUS_PAPYRUS_SITE_ROUTES, ReaderCustomHeaderRule, hasCmsApp, isStagingEnabled, resolveRedirectSubDomainPrefix, resolveCmsHostName, resolveSiteOrigin, githubOidcSubjects, resolveGithubRepository, resolveProspectusAccountsEndpoint, resolveProspectusSessionSealingParameterName, resolveReaderPollSecretParameterName, resolveRevalidateSecretParameterName, resolveStackName, resolveStagingDomainName, resolveStoragePreviewPrefix } from "./site-config";
+import { AmplifyAppShellSiteConfig, PROSPECTUS_PAPYRUS_SITE_ROUTES, ReaderCustomHeaderRule, hasCmsApp, isStagingEnabled, resolveRedirectSubDomainPrefix, resolveCmsHostName, resolveSiteOrigin, githubOidcSubjects, resolveGithubRepository, resolveProspectusAccountsEndpoint, resolveProspectusSessionSealingParameterName, resolveReaderPollSecretParameterName, resolveRevalidateSecretParameterName, resolveStackName, resolveStagingDomainName, resolveChatStackName, chatExportName, CHAT_EXPORTED_RESOURCES, CHAT_ENVIRONMENT_NAMES, CHAT_PRIVATE_ASSISTANT_ID, CHAT_PRIVATE_ASSISTANT_NAME, resolveStoragePreviewPrefix } from "./site-config";
 
 function environmentVariables(variables: Record<string, string>): amplify.CfnBranch.EnvironmentVariableProperty[] {
   return Object.entries(variables).map(([name, value]) => ({ name, value }));
 }
 
+/**
+ * The production branch's private chat environment. Only a site with an enabled `chat` block gets the flag and the
+ * resource names (imported from the chat data stack's exports, so that stack must be deployed first); every other
+ * site keeps the flag "false" and no chat variables, and its newsroom serves neither the chat route nor the UI.
+ */
+function chatEnvironment(config: AmplifyAppShellSiteConfig): Record<string, string> {
+  const chatStackName = resolveChatStackName(config);
+  if (!chatStackName) return { PAPYRUS_PRIVATE_CHAT_ENABLED: "false" };
+  return {
+    PAPYRUS_PRIVATE_CHAT_ENABLED: "true",
+    ...Object.fromEntries(CHAT_EXPORTED_RESOURCES.map((resource) => [CHAT_ENVIRONMENT_NAMES[resource], Fn.importValue(chatExportName(chatStackName, resource))])),
+    PAPYRUS_CHAT_PRIVATE_BOT_ID: CHAT_PRIVATE_ASSISTANT_ID,
+    PAPYRUS_CHAT_PRIVATE_BOT_NAME: CHAT_PRIVATE_ASSISTANT_NAME,
+  };
+}
+
 function readerCustomHeaders(rules: ReaderCustomHeaderRule[] | undefined): string | undefined {
   if (!rules) return undefined;
   const lines = ["customHeaders:"];
@@ -221,7 +237,7 @@ export class AmplifyAppShellStack extends Stack {
       environmentVariables: environmentVariables({
         ...config.cms.environment,
         ...emailEnvironment,
-        PAPYRUS_PRIVATE_CHAT_ENABLED: config.cms.environment.PAPYRUS_PRIVATE_CHAT_ENABLED ?? "false",
+        ...(config.chat?.enabled ? chatEnvironment(config) : { PAPYRUS_PRIVATE_CHAT_ENABLED: config.cms.environment.PAPYRUS_PRIVATE_CHAT_ENABLED ?? "false" }),
         PAPYRUS_COGNITO_DOMAIN_PREFIX: config.cms.cognitoDomainPrefix,
         ...(config.cms.applyCognitoDomainPrefix ? { PAPYRUS_APPLY_COGNITO_DOMAIN_PREFIX: "true" } : {}),
         PAPYRUS_OAUTH_REDIRECT_URLS: oauthRedirectUrls,