@anthusai/papyrus 1.0.0-next.2 → 1.0.0-next.21

package/lib/brand-fonts.ts

@@ -0,0 +1,112 @@
+export type SiteBrandFontFace = {
+  /** Public URL of the font file, e.g. `/fonts/acme-serif-regular.woff2`. */
+  src: string;
+  weight?: number | string;
+  style?: "normal" | "italic";
+};
+
+export type SiteBrandGoogleFontSource = {
+  weights: number[];
+  /** Also load the italic style of every listed weight. */
+  italics?: boolean;
+};
+
+/**
+ * One brand-declared font family. Declare exactly one source: `google` loads
+ * the family from the Google Fonts stylesheet API; `faces` self-hosts files
+ * with `@font-face`. The root layout exposes `cssVariable` as
+ * `"<family>", <fallback>` on `<html>`, so publication CSS writes
+ * `font-family: var(--font-masthead)`.
+ */
+export type SiteBrandFont = {
+  family: string;
+  cssVariable: string;
+  fallback?: string;
+  google?: SiteBrandGoogleFontSource;
+  faces?: SiteBrandFontFace[];
+};
+
+export type BrandFontAssets = {
+  preconnectOrigins: string[];
+  stylesheetHrefs: string[];
+  fontFaceCss: string;
+  rootStyle: Record<string, string>;
+  isEmpty: boolean;
+};
+
+const GOOGLE_STYLESHEET_ORIGIN = "https://fonts.googleapis.com";
+const GOOGLE_FILE_ORIGIN = "https://fonts.gstatic.com";
+const DEFAULT_FALLBACK = "sans-serif";
+const CSS_VARIABLE_PATTERN = /^--[a-z][a-z0-9-]*$/;
+
+export function validateBrandFonts(fonts: SiteBrandFont[]): void {
+  const seenVariables = new Set<string>();
+  for (const font of fonts) {
+    if (!font.family.trim()) throw new Error("A brand font needs a family name.");
+    if (!CSS_VARIABLE_PATTERN.test(font.cssVariable)) {
+      throw new Error(`Brand font "${font.family}" cssVariable must look like --font-name, got "${font.cssVariable}".`);
+    }
+    if (seenVariables.has(font.cssVariable)) {
+      throw new Error(`Brand font cssVariable ${font.cssVariable} is declared twice.`);
+    }
+    seenVariables.add(font.cssVariable);
+    const sourceCount = Number(Boolean(font.google)) + Number(Boolean(font.faces?.length));
+    if (sourceCount !== 1) {
+      throw new Error(`Brand font "${font.family}" must declare exactly one source: google or faces.`);
+    }
+    if (font.google && font.google.weights.length === 0) {
+      throw new Error(`Brand font "${font.family}" google source needs at least one weight.`);
+    }
+  }
+}
+
+function buildGoogleFamilyQuery(font: SiteBrandFont): string {
+  const google = font.google!;
+  const weights = [...new Set(google.weights)].sort((left, right) => left - right);
+  const familyName = font.family.trim().replace(/\s+/g, "+");
+  if (!google.italics) return `family=${familyName}:wght@${weights.join(";")}`;
+  const axisValues = [0, 1].flatMap((italic) => weights.map((weight) => `${italic},${weight}`));
+  return `family=${familyName}:ital,wght@${axisValues.join(";")}`;
+}
+
+export function buildGoogleFontsHref(fonts: SiteBrandFont[]): string | null {
+  const googleFonts = fonts.filter((font) => font.google);
+  if (googleFonts.length === 0) return null;
+  return `${GOOGLE_STYLESHEET_ORIGIN}/css2?${googleFonts.map(buildGoogleFamilyQuery).join("&")}&display=swap`;
+}
+
+function buildFontFaceCss(font: SiteBrandFont): string {
+  return (font.faces ?? [])
+    .map((face) => {
+      const declarations = [
+        `font-family:${JSON.stringify(font.family)}`,
+        `src:url(${JSON.stringify(face.src)})`,
+        `font-weight:${face.weight ?? 400}`,
+        `font-style:${face.style ?? "normal"}`,
+        "font-display:swap",
+      ];
+      return `@font-face{${declarations.join(";")}}`;
+    })
+    .join("");
+}
+
+export function resolveBrandFontAssets(fonts: SiteBrandFont[] | undefined): BrandFontAssets {
+  if (!fonts || fonts.length === 0) {
+    return { preconnectOrigins: [], stylesheetHrefs: [], fontFaceCss: "", rootStyle: {}, isEmpty: true };
+  }
+  validateBrandFonts(fonts);
+  const googleHref = buildGoogleFontsHref(fonts);
+  return {
+    preconnectOrigins: googleHref ? [GOOGLE_STYLESHEET_ORIGIN, GOOGLE_FILE_ORIGIN] : [],
+    stylesheetHrefs: googleHref ? [googleHref] : [],
+    fontFaceCss: fonts.map(buildFontFaceCss).join(""),
+    rootStyle: Object.fromEntries(
+      fonts.map((font) => [font.cssVariable, `${JSON.stringify(font.family)}, ${font.fallback ?? DEFAULT_FALLBACK}`]),
+    ),
+    isEmpty: false,
+  };
+}
+
+export function listBrandFontFamilies(fonts: SiteBrandFont[] | undefined): string[] {
+  return (fonts ?? []).map((font) => font.family);
+}

package/lib/cached-content-repository.ts

@@ -10,6 +10,8 @@ import type {
 } from "./content-types";
 import { graphqlContentRepository } from "./graphql-content-repository";
 import { READER_REVALIDATE_SECONDS } from "./reader-route-config";
+import type { VideoScriptRef } from "./video-script";
+import { getContentSource } from "./site-env";
 
 const bypassReaderCacheInDevelopment = process.env.NODE_ENV === "development";
 
@@ -34,7 +36,7 @@ function withReaderCache<T>(
   tags: string[],
   loader: () => Promise<T>,
 ): Promise<T> {
-  if (bypassReaderCacheInDevelopment) return loader();
+  if (bypassReaderCacheInDevelopment || getContentSource() === "drafts") return loader();
   return unstable_cache(loader, cacheKey, {
     tags,
     revalidate: READER_REVALIDATE_SECONDS,
@@ -87,3 +89,14 @@ export function getCachedLatestPublishedEdition(): Promise<EditionRouteSummary |
     async () => graphqlContentRepository.getLatestPublishedEdition(),
   );
 }
+
+export function getCachedVideoScript(targetSlug: string): Promise<VideoScriptRef | null> {
+  if (bypassReaderCacheInDevelopment) {
+    return Promise.resolve(graphqlContentRepository.loadVideoScript(targetSlug)).then((result) => result ?? null);
+  }
+  return withReaderCache(
+    ["reader-video-script", targetSlug],
+    [articleCacheTag(targetSlug), ARTICLES_CACHE_TAG],
+    async () => graphqlContentRepository.loadVideoScript(targetSlug),
+  );
+}

package/lib/category-repository.ts

@@ -769,85 +769,7 @@ function knowledgeCorpusIdFromKey(corpusKey: string): string {
 }
 
 export async function loadCategorySteeringDashboard(): Promise<CategorySteeringDashboard> {
-  const proposals = await loadServerSteeringProposals();
-  if (proposals.length === 0) return createEmptyCategorySteeringDashboard();
-  return {
-    ...createEmptyCategorySteeringDashboard(),
-    isPublicSkeleton: false,
-    proposals: sortProposals(proposals),
-    loadError: null,
-  };
-}
-
-const SERVER_STEERING_PROPOSALS_QUERY = `
-  query ListSteeringProposals($limit: Int, $nextToken: String) {
-    listSteeringProposals(limit: $limit, nextToken: $nextToken) {
-      items {
-        id
-        categorySetId
-        corpusId
-        proposalKind
-        steeringDomain
-        status
-        title
-        summary
-        categoryKey
-        targetCategoryKey
-        graphEntityId
-        relationshipType
-        displayName
-        shortTitle
-        subtitle
-        description
-        evidenceItemIds
-        suggestedSeedItemIds
-        suggestedHoldoutItemIds
-        sourceSnapshotId
-        proposedAt
-        reviewedAt
-        reviewedBy
-        updatedAt
-      }
-      nextToken
-    }
-  }
-`;
-
-async function loadServerSteeringProposals(): Promise<CategorySteeringProposal[]> {
-  const endpoint = process.env.PAPYRUS_GRAPHQL_ENDPOINT;
-  const jwt = process.env.PAPYRUS_GRAPHQL_JWT;
-  if (!endpoint || !jwt) return [];
-
-  const items: CategorySteeringProposal[] = [];
-  let nextToken: string | null = null;
-
-  for (let page = 0; page < 20; page += 1) {
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        Authorization: `Bearer ${jwt}`,
-      },
-      body: JSON.stringify({
-        query: SERVER_STEERING_PROPOSALS_QUERY,
-        variables: { limit: 500, nextToken },
-      }),
-      cache: "no-store",
-    });
-    if (!response.ok) return [];
-    const payload = await response.json() as {
-      data?: { listSteeringProposals?: { items?: Array<CategorySteeringProposal | null> | null; nextToken?: string | null } | null } | null;
-      errors?: Array<{ message?: string }> | null;
-    };
-    if (payload.errors?.length) return [];
-    const connection = payload.data?.listSteeringProposals;
-    if (!connection) return [];
-    items.push(...(connection.items ?? []).filter(Boolean) as CategorySteeringProposal[]);
-    nextToken = connection.nextToken ?? null;
-    if (!nextToken) break;
-  }
-
-  return items;
+  return createEmptyCategorySteeringDashboard();
 }
 
 function sortCategorySets(categorySets: CategorySteeringCategorySet[], importRuns: CategorySteeringImportRun[]): CategorySteeringCategorySet[] {
@@ -895,20 +817,6 @@ function sortCategorys(categorys: CategorySteeringCategory[]): CategorySteeringC
   });
 }
 
-function sortProposals(proposals: CategorySteeringProposal[]): CategorySteeringProposal[] {
-  const statusWeight = new Map([
-    ["proposed", 0],
-    ["deferred", 1],
-    ["accepted", 2],
-    ["rejected", 3],
-  ]);
-  return [...proposals].sort((left, right) => {
-    const statusDiff = (statusWeight.get(left.status) ?? 9) - (statusWeight.get(right.status) ?? 9);
-    if (statusDiff !== 0) return statusDiff;
-    return (right.proposedAt ?? right.updatedAt ?? "").localeCompare(left.proposedAt ?? left.updatedAt ?? "");
-  });
-}
-
 function defaultNewsroomSections(importedAt: string, sectionsConfigPath = DEFAULT_NEWSROOM_SECTIONS_CONFIG_PATH): NewsroomSectionRecord[] {
   return loadNewsroomSectionSeedRows(sectionsConfigPath).map((row, index) => ({
     ...row,

package/lib/content-actions-client.ts

@@ -0,0 +1,98 @@
+import { generateClient } from "aws-amplify/data";
+import type { Schema } from "../amplify/data/resource";
+
+export type ContentActionError = { code: string; message: string; line: number | null };
+
+export type DeriveMarkusInput = { frontMatterYaml: string | null; bodyMarkus: string; includeIr?: boolean };
+export type SaveItemDraftInput = {
+  id: string | null;
+  type: string;
+  slug: string;
+  section: string | null;
+  frontMatterYaml: string | null;
+  bodyMarkus: string;
+  aliases: string[];
+  expectedContentHash: string | null;
+};
+
+export type DeriveMarkusResult = { ok: true; bodyIrBytes: number; bodyIr?: unknown; errors: [] };
+export type SavedItemSummary = {
+  id: string;
+  contentHash: string;
+  status: string;
+  slug: string;
+  versionNumber: number | null;
+};
+export type SaveItemDraftResult = { ok: true; item: SavedItemSummary };
+export type PublishItemResult = { ok: true; changed: boolean; publishedId: string; versionNumber: number | null };
+export type UnpublishItemResult = { ok: true; changed: boolean };
+
+export class ContentActionFailure extends Error {
+  readonly errors: ContentActionError[];
+
+  constructor(errors: ContentActionError[]) {
+    super(errors.map((error) => error.message).join("; ") || "Content action failed");
+    this.name = "ContentActionFailure";
+    this.errors = errors;
+  }
+}
+
+type GraphqlEnvelope = { data?: unknown; errors?: { message?: string }[] | null };
+
+export type ContentActionsTransport = {
+  queries: { deriveMarkus: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope> };
+  mutations: {
+    saveItemDraft: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
+    publishItem: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
+    unpublishItem: (args: { input: string }, options: { authMode: "userPool" }) => Promise<GraphqlEnvelope>;
+  };
+};
+
+const USER_POOL = { authMode: "userPool" } as const;
+
+function parseActionResponse<T>(envelope: GraphqlEnvelope): T {
+  if (envelope.errors && envelope.errors.length > 0) {
+    throw new Error(envelope.errors.map((error) => error.message ?? "GraphQL error").join("; "));
+  }
+  const raw = envelope.data;
+  const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("The content action returned no data.");
+  }
+  const response = parsed as { ok?: boolean; errors?: ContentActionError[] };
+  if (response.ok !== true) {
+    throw new ContentActionFailure(response.errors ?? []);
+  }
+  return parsed as T;
+}
+
+export function createContentActionsClient(transport: ContentActionsTransport) {
+  return {
+    async deriveMarkus(input: DeriveMarkusInput): Promise<DeriveMarkusResult> {
+      return parseActionResponse(await transport.queries.deriveMarkus({ input: JSON.stringify(input) }, USER_POOL));
+    },
+    async saveItemDraft(input: SaveItemDraftInput): Promise<SaveItemDraftResult> {
+      return parseActionResponse(await transport.mutations.saveItemDraft({ input: JSON.stringify(input) }, USER_POOL));
+    },
+    async publishItem(id: string): Promise<PublishItemResult> {
+      return parseActionResponse(await transport.mutations.publishItem({ input: JSON.stringify({ id }) }, USER_POOL));
+    },
+    async unpublishItem(id: string): Promise<UnpublishItemResult> {
+      return parseActionResponse(await transport.mutations.unpublishItem({ input: JSON.stringify({ id }) }, USER_POOL));
+    },
+  };
+}
+
+let defaultClient: ReturnType<typeof createContentActionsClient> | null = null;
+
+function contentActionsClient() {
+  if (!defaultClient) {
+    defaultClient = createContentActionsClient(generateClient<Schema>() as unknown as ContentActionsTransport);
+  }
+  return defaultClient;
+}
+
+export const deriveMarkus = (input: DeriveMarkusInput) => contentActionsClient().deriveMarkus(input);
+export const saveItemDraft = (input: SaveItemDraftInput) => contentActionsClient().saveItemDraft(input);
+export const publishItem = (id: string) => contentActionsClient().publishItem(id);
+export const unpublishItem = (id: string) => contentActionsClient().unpublishItem(id);

package/lib/content-actions-demo.ts

@@ -0,0 +1,190 @@
+import { ContentActionFailure } from "./content-actions-client";
+import type {
+  DeriveMarkusInput,
+  DeriveMarkusResult,
+  PublishItemResult,
+  SaveItemDraftInput,
+  SaveItemDraftResult,
+  UnpublishItemResult,
+} from "./content-actions-client";
+import {
+  createDemoArticleRecords,
+  demoContentHash,
+  type DemoArticleRecord,
+} from "./newsroom-demo-articles";
+import { sourceLineOffset, type ArticlesBackend, type EditableArticle, type NewsroomArticleRow } from "./newsroom-articles";
+
+function titleFromYaml(frontMatterYaml: string | null, fallback: string): string {
+  for (const line of (frontMatterYaml ?? "").split("\n")) {
+    const match = /^title\s*:\s*(.*)$/.exec(line);
+    if (match && match[1].trim()) return match[1].trim().replace(/^["']|["']$/g, "");
+  }
+  return fallback;
+}
+
+const DEMO_IMAGE_DIRECTIVE = /^::image\{([^}]*)\}$/;
+
+function demoAttribute(attributes: string, name: string): string {
+  const match = new RegExp(`${name}="([^"]*)"`).exec(attributes);
+  return match ? match[1] : "";
+}
+
+function demoEnvelope(bodyMarkus: string) {
+  const images: Record<string, Record<string, unknown>> = {};
+  const children = bodyMarkus
+    .split(/\n{2,}/)
+    .map((block) => block.trim())
+    .filter(Boolean)
+    .map((block) => {
+      const heading = /^(#{1,6})\s+(.*)$/.exec(block);
+      if (heading) {
+        return { type: "heading", level: heading[1].length, inline: [{ type: "text", text: heading[2] }], line: null };
+      }
+      const image = DEMO_IMAGE_DIRECTIVE.exec(block);
+      if (image) {
+        const token = `PAPYRUSMARKUP${String(Object.keys(images).length + 1).padStart(5, "0")}END`;
+        images[token] = {
+          src: demoAttribute(image[1], "src"),
+          alt: demoAttribute(image[1], "alt"),
+          layout: demoAttribute(image[1], "layout") || null,
+        };
+        return { type: "paragraph", inline: [{ type: "text", text: token }], line: null };
+      }
+      return { type: "paragraph", inline: [{ type: "text", text: block }], line: null };
+    });
+  return {
+    schemaVersion: 1,
+    markus: { version: "demo", irSchemaVersion: 1 },
+    document: { type: "document", schema_version: 1, front_matter: {}, children },
+    papyrus: { images, citations: {}, citationLists: {}, entries: {}, bibliography: [] },
+  };
+}
+
+export function createDemoArticlesBackend(): ArticlesBackend {
+  const records = new Map<string, DemoArticleRecord>(createDemoArticleRecords().map((record) => [record.id, record]));
+  let created = 0;
+
+  const requireRecord = (id: string): DemoArticleRecord => {
+    const record = records.get(id);
+    if (!record) throw new ContentActionFailure([{ code: "not-found", message: "That article was not found.", line: null }]);
+    return record;
+  };
+
+  return {
+    actions: {
+      async deriveMarkus(input: DeriveMarkusInput): Promise<DeriveMarkusResult> {
+        const lines = input.bodyMarkus.split("\n");
+        const invalidIndex = lines.findIndex((line) => line.includes(":::nope"));
+        if (invalidIndex >= 0) {
+          throw new ContentActionFailure([
+            { code: "markus-validation", message: 'Unknown directive "nope".', line: invalidIndex + 1 + sourceLineOffset(input.frontMatterYaml) },
+          ]);
+        }
+        const envelope = demoEnvelope(input.bodyMarkus);
+        return {
+          ok: true,
+          bodyIrBytes: JSON.stringify(envelope).length,
+          ...(input.includeIr ? { bodyIr: envelope } : {}),
+          errors: [],
+        };
+      },
+      async saveItemDraft(input: SaveItemDraftInput): Promise<SaveItemDraftResult> {
+        const existing = input.id ? requireRecord(input.id) : null;
+        if (existing && input.expectedContentHash !== null && input.expectedContentHash !== existing.contentHash) {
+          throw new ContentActionFailure([
+            { code: "conflict", message: "The item changed since it was loaded.", line: null },
+          ]);
+        }
+        if (existing && existing.everPublished && existing.slug !== input.slug) {
+          throw new ContentActionFailure([
+            { code: "slug-locked", message: "The slug cannot change once the item has been published.", line: null },
+          ]);
+        }
+        const id = existing?.id ?? `demo-article-new-${(created += 1)}`;
+        const title = titleFromYaml(input.frontMatterYaml, input.slug);
+        const frontMatterYaml = input.frontMatterYaml ?? "";
+        const record: DemoArticleRecord = {
+          id,
+          type: input.type,
+          slug: input.slug,
+          section: input.section,
+          title,
+          status: existing?.status ?? "draft",
+          frontMatterYaml,
+          bodyMarkus: input.bodyMarkus,
+          contentHash: demoContentHash(frontMatterYaml, input.bodyMarkus),
+          publishedContentHash: existing?.publishedContentHash ?? null,
+          versionNumber: existing?.versionNumber ?? null,
+          everPublished: existing?.everPublished ?? false,
+          updatedAt: new Date().toISOString(),
+        };
+        records.set(id, record);
+        return {
+          ok: true,
+          item: {
+            id,
+            contentHash: record.contentHash,
+            status: record.status,
+            slug: record.slug,
+            versionNumber: record.versionNumber,
+          },
+        };
+      },
+      async publishItem(id: string): Promise<PublishItemResult> {
+        const record = requireRecord(id);
+        const changed = record.status !== "published" || record.publishedContentHash !== record.contentHash;
+        const versionNumber = changed ? (record.versionNumber ?? 0) + 1 : record.versionNumber;
+        records.set(id, {
+          ...record,
+          status: "published",
+          everPublished: true,
+          publishedContentHash: record.contentHash,
+          versionNumber,
+          updatedAt: new Date().toISOString(),
+        });
+        return { ok: true, changed, publishedId: `published-${id}`, versionNumber };
+      },
+      async unpublishItem(id: string): Promise<UnpublishItemResult> {
+        const record = requireRecord(id);
+        const changed = record.status === "published";
+        records.set(id, {
+          ...record,
+          status: "draft",
+          publishedContentHash: null,
+          updatedAt: new Date().toISOString(),
+        });
+        return { ok: true, changed };
+      },
+    },
+    async listRows(): Promise<NewsroomArticleRow[]> {
+      return [...records.values()]
+        .map((record) => ({
+          id: record.id,
+          type: record.type,
+          slug: record.slug,
+          section: record.section,
+          title: record.title || record.slug,
+          status: record.status,
+          pending: record.status === "published" && record.publishedContentHash !== record.contentHash,
+          updatedAt: record.updatedAt,
+        }))
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    },
+    async loadArticle(id: string): Promise<EditableArticle> {
+      const record = requireRecord(id);
+      return {
+        id: record.id,
+        type: record.type,
+        section: record.section,
+        slug: record.slug,
+        frontMatterYaml: record.frontMatterYaml,
+        bodyMarkus: record.bodyMarkus,
+        contentHash: record.contentHash,
+        status: record.status,
+        versionNumber: record.versionNumber,
+        aliases: [],
+        everPublished: record.everPublished,
+      };
+    },
+  };
+}

package/lib/content-repository.ts

@@ -1,6 +1,9 @@
 import type { ContentRepository } from "./content-types";
 import { graphqlContentRepository } from "./graphql-content-repository";
 import { getLayoutScenario } from "./layout-scenarios";
+import { assertContentSourceMatchesEnv } from "./site-env";
+
+assertContentSourceMatchesEnv();
 
 export const contentRepository: ContentRepository = {
   loadEditionContent({ scenarioId, editionDate, editionSlug } = {}) {
@@ -28,6 +31,9 @@ export const contentRepository: ContentRepository = {
   listArticleSlugs() {
     return graphqlContentRepository.listArticleSlugs();
   },
+  loadVideoScript(targetSlug: string) {
+    return graphqlContentRepository.loadVideoScript(targetSlug);
+  },
 };
 
 export function getScenarioIdParam(scenario: string | string[] | null | undefined): string | null {

package/lib/content-source-context.ts

@@ -0,0 +1,26 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { getContentSource, type ContentSource } from "./site-env";
+
+export type ContentSourceContext = {
+  source: ContentSource;
+  /** Request-scoped data client (drafts mode: carries the visitor's session cookies). */
+  client?: unknown;
+};
+
+const contentSourceStorage = new AsyncLocalStorage<ContentSourceContext>();
+
+export function runWithContentSource<T>(
+  source: ContentSource,
+  operation: () => Promise<T>,
+  client?: unknown,
+): Promise<T> {
+  return contentSourceStorage.run({ source, client }, operation);
+}
+
+export function currentRequestClient<T>(): T | undefined {
+  return contentSourceStorage.getStore()?.client as T | undefined;
+}
+
+export function currentContentSource(): ContentSource {
+  return contentSourceStorage.getStore()?.source ?? getContentSource();
+}

package/lib/content-types.ts

@@ -1,6 +1,7 @@
 import type { Article, ArticleVideoAsset } from "./articles";
 import type { EditionLayoutPlan } from "./layout-plan";
 import type { PublicationItem } from "./publication-items";
+import type { VideoScriptRef } from "./video-script";
 
 export type ContentSource = "scenario" | "graphql";
 
@@ -55,6 +56,8 @@ export type EditionContent = {
   scenarioId?: string;
   description?: string;
   editionVideo?: ArticleVideoAsset | null;
+  /** Video scripts by item slug (`"edition-overview"` for the edition video), for the VideoML preview. */
+  videoScripts?: Record<string, VideoScriptRef>;
 };
 
 export type EditionRouteSummary = {
@@ -101,4 +104,5 @@ export type ContentRepository = {
   getEditionArticle(options: GetEditionArticleOptions): Article | undefined | Promise<Article | undefined>;
   getEditionItem(options: GetEditionItemOptions): PublicationItem | undefined | Promise<PublicationItem | undefined>;
   listArticleSlugs(): string[] | Promise<string[]>;
+  loadVideoScript(targetSlug: string): VideoScriptRef | null | Promise<VideoScriptRef | null>;
 };