@anthusai/papyrus 0.0.0 → 1.0.0-next.1

package/lib/console-web-context.ts

@@ -0,0 +1,118 @@
+import type { PapyrusWebUiContext } from "./papyrus-web-locations";
+
+export const CONSOLE_WEB_CONTEXT_MESSAGE_KIND = "console_web_context";
+
+export type ConsoleWebContextEvent = "session_start" | "navigation";
+
+export type FormattedConsoleWebContext = {
+  visibleContent: string;
+  summary: string;
+  agentInstructions: string;
+};
+
+export function webUiContextKey(webUi: PapyrusWebUiContext): string {
+  return [
+    webUi.papyrusLocationUri,
+    webUi.webPath,
+    webUi.papyrusObjectUri ?? "",
+    webUi.viewMode ?? "",
+  ].join("|");
+}
+
+export function formatConsoleWebContextMessage(
+  webUi: PapyrusWebUiContext,
+  event: ConsoleWebContextEvent,
+): FormattedConsoleWebContext {
+  const locationUri = webUi.papyrusLocationUri.trim();
+  const webPath = webUi.webPath.trim();
+  const objectUri = webUi.papyrusObjectUri?.trim() ?? "";
+  const label = webUi.label?.trim() ?? "";
+  const tab = webUi.newsroomTab?.trim() ?? "";
+  const viewMode = webUi.viewMode?.trim() ?? "";
+
+  const headline = event === "session_start"
+    ? "Console session started on this page."
+    : "You navigated to a new page in the newsroom.";
+
+  const visibleLines = [
+    headline,
+    "",
+    locationUri ? `Papyrus location: ${locationUri}` : null,
+    webPath ? `Web path: ${webPath}` : null,
+    objectUri ? `Focused object: ${objectUri}` : null,
+    label ? `Label: ${label}` : null,
+    tab ? `Desk: ${tab}` : null,
+    viewMode ? `View: ${viewMode}` : null,
+  ].filter((line): line is string => Boolean(line));
+
+  const agentLines = [
+    "Papyrus web UI context for this console thread:",
+    locationUri ? `- papyrus_location_uri: ${locationUri}` : null,
+    webPath ? `- web_path: ${webPath}` : null,
+    objectUri ? `- focused_object_uri: ${objectUri}` : null,
+    label ? `- label: ${label}` : null,
+    viewMode ? `- view_mode: ${viewMode}` : null,
+    tab ? `- newsroom_tab: ${tab}` : null,
+    "",
+    "Use execute_tactus with papyrus.web.current_location{} to re-read this snapshot.",
+    "Use papyrus.web.navigate{ uri = \"papyrus://...\" } to move the browser when appropriate.",
+  ].filter((line): line is string => line !== null);
+
+  if (objectUri.startsWith("papyrus://reference/")) {
+    const referenceId = objectUri.slice("papyrus://reference/".length).trim();
+    if (referenceId) {
+      agentLines.push(
+        "",
+        `The user is viewing reference detail (${referenceId}). For questions about "this reference", the open page, or what they are looking at, do not ask them to paste the reference.`,
+        `First call execute_tactus with: return papyrus.Reference.get{ id = "${referenceId}" } (lineage ids from the URL resolve to the current version).`,
+        `Then call: return papyrus.knowledge.query{ semanticQuery = "Summarize the main claims, methods, and results.", anchors = { { uri = "papyrus://reference/${referenceId}" } } }`,
+        "Use double-quoted Lua strings only. Do not use JS parentheses, string.match, or multi-line Lua beyond simple return statements.",
+      );
+    }
+  }
+
+  const summaryParts = [label, tab, viewMode === "detail" ? "detail" : "index"].filter(Boolean);
+  return {
+    visibleContent: visibleLines.join("\n"),
+    summary: summaryParts.length
+      ? `Page context: ${summaryParts.join(" · ")}`
+      : "Page context updated",
+    agentInstructions: agentLines.join("\n"),
+  };
+}
+
+export function readConsoleAgentInstructionsFromMessageMetadata(metadata: unknown): string | null {
+  if (!metadata || typeof metadata !== "object") return null;
+  const record = metadata as Record<string, unknown>;
+  const consoleMeta = record.console;
+  if (!consoleMeta || typeof consoleMeta !== "object") return null;
+  const instructions = (consoleMeta as Record<string, unknown>).agentInstructions;
+  return typeof instructions === "string" && instructions.trim() ? instructions.trim() : null;
+}
+
+export function readConsoleWebUiFromMessageMetadata(metadata: unknown): PapyrusWebUiContext | null {
+  if (!metadata || typeof metadata !== "object") return null;
+  const record = metadata as Record<string, unknown>;
+  const consoleMeta = record.console;
+  if (!consoleMeta || typeof consoleMeta !== "object") return null;
+  const webUi = (consoleMeta as Record<string, unknown>).webUi;
+  if (!webUi || typeof webUi !== "object") return null;
+  const entry = webUi as Record<string, unknown>;
+  const webPath = typeof entry.webPath === "string" ? entry.webPath : "";
+  const papyrusLocationUri = typeof entry.papyrusLocationUri === "string" ? entry.papyrusLocationUri : "";
+  if (!webPath && !papyrusLocationUri) return null;
+  return {
+    webPath,
+    papyrusLocationUri,
+    papyrusObjectUri: typeof entry.papyrusObjectUri === "string" ? entry.papyrusObjectUri : null,
+    newsroomTab: typeof entry.newsroomTab === "string" ? entry.newsroomTab : null,
+    viewMode: entry.viewMode === "index" || entry.viewMode === "detail" ? entry.viewMode : null,
+    indexFilters: entry.indexFilters && typeof entry.indexFilters === "object"
+      ? Object.fromEntries(
+        Object.entries(entry.indexFilters as Record<string, unknown>)
+          .filter(([, value]) => typeof value === "string" && value.trim()),
+      ) as Record<string, string>
+      : null,
+    label: typeof entry.label === "string" ? entry.label : null,
+  };
+}

package/lib/content-load-timing.ts

@@ -0,0 +1,23 @@
+type ContentLoadMetadata = Record<string, string | number | boolean | null | undefined>;
+
+export function isContentLoadTimingEnabled(): boolean {
+  return process.env.PAPYRUS_CONTENT_LOAD_TIMING === "1";
+}
+
+export async function withContentLoadTiming<T>(
+  label: string,
+  metadata: ContentLoadMetadata,
+  work: () => Promise<T>,
+): Promise<T> {
+  if (!isContentLoadTimingEnabled()) {
+    return work();
+  }
+
+  const started = performance.now();
+  try {
+    return await work();
+  } finally {
+    const elapsedMs = Math.round(performance.now() - started);
+    console.info(`[papyrus-content-load] ${label} ${JSON.stringify({ ...metadata, ms: elapsedMs })}`);
+  }
+}

package/lib/content-repository.ts

@@ -0,0 +1,40 @@
+import type { ContentRepository } from "./content-types";
+import { graphqlContentRepository } from "./graphql-content-repository";
+import { getLayoutScenario } from "./layout-scenarios";
+
+export const contentRepository: ContentRepository = {
+  loadEditionContent({ scenarioId, editionDate, editionSlug } = {}) {
+    if (scenarioId) return getLayoutScenario(scenarioId);
+    return graphqlContentRepository.loadEditionContent({ editionDate, editionSlug });
+  },
+  getLatestPublishedEdition() {
+    return graphqlContentRepository.getLatestPublishedEdition();
+  },
+  getFirstPublishedEdition() {
+    return graphqlContentRepository.getFirstPublishedEdition();
+  },
+  listPublishedEditions(options) {
+    return graphqlContentRepository.listPublishedEditions(options);
+  },
+  getArticle(slug: string) {
+    return graphqlContentRepository.getArticle(slug);
+  },
+  getEditionArticle(options) {
+    return graphqlContentRepository.getEditionArticle(options);
+  },
+  getEditionItem(options) {
+    return graphqlContentRepository.getEditionItem(options);
+  },
+  listArticleSlugs() {
+    return graphqlContentRepository.listArticleSlugs();
+  },
+};
+
+export function getScenarioIdParam(scenario: string | string[] | null | undefined): string | null {
+  if (Array.isArray(scenario)) return scenario[0] ?? null;
+  return scenario ?? null;
+}
+
+export function isGraphQLContentSource(): boolean {
+  return true;
+}

package/lib/content-types.ts

@@ -0,0 +1,104 @@
+import type { Article, ArticleVideoAsset } from "./articles";
+import type { EditionLayoutPlan } from "./layout-plan";
+import type { PublicationItem } from "./publication-items";
+
+export type ContentSource = "scenario" | "graphql";
+
+import type { PretextLayout } from "./renderer-config";
+
+/** @deprecated Use PretextLayout from lib/renderer-config.ts */
+export type EditionPresentationFormat = PretextLayout;
+
+export type EditionSection = {
+  key: string;
+  label: string;
+  description?: string | null;
+  itemIds: string[];
+};
+
+export type NewsDeskCategoryTreeNode = {
+  id: string;
+  categorySetId: string;
+  categoryKey: string;
+  parentCategoryKey?: string | null;
+  displayName: string;
+  shortTitle?: string | null;
+  subtitle?: string | null;
+  description?: string | null;
+  status: string;
+  seedItemIds?: Array<string | null> | null;
+  holdoutItemIds?: Array<string | null> | null;
+  rank?: number | null;
+  depth?: number | null;
+};
+
+export type NewsDeskAppendix = {
+  categorySetId: string;
+  corpusId: string;
+  displayName: string;
+  description?: string | null;
+  generatedAt?: string | null;
+  nodes: NewsDeskCategoryTreeNode[];
+};
+
+export type EditionContent = {
+  id: string;
+  source: ContentSource;
+  title: string;
+  editionDate: string;
+  items: PublicationItem[];
+  sections: EditionSection[];
+  layoutPlan: EditionLayoutPlan;
+  placeholderMode?: "emptyEdition";
+  suppressNewsDeskAppendix?: boolean;
+  newsDeskAppendix?: NewsDeskAppendix | null;
+  scenarioId?: string;
+  description?: string;
+  editionVideo?: ArticleVideoAsset | null;
+};
+
+export type EditionRouteSummary = {
+  id: string;
+  slug: string;
+  title: string;
+  editionDate: string;
+  publishedAt?: string | null;
+  description?: string | null;
+};
+
+export type ListPublishedEditionsOptions = {
+  limit?: number;
+  nextToken?: string | null;
+};
+
+export type PublishedEditionConnection = {
+  editions: EditionRouteSummary[];
+  nextToken?: string | null;
+};
+
+export type LoadEditionContentOptions = {
+  scenarioId?: string | null;
+  editionDate?: string | null;
+  editionSlug?: string | null;
+};
+
+export type GetEditionArticleOptions = {
+  editionDate: string;
+  articleSlug: string;
+};
+
+export type GetEditionItemOptions = {
+  editionDate: string;
+  itemSlug: string;
+};
+
+export type ContentRepository = {
+  loadEditionContent(options?: LoadEditionContentOptions): EditionContent | Promise<EditionContent>;
+  getLatestPublishedEdition(): EditionRouteSummary | null | Promise<EditionRouteSummary | null>;
+  getFirstPublishedEdition(): EditionRouteSummary | null | Promise<EditionRouteSummary | null>;
+  listPublishedEditions(options?: ListPublishedEditionsOptions): PublishedEditionConnection | Promise<PublishedEditionConnection>;
+  getArticle(slug: string): Article | undefined | Promise<Article | undefined>;
+  getEditionArticle(options: GetEditionArticleOptions): Article | undefined | Promise<Article | undefined>;
+  getEditionItem(options: GetEditionItemOptions): PublicationItem | undefined | Promise<PublicationItem | undefined>;
+  listArticleSlugs(): string[] | Promise<string[]>;
+};

package/lib/define-site.js

@@ -0,0 +1,3 @@
+export function defineSite(site) {
+    return site;
+}

package/lib/define-site.ts

@@ -0,0 +1,21 @@
+import type { PapyrusSiteBackendConfig } from "../amplify/site-backend-config";
+import type { SiteBrand } from "./site-brand";
+
+/**
+ * What a publication repo's `papyrus.config.ts` default-exports.
+ * Resolved by the `papyrus-site` alias (tsconfig `paths` in Papyrus itself,
+ * `withPapyrus()` in a publication repo). Also the argument of
+ * `defineSiteBackend(site)` so `ampx` never needs the brand graph.
+ */
+export type PapyrusSite = {
+  /** Brands this publication registers (in addition to Papyrus's built-ins). */
+  brands?: SiteBrand[];
+  /** Brand used when PAPYRUS_SITE_BRAND is unset. */
+  defaultBrand?: string;
+  /** Options for `defineSiteBackend(site)` (Amplify Gen 2 backend). */
+  backend?: PapyrusSiteBackendConfig;
+};
+
+export function defineSite(site: PapyrusSite): PapyrusSite {
+  return site;
+}

package/lib/demo-amplify-outputs.ts

@@ -0,0 +1,15 @@
+import { readAmplifyOutputsFile } from "./amplify-outputs-path";
+
+const DEMO_MARKERS = [
+  "demo-user-pool-client-id-not-a-secret",
+  "da2-demoapikeynotasecret000000",
+  "00000000-demo-4000-8000-000000000000",
+] as const;
+
+/** True when amplify_outputs.json is the offline demo stub (see amplify/fixtures/demo-amplify-outputs.json). */
+export function isDemoAmplifyOutputs(): boolean {
+  const outputs = readAmplifyOutputsFile();
+  if (!outputs) return false;
+  const serialized = JSON.stringify(outputs);
+  return DEMO_MARKERS.some((marker) => serialized.includes(marker));
+}

package/lib/dev-sandbox-editor-auth.ts

@@ -0,0 +1,18 @@
+export type DevSandboxEditorAuth = {
+  username: string;
+  password: string;
+};
+
+const DEFAULT_SEED_USERNAME = "papyrus-seed-editor@example.com";
+const DEFAULT_SEED_PASSWORD = "PapyrusSeed1!";
+
+export function resolveDevSandboxEditorAuth(): DevSandboxEditorAuth | null {
+  if (process.env.NODE_ENV !== "development") return null;
+  if (process.env.PAPYRUS_DEV_SEED_SIGNIN === "0") return null;
+
+  const username = process.env.PAPYRUS_SEED_USERNAME?.trim() || DEFAULT_SEED_USERNAME;
+  const password = process.env.PAPYRUS_SEED_PASSWORD?.trim() || DEFAULT_SEED_PASSWORD;
+  if (!username || !password) return null;
+
+  return { username, password };
+}

package/lib/doctrine.ts

@@ -0,0 +1,128 @@
+export const DOCTRINE_ITEM_TYPE = "doctrine";
+export const DOCTRINE_ITEM_STATUS = "private";
+export const DOCTRINE_ITEM_TYPE_STATUS = "doctrine#private";
+
+export type DoctrineKind = "mission" | "policy";
+export type DoctrineScope = "publication" | "category";
+
+export type DoctrineDefinition = {
+  kind: DoctrineKind;
+  label: string;
+  slug: string;
+  id: string;
+  lineageId: string;
+};
+
+export type DoctrineCategory = {
+  categorySetId: string;
+  categoryKey: string;
+  displayName: string;
+  shortTitle?: string | null;
+  rank?: number | null;
+  depth?: number | null;
+  lineageId?: string | null;
+  id?: string | null;
+};
+
+export const DOCTRINE_DEFINITIONS: DoctrineDefinition[] = [
+  {
+    kind: "mission",
+    label: "Editorial Mission",
+    slug: "editorial-doctrine-mission",
+    id: "item-editorial-doctrine-mission-v1",
+    lineageId: "item-editorial-doctrine-mission",
+  },
+  {
+    kind: "policy",
+    label: "Editorial Policy",
+    slug: "editorial-doctrine-policy",
+    id: "item-editorial-doctrine-policy-v1",
+    lineageId: "item-editorial-doctrine-policy",
+  },
+];
+
+export const DOCTRINE_DEFINITION_BY_KIND = new Map(
+  DOCTRINE_DEFINITIONS.map((definition) => [definition.kind, definition]),
+);
+
+export function buildCategoryDoctrineDefinition(category: DoctrineCategory, kind: DoctrineKind): DoctrineDefinition {
+  const safeCategoryKey = safeDoctrineKey(category.categoryKey);
+  const categoryLineageId = category.lineageId ?? category.id ?? category.categoryKey;
+  const safeCategoryLineageId = safeDoctrineKey(categoryLineageId);
+  const label = kind === "mission" ? "Category Mission" : "Category Policies";
+  return {
+    kind,
+    label,
+    slug: `desk-doctrine-${safeCategoryKey}-${kind}`,
+    id: `item-desk-doctrine-${safeCategoryLineageId}-${kind}-v1`,
+    lineageId: `item-desk-doctrine-${safeCategoryLineageId}-${kind}`,
+  };
+}
+
+export function getCategoryDoctrineDefinitions(category: DoctrineCategory): DoctrineDefinition[] {
+  return [
+    buildCategoryDoctrineDefinition(category, "mission"),
+    buildCategoryDoctrineDefinition(category, "policy"),
+  ];
+}
+
+export function categoryDoctrineEditorialValue(category: DoctrineCategory, kind: DoctrineKind): string {
+  return JSON.stringify({
+    scope: "category",
+    kind,
+    categorySetId: category.categorySetId,
+    categoryLineageId: category.lineageId ?? category.id ?? category.categoryKey,
+    categoryKey: category.categoryKey,
+    categoryDepth: category.depth ?? null,
+  });
+}
+
+export function buildDeskDoctrineDefinition(category: DoctrineCategory, kind: DoctrineKind): DoctrineDefinition {
+  return buildCategoryDoctrineDefinition(category, kind);
+}
+
+export function getDeskDoctrineDefinitions(category: DoctrineCategory): DoctrineDefinition[] {
+  return getCategoryDoctrineDefinitions(category);
+}
+
+export function deskDoctrineEditorialValue(category: DoctrineCategory, kind: DoctrineKind): string {
+  return categoryDoctrineEditorialValue(category, kind);
+}
+
+export function isDeskDoctrineSlug(slug: string | null | undefined): boolean {
+  return typeof slug === "string" && slug.startsWith("desk-doctrine-");
+}
+
+export function doctrineBodyToText(body: Array<string | null> | null | undefined): string {
+  return compactDoctrineParagraphs(body).join("\n\n");
+}
+
+export function doctrineTextToBody(text: string): string[] {
+  return normalizeDoctrineText(text)
+    .split(/\n\s*\n+/)
+    .map((paragraph) => paragraph.trim())
+    .filter(Boolean);
+}
+
+export function doctrineEditorialValue(kind: DoctrineKind): string {
+  return JSON.stringify({ kind });
+}
+
+function safeDoctrineKey(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    || "topic";
+}
+
+function normalizeDoctrineText(text: string): string {
+  return text.replace(/\r\n?/g, "\n").trim();
+}
+
+function compactDoctrineParagraphs(body: Array<string | null> | null | undefined): string[] {
+  return (body ?? [])
+    .map((paragraph) => (typeof paragraph === "string" ? paragraph.trim() : ""))
+    .filter(Boolean);
+}

package/lib/edition-routes.ts

@@ -0,0 +1,155 @@
+const MONTH_NAMES = [
+  "january",
+  "february",
+  "march",
+  "april",
+  "may",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december",
+] as const;
+
+type EditionDateRouteInput = {
+  year: string;
+  month: string;
+  day: string;
+};
+
+type ParsedEditionDateRoute = {
+  editionDate: string;
+  canonicalPath: string;
+  isCanonical: boolean;
+};
+
+type ParsedEditionPageRoute = ParsedEditionDateRoute & {
+  pageNumber: number;
+};
+
+type ParsedEditionArticleRoute = ParsedEditionDateRoute & {
+  articleSlug: string;
+};
+
+type ParsedEditionSectionRoute = ParsedEditionDateRoute & {
+  sectionKey: string;
+};
+
+const RESERVED_DATE_CHILD_SEGMENTS = new Set(["page", "section"]);
+
+export function getEditionDatePath(editionDate: string): string {
+  const match = editionDate.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) return "/";
+
+  const monthIndex = Number(match[2]) - 1;
+  const monthName = MONTH_NAMES[monthIndex];
+  if (!monthName) return "/";
+
+  return `/${match[1]}/${monthName}/${match[3]}`;
+}
+
+export function getEditionPagePath(editionDate: string, pageNumber: number): string {
+  const basePath = getEditionDatePath(editionDate);
+  return pageNumber <= 1 ? basePath : `${basePath}/page/${pageNumber}`;
+}
+
+export function getEditionSectionPath(editionDate: string, sectionKey: string): string {
+  return `${getEditionDatePath(editionDate)}/section/${encodeURIComponent(sectionKey)}`;
+}
+
+export function getEditionArticlePath(editionDate: string, articleSlug: string): string {
+  return `${getEditionDatePath(editionDate)}/${encodeURIComponent(articleSlug)}`;
+}
+
+export const getEditionItemPath = getEditionArticlePath;
+
+export function parseEditionDateRoute(input: EditionDateRouteInput): ParsedEditionDateRoute | null {
+  const parsed = parseEditionDateSegments(input);
+  if (!parsed) return null;
+
+  return {
+    ...parsed,
+    isCanonical: getCurrentDatePath(input) === parsed.canonicalPath,
+  };
+}
+
+export function parseEditionPageRoute(input: EditionDateRouteInput & { pageNumber: string }): ParsedEditionPageRoute | null {
+  const parsed = parseEditionDateSegments(input);
+  if (!parsed) return null;
+  if (!/^\d+$/.test(input.pageNumber)) return null;
+
+  const pageNumber = Number(input.pageNumber);
+  if (!Number.isSafeInteger(pageNumber) || pageNumber < 1) return null;
+
+  const canonicalPath = getEditionPagePath(parsed.editionDate, pageNumber);
+  const currentPath = `${getCurrentDatePath(input)}/page/${input.pageNumber}`;
+  return {
+    editionDate: parsed.editionDate,
+    canonicalPath,
+    isCanonical: currentPath === canonicalPath,
+    pageNumber,
+  };
+}
+
+export function parseEditionArticleRoute(input: EditionDateRouteInput & { articleSlug: string }): ParsedEditionArticleRoute | null {
+  const parsed = parseEditionDateSegments(input);
+  if (!parsed) return null;
+  if (RESERVED_DATE_CHILD_SEGMENTS.has(input.articleSlug.toLowerCase())) return null;
+
+  const canonicalPath = getEditionArticlePath(parsed.editionDate, input.articleSlug);
+  const currentPath = `${getCurrentDatePath(input)}/${input.articleSlug}`;
+  return {
+    editionDate: parsed.editionDate,
+    canonicalPath,
+    isCanonical: currentPath === canonicalPath,
+    articleSlug: input.articleSlug,
+  };
+}
+
+export function parseEditionSectionRoute(input: EditionDateRouteInput & { sectionKey: string }): ParsedEditionSectionRoute | null {
+  const parsed = parseEditionDateSegments(input);
+  if (!parsed) return null;
+  if (!input.sectionKey.trim()) return null;
+
+  const canonicalPath = getEditionSectionPath(parsed.editionDate, input.sectionKey);
+  const currentPath = `${getCurrentDatePath(input)}/section/${input.sectionKey}`;
+  return {
+    editionDate: parsed.editionDate,
+    canonicalPath,
+    isCanonical: currentPath === canonicalPath,
+    sectionKey: input.sectionKey,
+  };
+}
+
+function parseEditionDateSegments(input: EditionDateRouteInput): Omit<ParsedEditionDateRoute, "isCanonical"> | null {
+  if (!/^\d{4}$/.test(input.year)) return null;
+
+  const monthIndex = MONTH_NAMES.indexOf(input.month.toLowerCase() as (typeof MONTH_NAMES)[number]);
+  if (monthIndex < 0) return null;
+
+  if (!/^\d{1,2}$/.test(input.day)) return null;
+  const dayNumber = Number(input.day);
+  if (dayNumber < 1 || dayNumber > 31) return null;
+
+  const monthNumber = monthIndex + 1;
+  const canonicalDay = String(dayNumber).padStart(2, "0");
+  const editionDate = `${input.year}-${String(monthNumber).padStart(2, "0")}-${canonicalDay}`;
+  if (!isValidIsoDate(editionDate)) return null;
+
+  return {
+    editionDate,
+    canonicalPath: getEditionDatePath(editionDate),
+  };
+}
+
+function getCurrentDatePath(input: EditionDateRouteInput): string {
+  return `/${input.year}/${input.month}/${input.day}`;
+}
+
+function isValidIsoDate(editionDate: string): boolean {
+  const [year, month, day] = editionDate.split("-").map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}