@openpresentation/opf 0.13.0 → 0.15.1

package/dist/{composition-D7we69Tr.d.ts → composition-D2tghM82.d.ts}

@@ -1,4 +1,5 @@
-import './chart-data-Cdr6rRVV.js';
+import { b as CatalogOptions } from './catalog-refs-BSfGELpt.js';
+import './chart-data-BnNqgnC-.js';
 
 /** Canonical table grid. No renderer, fonts, DOM or network dependencies. */
 interface TableBorder {
@@ -43,6 +44,110 @@ declare function tableGrid(value: unknown, path?: string): TableGrid;
 /** Row boundaries that preserve every vertical merge, used by pagination. */
 declare function tableRowBoundaries(value: unknown): number[];
 
+/** The `design` keys that a layout record, the deck and a slide all share and that composition resolves per key. */
+declare const DESIGN_HINT_KEYS: readonly ["titleAlignment", "contentAlignment", "contentBox", "contentDirection", "chartPrimary", "imageFit", "listBullet"];
+type DesignHintKey = typeof DESIGN_HINT_KEYS[number];
+/** Where an effective design hint came from: the slide's own `design`, the deck's `design`, or the slide's layout record. */
+type DesignHintSource = 'slide' | 'deck' | 'layout';
+/** The effective value of every shared design key. A key nobody sets is absent, so the engine default applies. */
+interface DesignHints {
+    titleAlignment?: 'left' | 'center' | 'right';
+    contentAlignment?: 'left' | 'center' | 'right';
+    contentBox?: boolean;
+    contentDirection?: 'horizontal' | 'vertical';
+    chartPrimary?: 'none' | 'top' | 'bottom' | 'left' | 'right';
+    imageFit?: 'cover' | 'contain' | 'stretch';
+    listBullet?: 'character' | 'image';
+}
+/** The effective hints plus which level supplied each key and the document path that names it. */
+interface ResolvedDesignHints extends DesignHints {
+    /** The level that supplied each key that is set. */
+    sources: {
+        [K in DesignHintKey]?: DesignHintSource;
+    };
+    /** Path of the supplying value: `slides.N.design.key`, `design.key`, or for a layout `slides.N.layout` (the reference that selected the record). */
+    paths: {
+        [K in DesignHintKey]?: string;
+    };
+}
+interface ResolveDesignHintsOptions {
+    /** The slide, for its own `design`. */
+    slide?: unknown;
+    /** The slide's resolved layout record, for its `design`. */
+    layout?: unknown;
+    /** The document, for the deck's `design`. */
+    presentation?: unknown;
+    /** Index used in the reported paths; defaults to 0. */
+    slideIndex?: number;
+    /** Host-resolved deck-level values. They rank with the deck's `design`, above it, and below the slide's. */
+    deck?: DesignHints;
+}
+/**
+ * Resolves the shared design keys with one merge, per key, the slide winning: the slide's `design`, then the
+ * deck's `design` (or the host's `deck` values), then the resolved layout record's `design`. A key none of them
+ * sets stays absent. A value the schema does not allow for its key is skipped, so the next level answers. Composition, the renderer, the PPTX exporter and the audit all take their values from here
+ * (`SlideComposition.design`), so they cannot disagree.
+ */
+declare function resolveDesignHints(options?: ResolveDesignHintsOptions): ResolvedDesignHints;
+
+/**
+ * Metric trend mark (RR-07, FA-06): the arrow and colour that show `metric.trend` and
+ * `metric.sentiment` in the SVG preview and the PPTX export. Core's metric layout places the trend word (up, down, flat) as ordinary
+ * text; this derives, from that accepted line geometry, one arrow beside it so both engines draw
+ * the same shape in the same place and colour. The word stays the text alternative: the arrow
+ * adds a visual cue and an `ariaLabel`, never rewritten source text. The arrow always points the
+ * way the trend does; its colour (and the trend and delta text colour) follows the sentiment, which
+ * defaults to the conventional reading of the trend (up positive, down negative, flat neutral).
+ */
+
+type MetricTrend = 'up' | 'down' | 'flat';
+/** Whether a change is good news: the colour of the trend mark. */
+type MetricSentiment = 'positive' | 'negative' | 'neutral';
+/** The DrawingML preset geometry that draws each trend (`a:prstGeom prst`). */
+declare const METRIC_TREND_SHAPES: Readonly<Record<MetricTrend, 'upArrow' | 'downArrow' | 'rightArrow'>>;
+declare const METRIC_TREND_MIN_CONTRAST = 4.5;
+interface MetricTrendColorOptions {
+    /** The slide background the metric text sits on. */
+    background: string;
+    /** Neutral colour for a neutral sentiment (the deck's muted text). */
+    neutral?: string;
+    /** Whether the change is good news; absent, the trend's default (up positive, down negative, flat neutral). */
+    sentiment?: MetricSentiment;
+}
+/** The colour of a trend (or, with `options.sentiment`, of its sentiment), kept at >= 4.5:1 against the slide background. */
+declare function metricTrendColor(trend: MetricTrend, options: MetricTrendColorOptions): string;
+interface MetricTrendMark {
+    trend: MetricTrend;
+    /** The sentiment the colour follows: the metric's own, else the default for the trend. */
+    sentiment: MetricSentiment;
+    /** DrawingML preset name for native export. */
+    shape: 'upArrow' | 'downArrow' | 'rightArrow';
+    /** Arrow bounding box in layout pixels (96 per inch). */
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** The arrow outline as polygon points in layout pixels: the preset geometry at default adjustments. */
+    points: [number, number][];
+    color: string;
+    /** Text alternative for the arrow. */
+    ariaLabel: string;
+    /** Path of the trend field the mark belongs to. */
+    path: string;
+}
+/** Outline of the DrawingML upArrow, downArrow or rightArrow preset (adj1 = adj2 = 50000) in `box`. */
+declare function metricTrendPoints(shape: MetricTrendMark['shape'], box: MetricTrendMark['box']): [number, number][];
+/**
+ * The arrow for a laid-out metric, or undefined when the metric has no (visible) trend or the
+ * arrow has no room. It is square, as tall as the trend word's capitals, on the baseline, and
+ * sits after the word for left-aligned metrics and before it for centred or right-aligned ones,
+ * so it grows away from the alignment edge. It never leaves the trend field's box. The colour
+ * follows `options.sentiment`, else the layout's own (`metric.sentiment`), else the trend's default.
+ */
+declare function metricTrendMark(layout: MetricLayout, options: MetricTrendColorOptions): MetricTrendMark | undefined;
+
 /** A positioned thing whose reading position is wanted. */
 interface ReadingBox {
     box: {
@@ -62,11 +167,34 @@ interface ReadingBox {
  * The boxes are read as given: pass them in logical (unmirrored) coordinates and the order is the reading
  * order of both a left-to-right and a right-to-left deck, because mirroring a deck moves where an item is
  * drawn and where a line starts together. For boxes that are already mirrored, pass `direction: 'rtl'` to
- * order each row from right to left. composeSlide uses this for promoted regions and `opf audit` uses it to
+ * order each row from right to left. composeSlide uses this for promoted regions and `opf/reading-order` uses it to
  * check the composed order, so the two cannot drift apart.
  */
 declare function visualReadingOrder<T extends ReadingBox>(items: readonly T[], direction?: 'ltr' | 'rtl'): T[];
 
+/**
+ * Intrinsic aspect ratio (width / height) of an image source, read without fetching: an embedded
+ * `data:` URI (PNG, JPEG, GIF, WebP, SVG), or an `asset:<id>` reference to one in `assets`.
+ * Any other source (a URL or file path) has no readable dimensions here and returns undefined;
+ * hosts resolve those themselves.
+ *
+ * Only a bounded prefix of the payload is decoded (never the whole of a multi-megabyte logo): 64 KiB, which
+ * holds every PNG, GIF and WebP header and the root `<svg>` tag of any real SVG, then 1 MiB for a JPEG whose
+ * start-of-frame segment sits behind large EXIF or ICC data. A JPEG whose frame header is still not inside
+ * 1 MiB, or an SVG whose root tag is not inside 64 KiB, has no readable proportions (undefined, so a square
+ * box). Results are memoized per source string, so a deck's repeated header image is read once.
+ */
+type Dimensions = {
+    width: number;
+    height: number;
+};
+/** Whether the value is an embedded raster or SVG image whose size is readable, and its pixel size (SVG: its user-unit size). */
+declare function intrinsicImageSize(value: unknown, assets?: unknown): (Dimensions & {
+    svg: boolean;
+}) | undefined;
+/** Width / height of an embedded image, following `asset:<id>` references through `assets`; undefined when unreadable. */
+declare function intrinsicImageAspect(value: unknown, assets?: unknown): number | undefined;
+
 /**
  * Text direction primitives shared by composition, the renderer and the PPTX exporter (RR-05).
  * Pure: no fonts, DOM or catalogs. Deck direction comes from the presentation language's script
@@ -104,6 +232,58 @@ declare function physicalAlignment(alignment: PhysicalAlignment | undefined, dir
  */
 declare function paragraphDirectionAt(text: string, deckDirection: TextDirection | string | undefined): (offset: number) => TextDirection;
 
+/**
+ * Engine defaults and engine vocabularies (OPF 0.15, FA-20/21). Small tables of values every engine must know to
+ * draw, compiled from spec/reference/engine-defaults.json and spec/reference/engine-vocabularies.json. None of
+ * this is catalog data: a document never references these records, and no catalog lookup reaches them.
+ */
+type Rec = Readonly<Record<string, unknown>>;
+/** The drawing fields of the theme engines use when a document names none, or its theme resolves nowhere. */
+declare const ENGINE_DEFAULT_THEME: Rec;
+/** The twelve slots engines use when neither the design nor the theme names a resolvable colour scheme. */
+declare const ENGINE_DEFAULT_COLOR_SCHEME: Rec;
+/** The font pair engines use when neither the design nor the theme names a resolvable font scheme. */
+declare const ENGINE_DEFAULT_FONT_SCHEME: Rec;
+/** Chart types in the order an engine offers them when it must pick one. */
+declare const ENGINE_DEFAULT_CHART_TYPES: readonly string[];
+/** Every `chart.type` value: an engine vocabulary, validated directly. */
+declare const CHART_TYPES: readonly string[];
+/** How an engine links a handle on one social platform. */
+interface SocialPlatformVocabulary {
+    readonly baseUrl?: string;
+    /** URL of a person's profile, with `{handle}` standing for the handle. */
+    readonly profileUrlPattern?: string;
+    /** URL of an organization's page, when the platform has a separate one. */
+    readonly companyUrlPattern?: string;
+    /** Prefix a handle is written with (`@` on X). */
+    readonly handlePrefix?: string;
+}
+/** The keys of `Organization.socials` and `Speaker.socials`: an engine vocabulary, validated directly. */
+declare const SOCIAL_PLATFORMS: Readonly<Record<string, SocialPlatformVocabulary>>;
+/** What engines know about one language tag. */
+interface LanguageVocabulary {
+    /** BCP-47 tag, canonically cased. */
+    readonly tag: string;
+    /** ISO 15924 script. */
+    readonly script: string;
+    readonly direction: 'ltr' | 'rtl';
+    /** Curated OOXML culture tag (`ja-JP` for `ja`). */
+    readonly ooxmlLang: string;
+    /** Default script fonts (major/minor) per target application. */
+    readonly fonts: {
+        readonly powerpoint: {
+            readonly major: string;
+            readonly minor: string;
+        };
+        readonly google: {
+            readonly major: string;
+            readonly minor: string;
+        };
+    };
+}
+/** The language tags engines know the script, direction, OOXML tag and default script fonts of. */
+declare const LANGUAGES: readonly LanguageVocabulary[];
+
 /**
  * Numbered lists: the `numbering` field of `items` and `bullets` payloads.
  *
@@ -218,7 +398,7 @@ declare function formatSlideNumber(format: string, current: number, total: numbe
 
 /** Normalize a literal hex color to uppercase #RRGGBB. */
 declare function normalizeHexColor(value: unknown): string | undefined;
-type ResolveColorRefRoles = Partial<Record<'primary' | 'secondary' | 'accent' | 'background' | 'surface' | 'text' | 'textSecondary', string>>;
+type ResolveColorRefRoles = Partial<Record<'primary' | 'secondary' | 'accent' | 'background' | 'surface' | 'surfaceAlt' | 'text' | 'textSecondary', string>>;
 interface ResolveColorRefOptions {
     /** Effective color scheme after design resolution (OOXML slots plus optional role hex overrides). */
     colorScheme: Record<string, unknown>;
@@ -231,6 +411,52 @@ interface ResolveColorRefOptions {
 }
 /** Resolve a ColorRef or TextRun.color string to a literal hex color. */
 declare function resolveColorRef(reference: string, options: ResolveColorRefOptions): string;
+/** WCAG relative luminance below which a slide background counts as dark (the point where white and black text contrast equally). */
+declare const DARK_BACKGROUND_LUMINANCE = 0.179;
+/** True when text on this color should be light: its relative luminance is under {@link DARK_BACKGROUND_LUMINANCE}. An unreadable color is not dark. */
+declare function isDarkColor(color: unknown): boolean;
+/**
+ * The slide background a color scheme implies when the design names no single-color background: the scheme's
+ * `background` role override, else its light1 slot, else white. Gradient and picture backgrounds use it too.
+ */
+declare function defaultSlideBackground(colorScheme: Record<string, unknown>): string;
+interface ResolvedColorRoles {
+    /** Role override, else accent1. */
+    primary: string;
+    /** Role override, else accent2. */
+    secondary: string;
+    /** Role override, else accent3. */
+    accent: string;
+    /** The slide background: the resolved single-color background of the slide, else {@link defaultSlideBackground}. */
+    background: string;
+    /** Role override, else dark2 on a dark background and light2 on a light one. */
+    surface: string;
+    /** The alternate surface of banded table rows: {@link surfaceAltColor} of `surface` and `text`, always distinguishable from `surface`. */
+    surfaceAlt: string;
+    /** Default text. On a dark background light1. On a light background the `text` role override, else dark1. */
+    text: string;
+    /** Role override, else light2 on a dark background and dark2 on a light one. */
+    textSecondary: string;
+    /** The color of a link run that sets no color of its own: the scheme's hyperlink slot (OOXML hlink), unless that has under 4.5:1 contrast against the slide background, then the slide `text` color. */
+    hyperlink: string;
+    /** Followed-hyperlink slot (OOXML folHlink). */
+    followedHyperlink: string;
+    /** Whether the slide background is dark; text, surface and textSecondary defaults follow it. */
+    dark: boolean;
+}
+interface ResolveColorRolesOptions {
+    /** The slide's resolved single-color background (solid, theme-slot or pattern background color). Omit for a gradient, picture or no background. */
+    background?: string | null;
+}
+/**
+ * Resolve a color scheme's abstract roles for one slide: the single definition the opf-render preview, the
+ * PPTX export and the audit share, so the same deck draws the same colors in all three. Role overrides on the
+ * scheme (`primary`, `secondary`, `accent`, `background`, `surface`, `text`, `textSecondary`) win over the slots they
+ * default to. The background-dependent roles follow {@link isDarkColor} of the slide background; a `text`
+ * override applies only on a light background, so a dark slide always gets readable light1 text.
+ * Values are uppercase #RRGGBB, or #RRGGBBAA where the scheme color carries an alpha byte.
+ */
+declare function resolveColorRoles(colorScheme: Record<string, unknown>, options?: ResolveColorRolesOptions): ResolvedColorRoles;
 declare function colorContrast(foreground: string, background: string): number | undefined;
 /** Keep an inherited text color at >=4.5:1; otherwise select black or white.
  * Callers must preserve explicit text-color overrides before using this fallback.
@@ -274,12 +500,422 @@ declare const CHART_SERIES_MIN_DIFFERENCE = 12;
  * and preview and export (which both call this function) draw the same ones.
  */
 declare function chartPaletteForFill(fill: string, palette: readonly string[]): string[];
+/** Share of the text colour mixed into the surface to make the muted colour of a highlighted chart. */
+declare const CHART_HIGHLIGHT_MUTED_MIX = 0.3;
+/** Smallest contrast the muted colour keeps against the surface: recessive, but still a visible mark. */
+declare const CHART_HIGHLIGHT_MUTED_MIN_CONTRAST = 1.6;
+/**
+ * The two colours of a chart that highlights marks (`chart.highlight`), derived from the theme only: `accent` for the highlighted
+ * marks, `muted` for every other mark.
+ *
+ * - `accent` is the deck's primary colour, kept at >= 3:1 against the surface by `chartColorForFill` (a primary that already has
+ *   that contrast is returned unchanged).
+ * - `muted` is the surface mixed {@link CHART_HIGHLIGHT_MUTED_MIX} of the way towards the text colour: a light grey on a light surface
+ *   and a dim grey on a dark one, in the surface's own hue. When that falls below {@link CHART_HIGHLIGHT_MUTED_MIN_CONTRAST} against
+ *   the surface (a surface and text that are close together) the mix moves towards the text colour until it holds.
+ *
+ * Pure arithmetic on opaque colours: the preview and the PPTX export both call it with the chart panel, the primary and the label
+ * colour, so they draw and write the same two colours. An unresolved colour is replaced by white (surface), the surface's own
+ * best contrast partner (text) or black (primary).
+ */
+declare function chartHighlightColors(surface: string, primary: string, text: string): {
+    accent: string;
+    muted: string;
+};
+/** Share of the text colour mixed into the surface for the `surfaceAlt` role. */
+declare const SURFACE_ALT_MIX = 0.1;
+/** Smallest contrast `surfaceAlt` keeps against `surface`, so a band is visible next to a plain row. */
+declare const SURFACE_ALT_MIN_CONTRAST = 1.1;
+/**
+ * The `surfaceAlt` colour role: the fill of the banded rows of a table whose other body rows take `surface`. It is the surface
+ * mixed {@link SURFACE_ALT_MIX} of the way towards the text colour (a slightly darker band on a light table, a slightly lighter one
+ * on a dark table), moved further until it differs from the surface by {@link SURFACE_ALT_MIN_CONTRAST}, while the text keeps
+ * 4.5:1 on it. When mixing towards the text cannot keep both (a surface and text that are close together), the band moves the
+ * other way, away from the text, which only raises the text contrast. Pure arithmetic on opaque colours, so the preview and
+ * the PPTX export, which both resolve the `surfaceAlt` ColorRef from their own `surface` and `text` roles, draw and write the
+ * same colour. An unresolved surface is white; an unresolved text colour is the surface's best contrast partner.
+ */
+declare function surfaceAltColor(surface: string, text: string): string;
+
+/**
+ * Language/script font model (font-fidelity-everywhere FF-18).
+ *
+ * Resolves, for a presentation's language and effective font scheme, the font
+ * family for each OOXML script slot (`a:latin`, `a:ea`, `a:cs`) of the major
+ * (heading) and minor (body) theme fonts, plus the language tags and base
+ * direction. Pure: no DOM, fonts, network or mutation. Font-scheme references
+ * resolve like every content reference (the document's catalogs groups, then the
+ * registered catalogs); nothing is fetched.
+ *
+ * The language is an engine vocabulary: tags the vocabulary knows resolve
+ * deterministically from vendored tables. Only a tag outside it may consult the
+ * runtime's ICU likely subtags (`Intl.Locale#maximize`) to find its script.
+ *
+ * Design: docs/programs/font-fidelity-everywhere/script-font-model.md.
+ */
+/** OOXML script slot a writing system uses: `a:latin`, `a:ea` or `a:cs`. */
+type ScriptRole = "latin" | "eastAsian" | "complexScript";
+/** FontScheme.languageFamily as written: the short OOXML names and the long slot names are one value. */
+type LanguageFamilyName = "latin" | "ea" | "cs" | "eastAsian" | "complexScript";
+/**
+ * Read a FontScheme `languageFamily` as one of three values. `eastAsian` is `ea` and `complexScript` is
+ * `cs`; anything that is not one of the five names returns undefined.
+ */
+declare function normalizeLanguageFamily(value: unknown): "latin" | "ea" | "cs" | undefined;
+/** Target application whose language font-scheme defaults apply. */
+type ScriptFontApp = "powerpoint" | "google-slides";
+/** Font family per OOXML script slot for one theme font (major or minor). */
+interface ScriptFontSlots {
+    latin: string;
+    eastAsian: string;
+    complexScript: string;
+}
+/**
+ * Where a resolved eastAsian/complexScript family came from:
+ * - `fontScheme`: an explicit `eastAsian`/`complexScript` slot on the effective design font scheme.
+ * - `schemeFamily`: the design font scheme's own major/minor, because its `languageFamily` names this
+ *   slot and its `languages` list is empty or names the presentation language.
+ * - `language`: the presentation language's font scheme (`fontScheme`, or `googleFontScheme` for Google Slides).
+ * - `latin`: no script-specific choice exists, so the slot repeats the latin family.
+ */
+type ScriptFontSource = "fontScheme" | "schemeFamily" | "language" | "latin";
+/** A per-script supplemental theme font, as in OOXML `<a:font script="Jpan" typeface="..."/>`. */
+interface ScriptFontSupplement {
+    /** OOXML theme script tag (ISO 15924, except Korean uses `Hang`). */
+    script: string;
+    heading: string;
+    body: string;
+}
+interface ResolveScriptFontsOptions extends CatalogOptions {
+    /** Which language font default applies. Defaults to `powerpoint` (`language.fontScheme`, else the vocabulary default); `google-slides` prefers `language.googleFontScheme`. */
+    app?: ScriptFontApp;
+    /** Merge `slides[slideIndex].design` over the deck design, per field, before resolving the font scheme. */
+    slideIndex?: number;
+    /** Language to resolve instead of the document's `language` (a BCP-47 tag or a Language object). */
+    language?: unknown;
+    /** Language tag used when neither the document nor `options.language` names a resolvable language. Defaults to `en-US`. */
+    defaultLanguage?: string;
+}
+interface ResolvedScriptFonts extends ScriptFontSlots {
+    /**
+     * Tag for OOXML `a:rPr/@lang` (and `a:endParaRPr/@lang`): an authored tag that carries a region,
+     * else the curated `ooxmlLang` of the language vocabulary, else the canonical BCP-47 tag.
+     */
+    lang: string;
+    /** Canonically cased BCP-47 tag for HTML/SVG `lang`: the authored tag. */
+    bcp47: string;
+    /** `default` when the tag came from `defaultLanguage` because no language resolved. */
+    languageSource: "document" | "option" | "default";
+    /** ISO 15924 script (`Zzzz` when it cannot be determined). */
+    script: string;
+    /** Script slot the language's own text uses. */
+    scriptRole: ScriptRole;
+    direction: "ltr" | "rtl";
+    rtl: boolean;
+    /** Major (heading) theme font slots. */
+    heading: ScriptFontSlots;
+    /** Minor (body) theme font slots. The top-level latin/eastAsian/complexScript repeat these. */
+    body: ScriptFontSlots;
+    /**
+     * Supplemental theme font for the language's script. Present only when an explicit slot, the
+     * design scheme's own script family or the language's font scheme supplies one; absent for
+     * Latin, Cyrillic, Greek and for scripts with no script font. For Armenian, Georgian and
+     * Ethiopic (latin slot) an explicit `complexScript` slot or a design `cs` scheme that serves the
+     * language replaces the language's own font scheme.
+     */
+    supplement?: ScriptFontSupplement;
+    sources: {
+        eastAsian: ScriptFontSource;
+        complexScript: ScriptFontSource;
+    };
+}
+
+/** The OOXML script slot for an ISO 15924 script code. Unknown scripts use the latin slot. */
+declare function scriptFontRole(script: string): ScriptRole;
+/**
+ * Resolve the per-script theme fonts, language tags and direction for a
+ * presentation (or a `{ design, language, catalogs }` subset of one).
+ *
+ * The latin slot follows the effective design font scheme exactly as
+ * `resolveFontFamilies` does; when nothing names a font scheme it falls back to
+ * the engine default font scheme. Each of the eastAsian and complexScript slots
+ * takes, in order: the design font scheme's explicit slot; the scheme's own
+ * families when its `languageFamily` names the slot and its `languages` list
+ * is empty or names the language; the language's font scheme when the
+ * language's script uses the slot; otherwise the latin family.
+ */
+declare function resolveScriptFonts(input: unknown, options?: ResolveScriptFontsOptions): ResolvedScriptFonts;
+/**
+ * The deck base direction composition lays a slide out in: the direction of the presentation language's script
+ * (`rtl` for Arabic, Hebrew and the other right-to-left scripts), `ltr` when the document names no language or
+ * the language does not resolve. Layout, preview and export all read this one value (RR-05).
+ */
+declare function resolveSlideDirection(presentation: unknown, slideIndex?: number): "ltr" | "rtl";
+
+/**
+ * Deterministic syntax highlighting shared by the SVG preview and the PPTX export (RR-07).
+ *
+ * `tokenizeCode(source, language)` returns coloured token ranges over the exact source
+ * string; everything between tokens is plain. `codeSyntaxPalette` derives one colour per
+ * token kind from the deck theme and keeps each at WCAG contrast >= 4.5:1 against the code
+ * panel. The scanner is a small hand-written one (no dependency, no network, no locale or
+ * clock input): it recognises comments, strings, numbers, keywords, definition names, calls,
+ * capitalised types and the structure of JSON, YAML, TOML, HTML/XML and CSS. It never edits
+ * the text: callers colour ranges of `code.source` and the concatenated runs equal the source.
+ * An unknown or missing language yields no tokens (plain text).
+ */
+type CodeTokenKind = 'comment' | 'keyword' | 'string' | 'number' | 'function' | 'type' | 'property';
+interface CodeToken {
+    start: number;
+    end: number;
+    kind: CodeTokenKind;
+}
+/** A slice of one source line: `kind` is absent for plain text. */
+interface CodeRun {
+    start: number;
+    end: number;
+    kind?: CodeTokenKind;
+}
+type CodeSyntaxPalette = Record<CodeTokenKind | 'plain', string>;
+/** Source longer than this is left plain: highlighting must stay bounded. */
+declare const CODE_HIGHLIGHT_MAX_LENGTH = 200000;
+/** Contrast the palette keeps against the code panel. */
+declare const CODE_SYNTAX_MIN_CONTRAST = 4.5;
+/** The code panel colour the preview and the PPTX export both draw. */
+declare const CODE_PANEL_BACKGROUND = "#111827";
+declare const CODE_PANEL_FOREGROUND = "#E5E7EB";
+/** Language ids with a scanner (the keys the aliases resolve to). */
+declare const CODE_HIGHLIGHT_LANGUAGES: readonly string[];
+/** The scanner id for a `code.language` value, or undefined when the language is not highlighted. */
+declare function resolveCodeLanguage(language: unknown): string | undefined;
+/**
+ * Token ranges of `source` for a `code.language` value, sorted and non-overlapping. Empty for
+ * an unknown language, a missing language, or source longer than CODE_HIGHLIGHT_MAX_LENGTH.
+ */
+declare function tokenizeCode(source: string, language?: unknown): CodeToken[];
+/**
+ * The runs of one source line `[start, end)`: consecutive slices that cover the line exactly.
+ * A token that crosses the line boundary is clipped, so each native text line can be coloured
+ * on its own while concatenating the runs returns the line text unchanged. With `source`, a tab
+ * character is always its own plain run, as in the preview where a tab is a measured segment: a
+ * token (a multi-line string, say) never colours a tab stop.
+ */
+declare function codeLineRuns(tokens: readonly CodeToken[], start: number, end: number, source?: string): CodeRun[];
+interface CodeSyntaxPaletteOptions {
+    background?: string;
+    foreground?: string;
+    minimumContrast?: number;
+}
+interface CodeSyntaxPaletteTheme {
+    primary?: string;
+    secondary?: string;
+    accent?: string;
+    mutedText?: string;
+}
+/**
+ * One colour per token kind from the deck theme: keyword = primary, string = accent,
+ * number = secondary, comment = a fixed slate; function, type and property take fixed hues
+ * (blue, cyan, pink) rotated away from any theme colour they would collide with. Every
+ * colour is lightened until it keeps `minimumContrast` (4.5:1) against the code panel, so a
+ * dark theme colour is raised rather than dropped. Deterministic for a given theme.
+ */
+declare function codeSyntaxPalette(theme?: CodeSyntaxPaletteTheme, options?: CodeSyntaxPaletteOptions): CodeSyntaxPalette;
+/**
+ * The palette for a resolved colour scheme record (`primary`, `secondary`, `accent`, or the
+ * `accent1` to `accent3` slots they default to). The preview and the PPTX export both call this
+ * with the scheme they resolved, so they cannot disagree on the inputs.
+ */
+declare function codeSyntaxPaletteForScheme(scheme: unknown, options?: CodeSyntaxPaletteOptions): CodeSyntaxPalette;
+
+/**
+ * Timeline event status (FA-11): how a `done`, `current` or `planned` event looks in the SVG
+ * preview and in the PPTX export. Core's timeline layout places the markers and the text and
+ * records each event's status on them (see `TimelineLayout.markers` and `TimelineTextPart.status`).
+ * This derives, from that geometry and the deck's colors, the shapes and text colors to draw, so
+ * both engines draw the same marker in the same place and colors.
+ *
+ * - no status, `done`: a filled marker in the primary color, normal text (today's marker).
+ * - `current` ("we are here"): the same filled marker inside a ring, and the label is bold
+ *   (layout sets the weight, so the measured line breaks already include it).
+ * - `planned`: a hollow marker (primary-color outline over the slide background) and muted text.
+ *
+ * Text colors are kept at 4.5:1 against the slide background, outlines and rings at 3:1.
+ */
+
+declare const TIMELINE_STATUSES: readonly ["done", "current", "planned"];
+declare const TIMELINE_TEXT_MIN_CONTRAST = 4.5;
+declare const TIMELINE_OUTLINE_MIN_CONTRAST = 3;
+interface TimelineStatusColors {
+    /** The slide background the timeline sits on. */
+    background: string;
+    /** The marker color (the deck's primary color). */
+    primary: string;
+    /** The color of normal timeline text. */
+    text: string;
+    /** The muted color of planned events' text (the deck's secondary text). */
+    mutedText: string;
+}
+interface TimelineMarkerShape {
+    /** `marker` is the event's dot (or hollow circle), `ring` the circle around a current event's dot. */
+    role: 'marker' | 'ring';
+    /** DrawingML preset name for native export. */
+    shape: 'ellipse';
+    cx: number;
+    cy: number;
+    /** Radius of the drawn ellipse (the marker's `radius`, or the ring's `ring.radius`, 1.6 times it). An outline is centered on the edge, so it reaches half its width beyond. */
+    radius: number;
+    /** Fill color; undefined means no fill (nothing draws inside the shape). */
+    fill?: string;
+    /** Outline; undefined means no outline. */
+    stroke?: {
+        color: string;
+        width: number;
+    };
+}
+/** The shapes of one marker from `layout.markers`, back to front: the ring (current only), then the marker. */
+declare function timelineMarkerShapes(marker: TimelineLayout['markers'][number], colors: TimelineStatusColors): TimelineMarkerShape[];
+/** The color of one timeline text part: muted for a planned event, the normal text color otherwise, kept at >= 4.5:1. */
+declare function timelineTextColor(part: Pick<TimelineTextPart, 'status'>, colors: TimelineStatusColors): string;
+
+/**
+ * Line emphasis for code blocks (`code.highlight`), shared by the SVG preview, the PPTX export and the
+ * validator so they cannot disagree.
+ *
+ * `code.highlight` lists 1-based source lines: a line number or an inclusive `[start, end]` range.
+ * Lines are counted by line break in `code.source`, so a soft-wrapped line is still one line and every
+ * displayed line of it takes the same number (`codeLineNumbers`). Engines draw one band behind each
+ * run of marked displayed lines (`codeHighlightBands`) and set the unmarked lines in a slightly dimmed
+ * colour (`codeHighlightColors`); both colour sets keep WCAG contrast >= 4.5:1 against what they sit on.
+ * Everything here is deterministic: no clock, locale or network.
+ */
+
+/** One `code.highlight` entry: a line number or an inclusive `[start, end]` range. */
+type CodeHighlightEntry = number | [number, number];
+interface CodeHighlightIssue {
+    code: 'code-highlight-out-of-range' | 'code-highlight-range-reversed' | 'code-highlight-invalid';
+    /** Index of the entry in `code.highlight`. */
+    index: number;
+    message: string;
+}
+interface CodeHighlightLines {
+    /** Lines in the source (a final empty line after a trailing line break is not counted). */
+    lineCount: number;
+    /** The marked lines inside the source, ascending and unique. Empty when nothing is marked. */
+    lines: number[];
+    /** Entries that are ignored: past the last line, written end before start, or not line numbers. */
+    issues: CodeHighlightIssue[];
+}
+/** Resolve `code.highlight` against its source: the marked lines, and the entries that are ignored. */
+declare function codeHighlightLines(highlight: unknown, source: string): CodeHighlightLines;
+/** The source line number (from 1) of every displayed line; wrapped lines repeat their line's number. */
+declare function codeLineNumbers(sourceLines: readonly {
+    boundary: 'soft' | 'hard' | 'end';
+}[]): number[];
+/** A run of consecutive displayed lines (indexes into `sourceLines`, inclusive) whose source lines are marked. */
+interface CodeHighlightBand {
+    first: number;
+    last: number;
+}
+/** One band per run of consecutive displayed lines that belong to a marked line. */
+declare function codeHighlightBands(sourceLines: readonly {
+    boundary: 'soft' | 'hard' | 'end';
+}[], lines: readonly number[]): CodeHighlightBand[];
+interface CodeHighlightColors {
+    /** The band behind marked lines: the panel colour tinted with the theme's primary colour. */
+    band: string;
+    /** Marked lines: the syntax palette, each colour at least 4.5:1 on `band`. */
+    lit: CodeSyntaxPalette;
+    /** Unmarked lines: the syntax palette moved toward the panel, never below 4.5:1 on it. */
+    dim: CodeSyntaxPalette;
+}
+/**
+ * The highlight colours for a resolved colour scheme record. The band takes the scheme's `primary`
+ * (or `accent1`); the palette is `codeSyntaxPaletteForScheme(scheme)` so highlighted lines keep their syntax
+ * colours. Preview and export call this with the scheme they resolved.
+ */
+declare function codeHighlightColors(scheme: unknown, palette?: CodeSyntaxPalette): CodeHighlightColors;
+
+/**
+ * Geometry of a text watermark (`design.watermark = { text, opacity }`), shared by the SVG preview and the
+ * PPTX export so both draw the same stamp.
+ *
+ * The stamp is one line of text, centered on the slide and rotated 30 degrees counterclockwise (rising to
+ * the right), the usual diagonal DRAFT or CONFIDENTIAL mark. It is sized so the line spans at most 70% of the
+ * slide width and its height is at most 30% of the shorter slide edge, which keeps the rotated line inside
+ * every preset from 9:16 portrait to 16:9 widescreen.
+ */
+
+interface WatermarkTextOptions {
+    /** The heading family of the design. Defaults to `sans-serif`. */
+    fontFamily?: string;
+    /** Defaults to 700. */
+    fontWeight?: number;
+    textMeasurement?: TextMeasurement;
+}
+interface WatermarkTextLayout {
+    /** The text as drawn: line breaks become spaces and the ends are trimmed. */
+    text: string;
+    fontFamily: string;
+    fontWeight: number;
+    /** The resolved text style (the host's font registry may rename the family). */
+    style: TextStyle;
+    /** In the unit of the size passed in (reference pixels for a composed slide). */
+    fontSize: number;
+    /** Measured width of the line at `fontSize`. */
+    textWidth: number;
+    /** The unrotated text box, centered on the slide; PPTX rotates it about its center. */
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Rotation about the slide center in degrees, clockwise positive. */
+    rotation: number;
+}
+/** Lay out a text watermark on a slide of `size`; undefined when the text is empty. */
+declare function layoutWatermark(text: unknown, size: {
+    width: number;
+    height: number;
+}, options?: WatermarkTextOptions): WatermarkTextLayout | undefined;
+
+/**
+ * DrawingML preset pattern fills (ECMA-376 20.1.10.51 ST_PresetPatternVal) as 8x8 bitmaps,
+ * shared by the SVG preview (RR-07) and the PPTX export, which writes the same names as native
+ * `a:pattFill prst="..."`.
+ *
+ * ECMA-376 names the 54 presets but does not define their pixels. These tiles are MEASURED from
+ * desktop PowerPoint (Office 365, Windows, 2026-10-01): each preset was exported as a full-slide
+ * pattern background (black on white) to a 1280 x 720 PNG and opf-render's
+ * `scripts/derive-pattern-bitmaps.mjs` voted every pixel into its (x mod 8, y mod 8) cell; every
+ * tile was uniform across all repeats (confidence 1.00) at one image pixel per pattern pixel, so a
+ * pattern pixel is one 1/96 inch unit. The tile is anchored at the slide's top-left corner (the
+ * phase of the line, grid and diagonal presets matched at no shift). Measured pixel data is
+ * committed as data; no third-party table was used. A tile is one row per line, '#' = foreground,
+ * '.' = background, top to bottom, left to right.
+ */
+/** ST_PresetPatternVal, in specification order. */
+declare const PATTERN_PRESETS: readonly string[];
+/** Engine ids that are not DrawingML names, with the preset they draw and export as. */
+declare const PATTERN_PRESET_ALIASES: Readonly<Record<string, string>>;
+/** The pattern size PowerPoint tiles: 8 x 8 units, one unit per 1/96 inch. */
+declare const PATTERN_TILE_SIZE = 8;
+/** The DrawingML preset a pattern id draws as: a preset name, an alias (diagStripe), or undefined. */
+declare function resolvePatternPreset(preset: unknown): string | undefined;
+/** Eight row bytes, top to bottom, most significant bit = leftmost pixel; undefined for an unknown id. */
+declare function patternBitmap(preset: unknown): readonly number[] | undefined;
+/** Horizontal runs of set pixels (`x`, `y`, `width` in tile units), in reading order. */
+declare function patternRuns(preset: unknown): {
+    x: number;
+    y: number;
+    width: number;
+}[] | undefined;
 
 /**
  * Footnotes, citations and captions (RR-34).
  *
  * - A TextRun may `cite` one or more ids of the deck's top-level `references`, or carry an inline
- *   `footnote`. Markers are numbered per deck in reading order of first use (slides, then regions,
+ *   `footnote`. Markers are numbered per deck in reading order of first use (slides: the heading group tag, title, subtitle, then regions,
  *   blocks and runs); the same reference id keeps its number, every footnote takes a new one. A run's
  *   marker is a superscript fragment drawn directly after the run (`1`, or `1,2` for several ids);
  *   `richTextLayouter` emits it from `RichTextOptions.citationMarker`, so it wraps with its word and
@@ -345,8 +981,9 @@ interface AnnotatedRun {
     footnote?: RichText;
 }
 /**
- * Visit every rich-text run of a slide that can carry a citation (text, bullets and list item runs),
- * in reading order: promoted regions (sorted keys), then blocks (recursively), then the root payload.
+ * Visit every rich-text run of a slide that can carry a citation (the slide tag, title and subtitle, then
+ * text, bullets, list item and quote runs), in reading order: the heading group first (tag, title, subtitle),
+ * then promoted regions (sorted keys), then blocks (recursively), then the root payload.
  * `basePath` is the slide's dotted path (`slides.3`).
  */
 declare function walkCitationRuns(slide: unknown, basePath: string, visit: (entry: AnnotatedRun) => void): void;
@@ -490,7 +1127,8 @@ interface ReferencesSlideOptions {
 declare function referencesSlide(presentation: unknown, options?: ReferencesSlideOptions): Record<string, unknown>;
 
 /** The chart constructs the engines draw. Every catalog chart type id resolves to one (see `chartOptionTarget`). */
-type ChartOptionKind = 'bar' | 'line' | 'area' | 'pie' | 'doughnut' | 'scatter' | 'radar' | 'treemap' | 'histogram' | 'pareto' | 'box' | 'waterfall' | 'funnel' | 'map';
+/** `combo` (FA-15) draws clustered columns and line series in one plot, the lines optionally on a secondary value axis. */
+type ChartOptionKind = 'bar' | 'line' | 'area' | 'pie' | 'doughnut' | 'scatter' | 'radar' | 'treemap' | 'histogram' | 'pareto' | 'box' | 'waterfall' | 'funnel' | 'map' | 'combo';
 interface ChartOptionTarget {
     kind: ChartOptionKind;
     /** Stacked and 100% stacked columns, bars, lines and areas: their data labels have no outside-end position. */
@@ -501,7 +1139,7 @@ type ChartLabelContent = 'category' | 'value' | 'percent';
 type ChartLabelPosition = 'center' | 'inside-end' | 'inside-base' | 'outside-end' | 'above' | 'below' | 'left' | 'right';
 interface ChartOptionDiagnostic {
     code: 'chart-option-adapted';
-    /** The option that was adapted: `axisTitles.category`, `axisTitles.value`, `legend`, `dataLabels`, `dataLabels.content`, `dataLabels.position` or `dataLabels.separator`. */
+    /** The option that was adapted: `axisTitles.category`, `axisTitles.value`, `axisTitles.secondary`, `legend`, `dataLabels`, `dataLabels.content`, `dataLabels.position`, `dataLabels.separator`, `line`, `secondaryAxis`, `highlight.series` or `highlight.categories`. */
     option: string;
     reason: 'unsupported-type' | 'unsupported-content' | 'unsupported-position';
     message: string;
@@ -509,34 +1147,57 @@ interface ChartOptionDiagnostic {
 interface ResolvedChartDataLabels {
     /** Canonical order: category, value, percent. Never empty. */
     content: ChartLabelContent[];
-    /** The concrete position, or null for a construct whose labels have no position choice (area, doughnut, radar, treemap). */
+    /** The concrete position, or null for a construct whose labels have no position choice (area, doughnut, radar, treemap). On a combo chart, the column series' position. */
     position: ChartLabelPosition | null;
+    /** Combo charts only: the concrete position of the line series' labels (`position` is the column series' one). */
+    linePosition?: ChartLabelPosition;
     separator: string;
 }
+/** FA-14: the series and category names `chart.highlight` keeps for a chart type (what the type cannot highlight is dropped, with a diagnostic). */
+interface ResolvedChartHighlight {
+    /** Series (column) names whose marks take the accent colour. */
+    series: string[];
+    /** Category (row label) names whose marks take the accent colour. */
+    categories: string[];
+}
 interface ResolvedChartOptions {
     /** True when the chart carries at least one option (after adaptation); false means every engine keeps today's output. */
     active: boolean;
+    /** `secondary` titles the secondary value axis of a combo chart. */
     axisTitles: {
         category?: string;
         value?: string;
+        secondary?: string;
     };
     /** Undefined = no legend option: each engine keeps its default (a right legend on multi-series, pie and doughnut charts). */
     legend?: ChartLegendPosition;
     dataLabels?: ResolvedChartDataLabels;
     /** True when `dataLabels: false` switches off the labels a construct draws by default (funnel values, treemap category names). */
     dataLabelsOff?: boolean;
+    /**
+     * FA-14: the names `chart.highlight` keeps; undefined when the chart has no highlight or its type can highlight nothing it names.
+     * It does not make `active` true: a highlight changes the colours of marks, never the geometry or the reserved space.
+     */
+    highlight?: ResolvedChartHighlight;
     diagnostics: ChartOptionDiagnostic[];
 }
 interface ChartOptionSupport {
+    /** `secondary`: the construct can have a secondary value axis (a combo chart whose `secondaryAxis` names a line series). */
     axisTitles: {
         category: boolean;
         value: boolean;
+        secondary: boolean;
     };
     legend: boolean;
+    /** FA-14: what `chart.highlight` can name: series (a whole series' marks) and categories (one category's marks, or a pie slice). */
+    highlight: {
+        series: boolean;
+        categories: boolean;
+    };
     dataLabels: {
         supported: boolean;
         content: readonly ChartLabelContent[];
-        /** Empty when labels have no position choice. */
+        /** Empty when labels have no position choice. A combo chart lists the column positions, then the line-only ones. */
         positions: readonly ChartLabelPosition[];
         /** The position `auto` resolves to; null with no positions. */
         defaultPosition: ChartLabelPosition | null;
@@ -546,7 +1207,7 @@ interface ChartOptionSupport {
 }
 /** What a chart construct can show. The table the docs, the validator, the preview and the exporter all follow. */
 declare function chartOptionSupport(target: ChartOptionTarget): ChartOptionSupport;
-/** The option target for a catalog chart type id (deprecated ids resolve to their replacement); undefined for an id outside the catalog. */
+/** The option target for a catalog chart type id; undefined for an id outside the catalog. */
 declare function chartOptionTarget(typeId: unknown): ChartOptionTarget | undefined;
 declare const DEFAULT_CHART_LABEL_SEPARATOR = ", ";
 /**
@@ -564,6 +1225,53 @@ declare function chartLabelText(parts: {
     value?: string;
     percent?: string;
 }, content: readonly ChartLabelContent[], separator?: string): string;
+/** Which marks of a chart a highlight names, in the order of the resolved chart data. */
+interface ChartHighlightMarks {
+    /** One flag per plotted series (the columns after the category and X columns): its marks are highlighted. */
+    series: boolean[];
+    /** One flag per data row: the marks of that category are highlighted. */
+    categories: boolean[];
+}
+/**
+ * FA-14: which series and categories of a chart are highlighted. `highlight` is `resolveChartOptions(...).highlight` and `data` the
+ * chart's `resolveChartData` result (its `columns`, `hasX` and `rows`). A mark is highlighted when its series OR its category is
+ * named: a column or bar of series s in row i takes the accent colour when `series[s] || categories[i]`; every other mark takes the muted
+ * colour (`chartHighlightColors`). Category names match the row labels as text (a number label `2024` matches `"2024"`, an empty label
+ * matches `""`), every row that carries the label. Returns undefined when there is no highlight or it names nothing the chart plots (a
+ * name that matches no column or label is the `chart-highlight-unknown-name` validation error), so the engines then draw the chart as if
+ * it had none.
+ */
+declare function chartHighlightMarks(highlight: ResolvedChartHighlight | undefined, data: {
+    columns: readonly string[];
+    hasX?: boolean;
+    rows: readonly (readonly unknown[])[];
+}): ChartHighlightMarks | undefined;
+
+/** Placeholder kinds that hold slide content (everything except the three heading kinds). */
+declare const LAYOUT_BODY_KINDS: readonly ["text", "list", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
+type LayoutBodyKind = typeof LAYOUT_BODY_KINDS[number];
+/** What a layout record holds, derived from its placeholders. */
+interface LayoutContent {
+    /** The most frequent body placeholder kind (a tie goes to the kind that appears first in placeholder order), or 'title' when the layout has no body placeholder. */
+    kind: LayoutBodyKind | 'title';
+    /** The number of body placeholders. */
+    count: number;
+    /** Which heading placeholders the layout has. */
+    heading: {
+        title: boolean;
+        subtitle: boolean;
+        tag: boolean;
+    };
+}
+/**
+ * Derives what a layout holds from its `placeholders`, which are the single source of truth: the content kind,
+ * the number of body regions and which headings it has are never stored on the record.
+ */
+declare function layoutContent(record: {
+    placeholders?: ReadonlyArray<{
+        type?: string;
+    } | null | undefined>;
+} | null | undefined): LayoutContent;
 
 /** Portable layout geometry. No fonts, DOM, renderer, or network dependencies. */
 interface Composition {
@@ -599,6 +1307,8 @@ interface TextStyle {
     italic?: boolean;
     path?: string;
     fontFace?: FontFaceSelection;
+    /** BCP-47 tag of a run that overrides the deck language (`TextRun.lang`); absent when the deck language applies. */
+    lang?: string;
 }
 /** Role families. `accent` is present only when the scheme defines an accent role; the slide tag and quote body use it. */
 interface FontFamilies {
@@ -607,37 +1317,11 @@ interface FontFamilies {
     code: string;
     accent?: string;
 }
-/** Shared last-resort font-scheme id when neither the slide, the deck nor the resolved theme names one.
- * One default for every engine, so preview matches export (font-fidelity-everywhere owner decision). */
-declare const DEFAULT_FONT_SCHEME = "aptos";
-/** Reported when a font-scheme id matches no inline or bundled record. Every engine then uses the
- * DEFAULT_FONT_SCHEME record as the base, with any sibling overrides on top. */
-interface FontSchemeDiagnostic {
-    code: "unresolved-font-scheme";
-    /** Where the unresolved id is written: `slides.N.design.fontScheme`, `design.fontScheme`, or the
-     * `design.theme` reference whose record names it. */
-    path: string;
-    message: string;
-    /** The unresolved font-scheme id. */
-    id: string;
-    /** The font scheme used instead (DEFAULT_FONT_SCHEME). */
-    fallback: string;
-}
-interface ResolvedFontScheme {
-    scheme: Record<string, unknown>;
-    diagnostic?: FontSchemeDiagnostic;
-}
-/** Resolve a font-scheme reference the same way in every engine. A string id, or the `id` of an object
- * reference, resolves through `lookup` (inline records, then bundled or host catalogs). An unresolved id
- * returns a diagnostic, and the DEFAULT_FONT_SCHEME record becomes the base, so preview and export use
- * the same families. An object without `id` is an inline scheme on the same base. Sibling fields on an
- * object reference override the base per key. */
-declare function resolveFontSchemeReference(reference: unknown, lookup: (id: string) => unknown, path?: string): ResolvedFontScheme;
-/** Resolve role families from an already-merged font scheme (catalog record plus design overrides).
- * A scheme that names no heading or body family gets the DEFAULT_FONT_SCHEME families (Aptos Display, Aptos).
+/** Resolve role families from an already-merged font scheme (the resolved record plus design overrides).
+ * A scheme that names no heading or body family gets the engine default families (Aptos Display, Aptos).
  * `code` comes from the scheme's `code` role, which catalog records such as consolas and courier-new
  * carry; otherwise it is Roboto Mono. Heading and body families are never reused for code.
- * `accent` is returned only when the scheme defines an `accent` role (a family string or Font object);
+ * `accent` is returned only when the scheme defines an `accent` role (a family name string);
  * the slide tag and the quote body use it in place of the body and heading families. */
 declare function resolveFontFamilies(input: unknown): FontFamilies;
 interface TextMeasurement {
@@ -647,6 +1331,14 @@ interface TextMeasurement {
      * Null means no outline. These are not hinted/antialiased raster bounds. */
     outlineBounds?: (text: string, fontSize: number, style: TextStyle) => LayoutBox | null;
 }
+/**
+ * The fonts handle every deck-level verb takes as `{ fonts }`. Core reads only `textMeasurement`: how wide the
+ * host's real fonts draw a string. The renderer's `loadFonts()` returns a richer handle (embedded fonts, font
+ * files, registry, manifest) that extends this one, so the same object goes to every verb.
+ */
+interface Fonts {
+    textMeasurement?: TextMeasurement;
+}
 type MeasureTextWidth = (text: string, fontSize: number) => number;
 declare function resolveTextStyle(style: TextStyle, measurement?: TextMeasurement): TextStyle;
 declare function textWidthMeasurer(style: TextStyle, measurement?: TextMeasurement): MeasureTextWidth;
@@ -721,47 +1413,96 @@ interface ComposedItem {
      * the media box after the band is reserved; `caption.box` is the band inside the same region.
      */
     caption?: ComposedCaption;
+    /** Picture geometry and treatments of an image item (`field` image); absent on every other item. */
+    image?: ComposedImage;
     /** Effective container settings, including inherited readability constraints. */
     composition: Composition;
     /**
      * Resolved horizontal text alignment for this item: titleAlignment for the
-     * title, contentAlignment for every other item (slide design, then host
-     * option, then left). Engines anchor native and preview text to this value.
+     * title, contentAlignment for every other item (slide design, deck design, layout design,
+     * then left). Engines anchor native and preview text to this value.
      */
     alignment: 'left' | 'center' | 'right';
 }
+/** How a picture fills its frame: cover crops around the focus, contain shows all of it, stretch scales it to the frame. */
+type ImageFit = 'cover' | 'contain' | 'stretch';
+/** A background also tiles: the picture repeats at its own size from the canvas's top-left corner. */
+type BackgroundImageFit = ImageFit | 'tile';
+/** A slide or frame edge, physical (already mirrored in a right-to-left deck). */
+type ImageEdge = 'left' | 'right' | 'top' | 'bottom';
+/** A point of a picture as fractions of its width and height from the top-left corner; the default is { x: 0.5, y: 0.5 }. */
+interface ImageFocus {
+    x: number;
+    y: number;
+}
+/** A frame mask. path follows the ECMA-376 preset formula for preset/adjust exactly, in reference pixels. */
+interface ImageShape {
+    kind: 'rectangle' | 'rounded' | 'circle' | 'hexagon';
+    preset: 'rect' | 'roundRect' | 'ellipse' | 'hexagon';
+    /** DrawingML avLst guide values (for example adj and vf), in 1/100000 units. */
+    adjust: Record<string, number>;
+    path: string;
+}
+/** One overlay, shared by image backgrounds and image blocks: drawn directly above its picture, beneath content. */
+interface ComposedOverlay {
+    /** OPF path of the overlay value, for example `slides.3.design.background.overlay` or `slides.3.blocks.0.overlay`. */
+    path: string;
+    /** ColorRef as authored (hex, eight-digit hex alpha, scheme slot or role, `var:<id>`); engines resolve it. */
+    color: unknown;
+    /** Fill opacity, 0 to 1, multiplied with any eight-digit hex alpha. */
+    opacity: number;
+    /** Physical edge of a band overlay; absent when the overlay covers the whole frame. */
+    edge?: ImageEdge;
+    /** Area covered: the whole frame, or the edge band. */
+    box: LayoutBox;
+    /** Outline to fill: the frame's shape for a whole-frame overlay, a rectangle for a band. */
+    shape: ImageShape;
+}
+/** Where the whole picture lands for a fit, for a picture whose aspect ratio is known (see `fitImage`). */
+interface ImageFitPlacement {
+    /** The whole picture's rectangle in slide coordinates: past the frame for cover, inside it for contain, the frame for stretch. */
+    image: LayoutBox;
+    /** DrawingML srcRect insets as fractions of the picture (positive crops, negative pads); all 0 for stretch. */
+    crop: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+}
+/** A placed image block's band (FA-22): the image bleeds to `edge` and the rest of the slide composes beside it. */
+interface ComposedPlacement {
+    /** Physical edge: in a right-to-left deck an authored `left` (the start side) is `right` here. */
+    edge: ImageEdge;
+    /** Share of the slide width (left, right) or height (top, bottom), 0.1 to 0.9. */
+    size: number;
+    /** True when the frame sits inside the slide padding instead of edge to edge. */
+    inset: boolean;
+    /** Where the placement is written: `slides.N.blocks.I.placement`, or `layout.placeholders.P.placement` for a layout image placeholder's. */
+    path: string;
+}
 /**
- * Slide-level image resolved from design.slideImage. It is active when the slide sets its own
- * design.slideImage, or when the deck sets one and either the slide's layout record declares
- * slideImage: true or the slide's root image is the same source.
- * Content composes in the part of the slide the image does not occupy; 'background' leaves the whole slide.
+ * Resolved picture geometry of an image item (FA-22): every composed item with `field` 'image' carries one. Engines
+ * draw the picture in `box` with `fit` and `focus`, clipped to `shape`, with `recolor` and `opacity` on its pixels
+ * only, then the `border` on the shape outline, then the `overlay`. This is the paint order and the treatment code
+ * 0.14's slide image used.
  */
-interface ComposedSlideImage {
-    /** The design value that configured the image: 'design.slideImage' or 'slides.N.design.slideImage'. */
-    path: string;
-    /** Path of the drawn asset value: the design value, or the slide's root image payload it replaced. */
-    sourcePath: string;
-    /** Asset value (string or Asset object) that engines resolve like any other image. */
-    value: unknown;
-    position: 'background' | 'top' | 'bottom' | 'left' | 'right';
-    /** crop covers the frame (centered); fit shows the whole image centered inside it. */
-    fill: 'crop' | 'fit';
-    /** Band allocated to the image. */
+interface ComposedImage {
+    /** Allocated region, equal to the item's box: the flow cell (after any card padding and caption band) or the placement band. */
     region: LayoutBox;
-    /** Image frame inside the region. */
+    /** Picture frame inside the region: the band inside the slide padding for an inset placement, then the largest centered box with `aspectRatio` (a circle uses 1). */
     box: LayoutBox;
-    /** True when the slide's root image payload became this slide image instead of a content item. */
-    replacesContent: boolean;
-    /** Treatment alt text; engines fall back to the asset's own alt text. */
-    alt?: string;
+    /** The block's own fit, else the effective design.imageFit, else cover. */
+    fit: ImageFit;
+    focus: ImageFocus;
     /** Mask on the frame: a DrawingML preset with its guide values, and the same outline as an SVG path. */
-    shape: SlideImageShape;
-    /** Line centered on the shape outline; width in reference pixels (already scaled to the canvas). */
+    shape: ImageShape;
+    /** Line centered on the shape outline; width in reference pixels, already scaled to the canvas. */
     border?: {
         color: unknown;
         width: number;
     };
-    /** Image opacity below 1; the border and overlay are not affected. */
+    /** Picture opacity below 1; the border and overlay are not affected. */
     opacity?: number;
     /** Luminance-based recolor (Rec. 601 weights on sRGB values). */
     recolor?: {
@@ -771,21 +1512,41 @@ interface ComposedSlideImage {
         dark: unknown;
         light: unknown;
     };
-    /** Scrim over the frame (same shape) or over an edge band of a rectangle frame. */
-    overlay?: {
-        color: unknown;
-        opacity: number;
-        box: LayoutBox;
-        shape: SlideImageShape;
-    };
+    overlay?: ComposedOverlay;
+    /** Present on a placed block: the band along a slide edge that `region` is. */
+    placement?: ComposedPlacement;
+    /** Present when core reads the picture's aspect ratio (a data URI, or an `asset:` reference to one); otherwise call `fitImage` with the host's. */
+    picture?: ImageFitPlacement;
 }
-/** A frame mask. path follows the ECMA-376 preset formula for preset/adjust exactly, in reference pixels. */
-interface SlideImageShape {
-    kind: 'rectangle' | 'rounded' | 'circle' | 'hexagon';
-    preset: 'rect' | 'roundRect' | 'ellipse' | 'hexagon';
-    /** DrawingML avLst guide values (for example adj and vf), in 1/100000 units. */
-    adjust: Record<string, number>;
+/**
+ * The slide's picture background (FA-22): the effective `design.background` (the slide's, then the deck's, then
+ * `ComposeSlideOptions.themeBackground`) when it is an image, in object form or as an image-source string. It fills
+ * the whole canvas behind everything and never moves content. Paint order: the colour scheme's default slide
+ * background, the picture (with `recolor` and `opacity` on its pixels), the overlay, then furniture and content.
+ */
+interface ComposedBackgroundImage {
+    /** Where the background is written: `slides.N.design.background`, `design.background`, or `theme` (ComposeSlideOptions.themeBackground). */
     path: string;
+    /** Image source as authored: `asset:<id>`, an https URL, a data URI or a relative path. */
+    src: string;
+    alt?: string;
+    fit: BackgroundImageFit;
+    focus: ImageFocus;
+    /** The whole canvas. */
+    box: LayoutBox;
+    /** Picture opacity below 1; the overlay keeps its own. */
+    opacity?: number;
+    /** Luminance-based recolor of the pixels (Rec. 601 weights on sRGB values), as on an image block. */
+    recolor?: {
+        type: 'grayscale';
+    } | {
+        type: 'duotone';
+        dark: unknown;
+        light: unknown;
+    };
+    overlay?: ComposedOverlay;
+    /** Present when core reads the picture's aspect ratio and the fit is not tile; otherwise call `fitImage` with the host's. */
+    picture?: ImageFitPlacement;
 }
 /** Which logo variant family a consumer asks for: the full lockup, a square mark, or a stacked lockup. */
 type LogoSlot = 'lockup' | 'icon' | 'stacked';
@@ -882,8 +1643,14 @@ interface SlideComposition {
     composition: Composition;
     /** Repeated furniture is measured separately from body pagination leaves. */
     furniture?: FurnitureLayout;
-    /** Active slide-level image; absent when design.slideImage does not apply to this slide. */
-    slideImage?: ComposedSlideImage;
+    /**
+     * Effective shared design hints of this slide: slide design, then deck design, then the layout record's design,
+     * per key. Renderers and exporters read titleAlignment, contentAlignment, contentBox and
+     * listBullet here instead of re-deriving them from the document; image items carry their resolved fit in `image.fit`.
+     */
+    design: ResolvedDesignHints;
+    /** Picture background of this slide; absent when the effective background is not an image. */
+    backgroundImage?: ComposedBackgroundImage;
     /** Deck logo on a cover or section slide; absent on content slides and when no logo resolves. */
     logo?: ComposedLogo;
     /**
@@ -902,14 +1669,18 @@ interface ComposeSlideOptions {
         design?: {
             header?: unknown;
             footer?: unknown;
-            slideImage?: unknown;
-            imageFill?: unknown;
+            background?: unknown;
+            imageFit?: unknown;
             logo?: unknown;
             contentDirection?: unknown;
             chartPrimary?: unknown;
             listBullet?: unknown;
+            titleAlignment?: unknown;
+            contentAlignment?: unknown;
+            contentBox?: unknown;
         };
         organization?: unknown;
+        speaker?: unknown;
         slides?: unknown;
         catalogs?: unknown;
         references?: unknown;
@@ -921,12 +1692,11 @@ interface ComposeSlideOptions {
      */
     darkBackground?: boolean;
     /**
-     * Host-resolved social-platform records for generated `socials` furniture.
-     * Inline `presentation.catalogs.socialPlatforms.records` take precedence. Hosts
-     * normally pass the bundled catalog; without a matching record a handle renders
-     * as its raw value, as the Socials contract specifies.
+     * The resolved theme's `background`, the lowest level of the background chain (the slide's design.background, then
+     * the deck's, then this). Only an image background produces geometry (`SlideComposition.backgroundImage`).
+     * `resolveSlideContext` passes it.
      */
-    socialPlatforms?: readonly SocialPlatformRecord[];
+    themeBackground?: unknown;
     /** One-based displayed number; source paths still use slideIndex. */
     slideNumber?: number;
     /** Displayed slide count for `{total}` in slideNumberFormat. Defaults to `presentation.slides.length`. */
@@ -936,7 +1706,7 @@ interface ComposeSlideOptions {
      * consults a clock; without this option a current date is reported as unresolved content.
      */
     date?: string;
-    fonts?: Partial<FontFamilies>;
+    fontFamilies?: Partial<FontFamilies>;
     /**
      * Deck base direction (RR-05). Defaults to the direction of the presentation language's script. In a right-to-left deck
      * composition mirrors the arrangement (the first column or `left` region is drawn at the right, slide images, logos and
@@ -944,12 +1714,12 @@ interface ComposeSlideOptions {
      * reports each paragraph's direction. Alignment stays logical: `left` is the start edge.
      */
     direction?: TextDirection;
-    /** Host-resolved alignment for shared content; slide design can override it. */
+    /** Deck-level alignment a host resolved itself. It ranks with `presentation.design`, above the layout record's design and below the slide's own design; hosts normally omit it because composition reads `presentation.design` and the layout. */
     contentAlignment?: 'left' | 'center' | 'right';
     titleAlignment?: 'left' | 'center' | 'right';
     /** Unscaled reference pixels around provided vector outlines; defaults to 1 for body text and 2 for furniture. Explicit values apply to both. */
     textRasterPadding?: number;
-    /** Host-resolved body cards. A slide's explicit design.contentBox overrides this value. */
+    /** Deck-level body cards a host resolved itself, ranked like contentAlignment. A slide's explicit design.contentBox overrides this value. */
     contentBox?: boolean;
     textMeasurement?: TextMeasurement;
     width?: number;
@@ -969,7 +1739,25 @@ declare class OPFCompositionError extends Error {
  * Outline of a DrawingML preset in a box, following the ECMA-376 presetShapeDefinitions formulas:
  * roundRect (adj; ss = min(w,h), radius = ss*adj/100000), ellipse, and hexagon (adj, vf).
  */
-declare function slideImageShape(kind: SlideImageShape['kind'], box: LayoutBox, cornerRadius?: number): SlideImageShape;
+declare function imageShape(kind: ImageShape['kind'], box: LayoutBox, cornerRadius?: number): ImageShape;
+/**
+ * The shared fit math every engine uses (FA-22). `aspect` is the picture's width / height. cover scales the picture
+ * to cover the frame and centers the focus point in the frame as far as the picture still covers it, so the focus
+ * point always stays in view ({0.5, 0.5} is a center crop, {0, 0} keeps the top-left corner). contain scales it to
+ * fit and centers it; stretch fills the frame exactly. Focus applies to cover only. `crop` holds the DrawingML
+ * srcRect insets as fractions of the picture: positive insets crop, negative insets pad.
+ */
+declare function fitImage(frame: LayoutBox, fit: ImageFit, aspect: number, focus?: ImageFocus): ImageFitPlacement;
+/** The background a value describes when it is an image: the object form, or an image-source string (a cover image). */
+declare function imageBackground(value: unknown): {
+    src: string;
+    alt?: string;
+    fit: BackgroundImageFit;
+    focus: ImageFocus;
+    opacity?: number;
+    recolor?: unknown;
+    overlay?: unknown;
+} | undefined;
 interface ResolveLogoOptions {
     /** Variant family to prefer; defaults to the full lockup. */
     slot?: LogoSlot;
@@ -993,7 +1781,7 @@ declare function resolveLogo(presentation: unknown, slide: unknown, options?: Re
 interface FurniturePartBase {
     kind: 'header' | 'footer';
     zone: 'left' | 'center' | 'right';
-    field: 'text' | 'image' | 'logo' | 'organization' | 'socials' | 'section' | 'slideNumber' | 'date';
+    field: 'text' | 'image' | 'logo' | 'organization' | 'speaker' | 'socials' | 'section' | 'slideNumber' | 'date';
     /** Literal field or controlling flag, with the actual inherited/local path. */
     path: string;
     /** String/asset source, when different from a generated field's flag. */
@@ -1027,21 +1815,12 @@ interface FurnitureTextExtras {
     fields?: FurnitureField[];
     links?: FurnitureSocialLink[];
 }
-/** Social-platform catalog fields used to format a profile. */
-interface SocialPlatformRecord {
-    id: string;
-    name?: string;
-    baseUrl?: string;
-    profileUrlPattern?: string;
-    companyUrlPattern?: string;
-    handlePrefix?: string;
-}
 interface SocialProfile {
     /** Single-line display text: the profile URL without an `https://` scheme, or the raw value. */
     text: string;
     /** Full http(s) URL when the value is one or its platform record formats one. */
     href?: string;
-    /** Whether a socialPlatforms record formatted a handle. */
+    /** Whether the platform's URL pattern formatted a handle. */
     resolved: boolean;
 }
 interface FurnitureSocialLink extends SocialProfile {
@@ -1051,11 +1830,11 @@ interface FurnitureSocialLink extends SocialProfile {
     sourcePath: string;
 }
 /**
- * Format one Socials value through its platform record, deterministically and
+ * Format one Socials value through the engine's social-platform vocabulary (SOCIAL_PLATFORMS), deterministically and
  * without network access. `owner` selects companyUrlPattern for organizations.
  * URLs pass through; unknown platforms and unformattable values stay raw.
  */
-declare function resolveSocialProfile(platform: string, value: string, records?: readonly SocialPlatformRecord[], owner?: 'organization' | 'speaker'): SocialProfile;
+declare function resolveSocialProfile(platform: string, value: string, owner?: 'organization' | 'speaker'): SocialProfile;
 interface FurnitureImagePart extends FurniturePartBase {
     type: 'image';
     image: unknown;
@@ -1091,9 +1870,12 @@ declare const FONT_SIZE_GRID_PER_PX = 75;
 declare function snapFontSizeDown(px: number): number;
 /** Smallest grid size not below `px`. Used for readability floors, so a floor is never undercut. */
 declare function snapFontSizeUp(px: number): number;
+/** `text` is a string or TextRun[] (FA-10); attribution, role and source stay plain strings. */
 interface QuoteContent {
-    text: string;
+    text: string | readonly (string | RichTextRun)[];
     attribution?: string;
+    role?: string;
+    photo?: unknown;
     source?: string;
 }
 /** Source and displayed-text ranges are half-open UTF-16 offsets. Added punctuation has no source range. */
@@ -1115,24 +1897,46 @@ interface QuoteTextPart {
     minFontSize: number;
     requestedStyle: TextStyle;
     style: TextStyle;
-    /** Absent when the available box is invalid; never fit against an invented one-pixel box. */
-    fit?: TextFit;
+    /**
+     * The displayed runs of a rich quote body (FA-10): the quote's TextRun[] with the quotation marks joined to its first and
+     * last run, so a run's index and a citation marker's position never shift. Absent for a string body and for the footer.
+     */
+    runs?: (string | RichTextRun)[];
+    /** Absent when the available box is invalid; never fit against an invented one-pixel box. A rich body reports a RichTextFit. */
+    fit?: TextFit | RichTextFit;
 }
 interface QuoteLayoutDiagnostic extends LayoutDiagnostic {
-    reason: 'invalid-part-box' | 'part-outside-cell' | 'text-fit' | 'part-overlap';
+    reason: 'invalid-part-box' | 'part-outside-cell' | 'text-fit' | 'part-overlap' | 'photo-fit';
     parts: QuoteTextPart['role'][];
 }
+/**
+ * The attributed person's headshot (FA-12): a circle at the start edge of the footer row, beside the
+ * attribution and role lines (the left in a left-to-right deck, the right in a right-to-left one). Its diameter is
+ * three times the footer font size, so it follows the text when the footer shrinks toward the readability floor.
+ */
+interface QuotePhoto {
+    /** Path of the photo value, `<quote path>.photo`. */
+    path: string;
+    /** Asset value (string or Asset object) that engines resolve like any other image; crop to cover the frame. */
+    value: unknown;
+    /** Square frame, in reference pixels. */
+    box: LayoutBox;
+    /** Circle mask: the `ellipse` DrawingML preset and the same outline as an SVG path, as an image block's shape 'circle'. */
+    shape: ImageShape;
+}
 interface QuoteLayout {
     algorithm: 'quote-flow-v1';
     textMeasurement: 'estimated' | 'provided';
     parts: QuoteTextPart[];
+    /** Present when the quote has a photo; absent otherwise, and then the layout is the footer-only layout. */
+    photo?: QuotePhoto;
     diagnostics: QuoteLayoutDiagnostic[];
     overflow: boolean;
 }
 interface QuoteLayoutOptions {
     /** Canvas short edge divided by 720. Insets retain the current 18 reference-pixel contract. */
     scale?: number;
-    fonts?: Partial<FontFamilies>;
+    fontFamilies?: Partial<FontFamilies>;
     /** Readability floor in reference pixels, before canvas scaling. */
     minFontSize?: number;
     overflow?: Composition['overflow'];
@@ -1140,6 +1944,8 @@ interface QuoteLayoutOptions {
     textMeasurement?: TextMeasurement;
     /** Deck direction; in a right-to-left deck every part fit reports its paragraphs' directions (RR-05). */
     direction?: TextDirection;
+    /** Marker text for a rich body run by its dotted path (`<path>.text.<runIndex>`); composeSlide supplies the deck numbering. */
+    citationMarker?: (runPath: string) => string | undefined;
 }
 /**
  * Allocate and measure quote body/footer space for composition, rendering and export. Callers must
@@ -1153,7 +1959,11 @@ interface MetricContent {
     unit?: string;
     delta?: string | number;
     trend?: 'up' | 'down' | 'flat';
+    /** Whether the change is good news; colours the trend arrow, trend word and delta text (see metricTrendColor). */
+    sentiment?: MetricSentiment;
 }
+/** The text fields of a metric, each laid out as its own part. `sentiment` is metadata, not text. */
+type MetricTextRole = Exclude<keyof MetricContent, 'sentiment'>;
 /** Ranges address String(sourceValue), not the numeric token spelling in serialized JSON. */
 interface MetricTextSource {
     path: string;
@@ -1162,7 +1972,7 @@ interface MetricTextSource {
     end: number;
 }
 interface MetricTextPart {
-    role: keyof MetricContent;
+    role: MetricTextRole;
     path: string;
     text: string;
     sources: MetricTextSource[];
@@ -1190,6 +2000,8 @@ interface MetricLayout {
     alignment: 'left' | 'center' | 'right';
     textMeasurement: 'estimated' | 'provided';
     arrangement: 'inline-unit' | 'stacked';
+    /** The metric's `sentiment`, passed through for metricTrendMark; omitted when the content has none. */
+    sentiment?: MetricSentiment;
     /** At most 48 arrangements; value fitting is bounded by 77 reference-size trials per arrangement. */
     attempts: number;
     parts: MetricTextPart[];
@@ -1208,10 +2020,13 @@ interface MetricLayoutOptions extends QuoteLayoutOptions {
  * beside it from these accepted parts. Consumers must reuse these accepted parts and source ranges.
  */
 declare function layoutMetric(value: string | number | MetricContent, box: LayoutBox, options?: MetricLayoutOptions): MetricLayout;
+/** Progress of a timeline event (FA-11). Engines draw it from the deck's colors; see `timelineMarkerShapes`. */
+type TimelineStatus = 'done' | 'current' | 'planned';
 interface TimelineEvent {
     when?: string;
     what: string;
     description?: string;
+    status?: TimelineStatus;
 }
 interface TimelineContent {
     name?: string;
@@ -1221,6 +2036,8 @@ interface TimelineContent {
 interface TimelineTextPart {
     role: 'name' | 'description' | 'when' | 'what' | 'event-description';
     eventIndex?: number;
+    /** The event's status; absent for metadata parts and for events without a status. */
+    status?: TimelineStatus;
     path: string;
     text: string;
     sources: {
@@ -1247,12 +2064,23 @@ interface TimelineLayout {
     textMeasurement: 'provided' | 'estimated';
     textOutlines: 'provided' | 'unavailable';
     parts: TimelineTextPart[];
+    /**
+     * One marker per event. `radius` is the marker's own radius; `status` repeats the event's status
+     * (absent without one). A 'current' marker also has `ring.radius`, 1.6 times `radius`, and a
+     * 'current' or 'planned' marker has the `strokeWidth` of its outline and ring. Every radius is that
+     * of the drawn ellipse; an outline is centered on the ellipse edge, so it reaches half a stroke beyond.
+     */
     markers: {
         path: string;
         eventIndex: number;
         x: number;
         y: number;
         radius: number;
+        status?: TimelineStatus;
+        ring?: {
+            radius: number;
+        };
+        strokeWidth?: number;
     }[];
     connector: {
         x1: number;
@@ -1347,6 +2175,10 @@ interface RichTextRun {
     link?: string;
     superscript?: boolean;
     subscript?: boolean;
+    /** Inline code: the run takes the design's code font (`RichTextOptions.codeFontFamily`) unless it names its own `fontFamily`. */
+    code?: boolean;
+    /** BCP-47 tag that overrides the deck language for this run; it reaches the fragment style as `style.lang`. */
+    lang?: string;
     /** RR-34: reference ids this run cites (a marker follows the run; the deck's `references` list resolves them). */
     cite?: string | string[];
     /** RR-34: an inline footnote for this run (a marker follows the run; the note is listed in the slide's footnote area). */
@@ -1385,6 +2217,8 @@ interface RichTextFit extends TextFit {
 }
 interface RichTextOptions {
     style: TextStyle;
+    /** The design's code family for runs with `code: true`; `monospace` when absent. */
+    codeFontFamily?: string;
     textMeasurement?: TextMeasurement;
     /** Use one measured line advance for every line, as native table cells do. */
     uniformLineHeight?: boolean;
@@ -1472,6 +2306,8 @@ interface TableLayoutOptions {
     scale?: number;
     minFontSize?: number;
     fontFamily?: string;
+    /** The design's code family for cell runs with `code: true`. */
+    codeFontFamily?: string;
     textMeasurement?: TextMeasurement;
     path?: string;
     /** RR-54: the document, for a dataset-backed table (`{ dataset }`): its headers, rows and column formats come from `datasets`. */
@@ -1527,4 +2363,4 @@ declare function resolveCanvasDimensions(input: unknown): {
     height: number;
 };
 
-export { DEFAULT_FURNITURE_DATE_FORMAT as $, type AnnotatedRun as A, type CodeLayoutOptions as B, type ComposeSlideOptions as C, type CodeLineSegment as D, type CodeLineSource as E, type FontSchemeDiagnostic as F, type CodeTextFit as G, type CodeTextPart as H, type ComposedCaption as I, type ComposedFlow as J, type ComposedFootnoteEntry as K, type LayoutDiagnostic as L, type MetricLayout as M, type ComposedFootnotes as N, type ComposedGroup as O, type ComposedItem as P, type ComposedLogo as Q, type ComposedSlideImage as R, type Composition as S, type TextMeasurement as T, type CompositionCandidate as U, type CompositionDecision as V, type CompositionExplanation as W, type CompositionPenalties as X, type CompositionTrack as Y, DEFAULT_CHART_LABEL_SEPARATOR as Z, DEFAULT_FONT_SCHEME as _, type AnnotationFitter as a, type RichTextRun as a$, DEFAULT_SLIDE_NUMBER_FORMAT as a0, type DeckCitations as a1, FONT_SIZE_GRID_PER_PX as a2, FOOTNOTE_MAX_RATIO as a3, type FontFamilies as a4, type FootnoteLayoutOptions as a5, type FurnitureField as a6, type FurnitureImagePart as a7, type FurnitureLayout as a8, type FurniturePart as a9, type NumberingInput as aA, type NumberingStyleName as aB, type NumberingSuffix as aC, OPFCompositionError as aD, PICTURE_BULLET_SCALE as aE, type PhysicalAlignment as aF, type QuoteContent as aG, type QuoteLayout as aH, type QuoteLayoutDiagnostic as aI, type QuoteLayoutOptions as aJ, type QuoteTextPart as aK, type QuoteTextSource as aL, type Reference as aM, type ReferencesSlideOptions as aN, type ResolveColorRefOptions as aO, type ResolveColorRefRoles as aP, type ResolveLogoOptions as aQ, type ResolvedChartDataLabels as aR, type ResolvedChartOptions as aS, type ResolvedFontScheme as aT, type ResolvedLogo as aU, type ResolvedNumbering as aV, type RichText as aW, type RichTextFit as aX, type RichTextFragment as aY, type RichTextLine as aZ, type RichTextOptions as a_, type FurniturePartBase as aa, type FurnitureSocialLink as ab, type FurnitureTextExtras as ac, type FurnitureTextPart as ad, type LayoutBox as ae, type ListBulletImage as af, type ListEntryLayout as ag, type ListFit as ah, type ListFitOptions as ai, type ListNumber as aj, type ListText as ak, type ListValue as al, type LogoSlot as am, MAX_COMPOSITION_DEPTH as an, MAX_NUMBERING_LEVELS as ao, MAX_NUMBERING_VALUE as ap, MAX_ROMAN_VALUE as aq, type MeasureTextWidth as ar, type MetricContent as as, type MetricLayoutDiagnostic as at, type MetricLayoutOptions as au, type MetricTextPart as av, type MetricTextSource as aw, NUMBERING_STYLES as ax, NUMBERING_SUFFIXES as ay, type Numbering as az, type AnnotationLayoutOptions as b, sliceNumberedItems as b$, type SlideCitations as b0, type SlideComposition as b1, type SlideImageShape as b2, type SocialPlatformRecord as b3, type SocialProfile as b4, type TextDirection as b5, type TextFit as b6, type TextLineInk as b7, type TextPlacement as b8, type TextPlacementLine as b9, layoutCaption as bA, layoutCode as bB, layoutFootnotes as bC, layoutFurniture as bD, layoutMetric as bE, layoutQuote as bF, layoutTimeline as bG, listNumbers as bH, measureText as bI, measureTextOutline as bJ, normalizeHexColor as bK, numberingAtLevel as bL, numberingStyleDraws as bM, paragraphDirection as bN, paragraphDirectionAt as bO, physicalAlignment as bP, placeTextLines as bQ, referencesSlide as bR, resolveCanvasDimensions as bS, resolveChartOptions as bT, resolveColorRef as bU, resolveFontFamilies as bV, resolveFontSchemeReference as bW, resolveLogo as bX, resolveNumbering as bY, resolveSocialProfile as bZ, resolveTextStyle as b_, type TextStyle as ba, type TimelineContent as bb, type TimelineEvent as bc, type TimelineLayout as bd, type TimelineLayoutDiagnostic as be, type TimelineLayoutOptions as bf, type TimelineTextPart as bg, annotationText as bh, captionSettings as bi, chartColorForFill as bj, chartLabelText as bk, chartOptionSupport as bl, chartOptionTarget as bm, chartPaletteForFill as bn, citationMarkerText as bo, collectCitations as bp, colorContrast as bq, composeSlide as br, fitList as bs, fitRichText as bt, fitText as bu, formatChartLabelNumber as bv, formatChartLabelPercent as bw, formatFurnitureDate as bx, formatListNumber as by, formatSlideNumber as bz, CAPTIONABLE_FIELDS as c, slideCitations as c0, snapFontSizeDown as c1, snapFontSizeUp as c2, textColorForFill as c3, textWidthMeasurer as c4, walkCitationRuns as c5, wrapText as c6, type FontFaceSelection as c7, type ReadingBox as c8, type SourceTextFit as c9, type TableBorder as ca, type TableCellLayout as cb, type TableCellStyle as cc, type TableGrid as cd, type TableGridCell as ce, type TableGridIssue as cf, type TableLayout as cg, type TableLayoutOptions as ch, type TableRowLayout as ci, type TextLineSegment as cj, type TextLineSource as ck, layoutTable as cl, slideImageShape as cm, tableGrid as cn, tableRowBoundaries as co, visualReadingOrder as cp, CAPTION_FONT_RATIO as d, CAPTION_MAX_RATIO as e, CHART_SERIES_MIN_DIFFERENCE as f, CHART_SERIES_MIN_LIGHTNESS_STEP as g, CITATION_MARKER_RAISE as h, CITATION_MARKER_SCALE as i, type Caption as j, type CaptionAlignment as k, type CaptionObject as l, type CaptionPosition as m, type CaptionSettings as n, type ChartLabelContent as o, type ChartLabelPosition as p, type ChartLegendPosition as q, type ChartOptionDiagnostic as r, type ChartOptionKind as s, type ChartOptionSupport as t, type ChartOptionTarget as u, type CitationMarker as v, type CitationNote as w, type CodeContent as x, type CodeLayout as y, type CodeLayoutDiagnostic as z };
+export { type CodeHighlightColors as $, type AnnotatedRun as A, type BackgroundImageFit as B, type ComposeSlideOptions as C, CODE_SYNTAX_MIN_CONTRAST as D, ENGINE_DEFAULT_CHART_TYPES as E, type Fonts as F, type Caption as G, type CaptionAlignment as H, type CaptionObject as I, type CaptionPosition as J, type CaptionSettings as K, type LayoutDiagnostic as L, type MeasureTextWidth as M, type ChartHighlightMarks as N, type ChartLabelContent as O, type ChartLabelPosition as P, type ChartLegendPosition as Q, type ChartOptionDiagnostic as R, SOCIAL_PLATFORMS as S, type TextMeasurement as T, type ChartOptionKind as U, type ChartOptionSupport as V, type ChartOptionTarget as W, type CitationMarker as X, type CitationNote as Y, type CodeContent as Z, type CodeHighlightBand as _, CHART_TYPES as a, type ListBulletImage as a$, type CodeHighlightEntry as a0, type CodeHighlightIssue as a1, type CodeHighlightLines as a2, type CodeLayout as a3, type CodeLayoutDiagnostic as a4, type CodeLayoutOptions as a5, type CodeLineSegment as a6, type CodeLineSource as a7, type CodeRun as a8, type CodeSyntaxPalette as a9, DEFAULT_SLIDE_NUMBER_FORMAT as aA, DESIGN_HINT_KEYS as aB, type DeckCitations as aC, type DesignHintKey as aD, type DesignHintSource as aE, type DesignHints as aF, FONT_SIZE_GRID_PER_PX as aG, FOOTNOTE_MAX_RATIO as aH, type FontFaceSelection as aI, type FootnoteLayoutOptions as aJ, type FurnitureField as aK, type FurnitureImagePart as aL, type FurnitureLayout as aM, type FurniturePart as aN, type FurniturePartBase as aO, type FurnitureSocialLink as aP, type FurnitureTextExtras as aQ, type FurnitureTextPart as aR, type ImageEdge as aS, type ImageFit as aT, type ImageFitPlacement as aU, type ImageFocus as aV, type ImageShape as aW, LAYOUT_BODY_KINDS as aX, type LayoutBodyKind as aY, type LayoutBox as aZ, type LayoutContent as a_, type CodeSyntaxPaletteOptions as aa, type CodeSyntaxPaletteTheme as ab, type CodeTextFit as ac, type CodeTextPart as ad, type CodeToken as ae, type CodeTokenKind as af, type ComposedBackgroundImage as ag, type ComposedCaption as ah, type ComposedFlow as ai, type ComposedFootnoteEntry as aj, type ComposedFootnotes as ak, type ComposedGroup as al, type ComposedImage as am, type ComposedItem as an, type ComposedLogo as ao, type ComposedOverlay as ap, type ComposedPlacement as aq, type Composition as ar, type CompositionCandidate as as, type CompositionDecision as at, type CompositionExplanation as au, type CompositionPenalties as av, type CompositionTrack as aw, DARK_BACKGROUND_LUMINANCE as ax, DEFAULT_CHART_LABEL_SEPARATOR as ay, DEFAULT_FURNITURE_DATE_FORMAT as az, ENGINE_DEFAULT_COLOR_SCHEME as b, type RichTextOptions as b$, type ListEntryLayout as b0, type ListFit as b1, type ListFitOptions as b2, type ListNumber as b3, type ListText as b4, type ListValue as b5, type LogoSlot as b6, MAX_COMPOSITION_DEPTH as b7, MAX_NUMBERING_LEVELS as b8, MAX_NUMBERING_VALUE as b9, type QuoteLayout as bA, type QuoteLayoutDiagnostic as bB, type QuoteLayoutOptions as bC, type QuotePhoto as bD, type QuoteTextPart as bE, type QuoteTextSource as bF, type ReadingBox as bG, type Reference as bH, type ReferencesSlideOptions as bI, type ResolveColorRefOptions as bJ, type ResolveColorRefRoles as bK, type ResolveColorRolesOptions as bL, type ResolveDesignHintsOptions as bM, type ResolveLogoOptions as bN, type ResolveScriptFontsOptions as bO, type ResolvedChartDataLabels as bP, type ResolvedChartHighlight as bQ, type ResolvedChartOptions as bR, type ResolvedColorRoles as bS, type ResolvedDesignHints as bT, type ResolvedLogo as bU, type ResolvedNumbering as bV, type ResolvedScriptFonts as bW, type RichText as bX, type RichTextFit as bY, type RichTextFragment as bZ, type RichTextLine as b_, MAX_ROMAN_VALUE as ba, METRIC_TREND_MIN_CONTRAST as bb, METRIC_TREND_SHAPES as bc, type MetricContent as bd, type MetricLayout as be, type MetricLayoutDiagnostic as bf, type MetricLayoutOptions as bg, type MetricSentiment as bh, type MetricTextPart as bi, type MetricTextSource as bj, type MetricTrend as bk, type MetricTrendColorOptions as bl, type MetricTrendMark as bm, NUMBERING_STYLES as bn, NUMBERING_SUFFIXES as bo, type Numbering as bp, type NumberingInput as bq, type NumberingStyleName as br, type NumberingSuffix as bs, OPFCompositionError as bt, PATTERN_PRESETS as bu, PATTERN_PRESET_ALIASES as bv, PATTERN_TILE_SIZE as bw, PICTURE_BULLET_SCALE as bx, type PhysicalAlignment as by, type QuoteContent as bz, ENGINE_DEFAULT_FONT_SCHEME as c, fitImage as c$, type RichTextRun as c0, SURFACE_ALT_MIN_CONTRAST as c1, SURFACE_ALT_MIX as c2, type ScriptFontApp as c3, type ScriptFontSlots as c4, type ScriptFontSource as c5, type ScriptFontSupplement as c6, type ScriptRole as c7, type SlideCitations as c8, type SlideComposition as c9, type TimelineMarkerShape as cA, type TimelineStatus as cB, type TimelineStatusColors as cC, type TimelineTextPart as cD, type WatermarkTextLayout as cE, type WatermarkTextOptions as cF, annotationText as cG, captionSettings as cH, chartColorForFill as cI, chartHighlightColors as cJ, chartHighlightMarks as cK, chartLabelText as cL, chartOptionSupport as cM, chartOptionTarget as cN, chartPaletteForFill as cO, citationMarkerText as cP, codeHighlightBands as cQ, codeHighlightColors as cR, codeHighlightLines as cS, codeLineNumbers as cT, codeLineRuns as cU, codeSyntaxPalette as cV, codeSyntaxPaletteForScheme as cW, collectCitations as cX, colorContrast as cY, composeSlide as cZ, defaultSlideBackground as c_, type SocialProfile as ca, type SourceTextFit as cb, TIMELINE_OUTLINE_MIN_CONTRAST as cc, TIMELINE_STATUSES as cd, TIMELINE_TEXT_MIN_CONTRAST as ce, type TableBorder as cf, type TableCellLayout as cg, type TableCellStyle as ch, type TableGrid as ci, type TableGridCell as cj, type TableGridIssue as ck, type TableLayout as cl, type TableLayoutOptions as cm, type TableRowLayout as cn, type TextDirection as co, type TextFit as cp, type TextLineInk as cq, type TextLineSegment as cr, type TextLineSource as cs, type TextPlacement as ct, type TextPlacementLine as cu, type TimelineContent as cv, type TimelineEvent as cw, type TimelineLayout as cx, type TimelineLayoutDiagnostic as cy, type TimelineLayoutOptions as cz, ENGINE_DEFAULT_THEME as d, textWidthMeasurer as d$, fitList as d0, fitRichText as d1, fitText as d2, formatChartLabelNumber as d3, formatChartLabelPercent as d4, formatFurnitureDate as d5, formatListNumber as d6, formatSlideNumber as d7, imageBackground as d8, imageShape as d9, patternRuns as dA, physicalAlignment as dB, placeTextLines as dC, referencesSlide as dD, resolveCanvasDimensions as dE, resolveChartOptions as dF, resolveCodeLanguage as dG, resolveColorRef as dH, resolveColorRoles as dI, resolveDesignHints as dJ, resolveFontFamilies as dK, resolveLogo as dL, resolveNumbering as dM, resolvePatternPreset as dN, resolveScriptFonts as dO, resolveSlideDirection as dP, resolveSocialProfile as dQ, resolveTextStyle as dR, scriptFontRole as dS, sliceNumberedItems as dT, slideCitations as dU, snapFontSizeDown as dV, snapFontSizeUp as dW, surfaceAltColor as dX, tableGrid as dY, tableRowBoundaries as dZ, textColorForFill as d_, intrinsicImageAspect as da, intrinsicImageSize as db, isDarkColor as dc, layoutCaption as dd, layoutCode as de, layoutContent as df, layoutFootnotes as dg, layoutFurniture as dh, layoutMetric as di, layoutQuote as dj, layoutTable as dk, layoutTimeline as dl, layoutWatermark as dm, listNumbers as dn, measureText as dp, measureTextOutline as dq, metricTrendColor as dr, metricTrendMark as ds, metricTrendPoints as dt, normalizeHexColor as du, numberingAtLevel as dv, numberingStyleDraws as dw, paragraphDirection as dx, paragraphDirectionAt as dy, patternBitmap as dz, type FontFamilies as e, timelineMarkerShapes as e0, timelineTextColor as e1, tokenizeCode as e2, visualReadingOrder as e3, walkCitationRuns as e4, wrapText as e5, LANGUAGES as f, type LanguageFamilyName as g, type LanguageVocabulary as h, type SocialPlatformVocabulary as i, type TextStyle as j, type AnnotationFitter as k, type AnnotationLayoutOptions as l, CAPTIONABLE_FIELDS as m, normalizeLanguageFamily as n, CAPTION_FONT_RATIO as o, CAPTION_MAX_RATIO as p, CHART_HIGHLIGHT_MUTED_MIN_CONTRAST as q, CHART_HIGHLIGHT_MUTED_MIX as r, CHART_SERIES_MIN_DIFFERENCE as s, CHART_SERIES_MIN_LIGHTNESS_STEP as t, CITATION_MARKER_RAISE as u, CITATION_MARKER_SCALE as v, CODE_HIGHLIGHT_LANGUAGES as w, CODE_HIGHLIGHT_MAX_LENGTH as x, CODE_PANEL_BACKGROUND as y, CODE_PANEL_FOREGROUND as z };