Blame for backend/app/slides/layout.py

"""Where everything on a slide goes. Each theme has its own composition for every layout variant (GEOMETRY), the
variant of each slide is picked by code (assign_variants), and compose() turns one slide into placed elements: boxes
in pixels on the 1920 x 1080 canvas, each with its text and font size. The HTML and the PowerPoint both draw these
same elements, so the two always match.

Text is measured here before it is placed: every text box gets the largest font size at which its text fits, and
text that cannot fit even at the smallest size is shortened. Nothing is ever drawn outside its box."""

import copy
import math
import random
import re
from dataclasses import dataclass, field

from app.slides.content import LIMITS, clip
from app.slides.metrics import WIDTHS
from app.slides.themes import theme_id

# --- geometry -------------------------------------------------------------------------------------------------------
# A block is (x, y, w, h[, align[, valign[, kind]]]). `kind` says how a body, a column or the closing line is drawn.
# Night stellar (dark-space): cinematic, centred openers and closers, asymmetric splits. Moon light (light-space):
# editorial, left aligned, top anchored, mirrored splits.

GEOMETRY: dict[str, dict[str, dict[str, dict[str, tuple]]]] = {
    "dark-space": {
        "title": {
            "a": {"kicker": (360, 258, 1200, 40, "center"), "heading": (160, 312, 1600, 300, "center", "middle"),
                  "lead": (360, 636, 1200, 130, "center")},
            "b": {"kicker": (140, 512, 1100, 40), "heading": (140, 562, 1150, 290, "left", "bottom"),
                  "lead": (140, 872, 1000, 120)},
            "c": {"kicker": (140, 286, 860, 40), "heading": (140, 340, 880, 400, "left", "middle"),
                  "lead": (140, 762, 860, 150)},
        },
        "agenda": {
            "a": {"kicker": (140, 160, 700, 40), "heading": (140, 212, 700, 420),
                  "body": (960, 140, 820, 820, "left", "middle", "agenda_list")},
            "b": {"kicker": (360, 110, 1200, 40, "center"), "heading": (260, 160, 1400, 130, "center", "middle"),
                  "body": (220, 340, 1480, 620, "left", "top", "agenda_grid")},
        },
        "section": {
            "a": {"kicker": (360, 368, 1200, 40, "center"), "heading": (210, 420, 1500, 240, "center", "middle"),
                  "lead": (410, 684, 1100, 150, "center")},
            "b": {"kicker": (140, 552, 1100, 40), "heading": (140, 604, 1300, 240, "left", "bottom"),
                  "lead": (140, 864, 1100, 120)},
        },
        "points": {
            "a": {"kicker": (140, 100, 1300, 40), "heading": (140, 150, 1360, 150), "lead": (140, 314, 1300, 110),
                  "body": (140, 446, 1300, 534, "left", "top", "list")},
            "b": {"kicker": (140, 160, 640, 40), "heading": (140, 212, 640, 500), "lead": (140, 730, 640, 240),
                  "body": (880, 130, 900, 840, "left", "middle", "list")},
            "c": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
                  "body": (140, 432, 1640, 548, "left", "top", "cards")},
            "d": {"kicker": (140, 160, 700, 40), "heading": (140, 212, 700, 430), "lead": (140, 662, 700, 300),
                  "body": (930, 110, 850, 860, "left", "middle", "timeline_v")},
        },
        "two_column": {
            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
                  "left": (140, 432, 790, 548, "left", "top", "col"), "right": (990, 432, 790, 548, "left", "top", "col")},
            "b": {"kicker": (360, 90, 1200, 40, "center"), "heading": (210, 140, 1500, 130, "center", "middle"),
                  "lead": (360, 282, 1200, 90, "center"),
                  "left": (140, 410, 780, 570, "left", "top", "panel"), "right": (1000, 410, 780, 570, "left", "top", "panel")},
        },
        "stat": {
            "a": {"kicker": (360, 120, 1200, 40, "center"), "heading": (260, 170, 1400, 130, "center", "middle"),
                  "value": (160, 318, 1600, 300, "center", "middle"), "label": (360, 630, 1200, 120, "center"),
                  "lead": (410, 776, 1100, 180, "center")},
            "b": {"kicker": (140, 150, 820, 40), "value": (140, 206, 820, 420, "left", "middle"),
                  "label": (140, 650, 820, 300), "heading": (1060, 160, 720, 290, "left", "bottom"),
                  "lead": (1060, 480, 720, 480)},
        },
        "quote": {
            "a": {"kicker": (360, 150, 1200, 40, "center"), "quote": (210, 214, 1500, 500, "center", "middle"),
                  "by": (360, 740, 1200, 60, "center"), "heading": (360, 846, 1200, 110, "center")},
            "b": {"kicker": (140, 150, 640, 40), "heading": (140, 202, 640, 400), "lead": (140, 630, 640, 320),
                  "quote": (900, 160, 880, 640, "left", "middle"), "by": (900, 820, 880, 60)},
        },
        "closing": {
            "a": {"kicker": (360, 90, 1200, 40, "center"), "heading": (210, 140, 1500, 120, "center", "middle"),
                  "body": (140, 300, 1640, 430, "center", "top", "take_arc"),
                  "closing": (260, 760, 1400, 190, "center", "middle", "line")},
            "b": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 120),
                  "body": (140, 308, 1640, 450, "left", "top", "take_cols"),
                  "closing": (140, 800, 1640, 170, "left", "middle", "band")},
            "c": {"kicker": (140, 190, 820, 40), "closing": (140, 244, 820, 600, "left", "middle", "big"),
                  "heading": (1060, 150, 720, 110), "body": (1060, 290, 720, 680, "left", "top", "take_stack")},
        },
    },
    "light-space": {
        "title": {
            "a": {"kicker": (140, 318, 1150, 40), "heading": (140, 368, 1150, 350), "lead": (140, 738, 1000, 150)},
            "b": {"kicker": (140, 120, 1640, 40), "heading": (140, 174, 1640, 430, "left", "bottom"), "lead": (140, 640, 1150, 170)},
            "c": {"kicker": (360, 326, 1200, 40, "center"), "heading": (300, 378, 1320, 270, "center", "middle"),
                  "lead": (410, 670, 1100, 130, "center")},
        },
        "agenda": {
            "a": {"kicker": (140, 110, 1640, 40), "heading": (140, 160, 1640, 130),
                  "body": (140, 336, 1640, 630, "left", "top", "agenda_grid")},
            "b": {"kicker": (140, 376, 640, 40), "heading": (140, 428, 640, 320),
                  "body": (900, 130, 880, 840, "left", "middle", "agenda_list")},
        },
        "section": {
            "a": {"kicker": (140, 408, 1300, 40), "heading": (140, 460, 1300, 240), "lead": (140, 716, 1100, 150)},
            "b": {"kicker": (620, 408, 1160, 40, "right"), "heading": (480, 460, 1300, 240, "right"),
                  "lead": (680, 716, 1100, 150, "right")},
        },
        "points": {
            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1500, 100),
                  "body": (140, 432, 1640, 548, "left", "top", "list2")},
            "b": {"kicker": (1180, 160, 600, 40), "heading": (1180, 212, 600, 500), "lead": (1180, 730, 600, 240),
                  "body": (140, 130, 940, 840, "left", "middle", "list")},
            "c": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
                  "body": (140, 432, 1640, 548, "left", "top", "cards")},
            "d": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
                  "body": (140, 440, 1640, 540, "left", "top", "timeline_h")},
        },
        "two_column": {
            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
                  "left": (140, 432, 790, 548, "left", "top", "panel"), "right": (990, 432, 790, 548, "left", "top", "panel")},
            "b": {"kicker": (140, 160, 560, 40), "heading": (140, 212, 560, 420), "lead": (140, 650, 560, 320),
                  "left": (780, 130, 1000, 400, "left", "top", "col"), "right": (780, 566, 1000, 400, "left", "top", "col")},
        },
        "stat": {
            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140),
                  "value": (140, 330, 900, 360, "left", "middle"), "label": (140, 700, 900, 260),
                  "lead": (1120, 360, 660, 600)},
            "b": {"kicker": (360, 130, 1200, 40, "center"), "value": (260, 186, 1400, 320, "center", "middle"),
                  "label": (360, 526, 1200, 120, "center"), "heading": (260, 690, 1400, 110, "center", "middle"),
                  "lead": (410, 820, 1100, 150, "center")},
        },
        "quote": {
            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 110),
                  "quote": (250, 300, 1430, 470, "left", "middle"), "by": (250, 796, 1430, 60)},
            "b": {"kicker": (620, 130, 1160, 40, "right"), "heading": (620, 180, 1160, 110, "right"),
                  "quote": (420, 330, 1360, 450, "right", "middle"), "by": (620, 806, 1160, 60, "right")},
        },
        "closing": {
            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 120),
                  "body": (140, 318, 1640, 440, "left", "top", "take_cols"),
                  "closing": (140, 800, 1640, 170, "left", "middle", "band")},
            "b": {"kicker": (140, 110, 1640, 40), "closing": (140, 160, 1500, 390, "left", "top", "big"),
                  "heading": (140, 590, 1640, 80), "body": (140, 690, 1640, 290, "left", "top", "take_row")},
            "c": {"kicker": (360, 130, 1200, 40, "center"), "heading": (260, 180, 1400, 110, "center", "middle"),
                  "body": (410, 330, 1100, 410, "left", "top", "take_stack"),
                  "closing": (260, 772, 1400, 180, "center", "middle", "line")},
        },
    },
}

VARIANTS = {layout: tuple(GEOMETRY["dark-space"][layout]) for layout in GEOMETRY["dark-space"]}


def block(theme: str, layout: str, variant: str, name: str) -> tuple | None:
    g = GEOMETRY[theme_id(theme)][layout].get(variant) or next(iter(GEOMETRY[theme_id(theme)][layout].values()))
    b = g.get(name)
    if not b:
        return None
    x, y, w, h, *rest = b
    return (x, y, w, h, rest[0] if rest else "left", rest[1] if len(rest) > 1 else "top", rest[2] if len(rest) > 2 else "")


# --- picking variants -----------------------------------------------------------------------------------------------

def fits_variant(slide: dict, theme: str, variant: str) -> bool:
    """Whether a variant suits this slide's content (a card row needs 3 or 4 points, a timeline 3 to 5)."""
    layout = slide["layout"]
    n = len(slide["points"])
    kind = (block(theme, layout, variant, "body") or (0, 0, 0, 0, "", "", ""))[6]
    if kind == "cards":
        return 3 <= n <= 4
    if kind in ("timeline_v", "timeline_h"):
        return 3 <= n <= 5
    if kind == "list2":
        return n >= 3
    if kind == "agenda_list":
        return n <= 7
    return True


def assign_variants(slides: list[dict], theme: str, seed: int, previous: list[tuple[str, str]] | None = None) -> None:
    """Give every slide a variant, in place. Only variants that suit the slide are considered; the previous slide's
    layout and variant is never repeated; variants not used yet in this deck come first; and the variant the last deck
    in the notebook had at the same position is avoided. Ties are broken by `seed` (the deck's own id), so every new
    deck differs while one deck always draws the same."""
    theme = theme_id(theme)
    rnd = random.Random(seed)
    used: dict[tuple[str, str], int] = {}
    before: tuple[str, str] | None = None
    previous = previous or []
    for i, s in enumerate(slides):
        options = [v for v in VARIANTS[s["layout"]] if fits_variant(s, theme, v)] or list(VARIANTS[s["layout"]])
        fresh = [v for v in options if (s["layout"], v) != before]
        if not fresh:  # the only variant that suits it was just used: any other one draws it too, so never repeat
            fresh = [v for v in VARIANTS[s["layout"]] if (s["layout"], v) != before] or options
        last_time = previous[i] if i < len(previous) else None

        scores = {v: (used.get((s["layout"], v), 0), 1 if last_time == (s["layout"], v) else 0, rnd.random())
                  for v in fresh}
        choice = min(fresh, key=scores.__getitem__)
        s["variant"] = choice
        used[(s["layout"], choice)] = used.get((s["layout"], choice), 0) + 1
        before = (s["layout"], choice)


# --- measuring text -------------------------------------------------------------------------------------------------

def _char_w(c: str, font: str, bold: bool) -> float:
    """Advance of one character in em, from the fonts' measured widths, padded a little so real text is never wider."""
    if font == "mono":
        return 0.62
    table = WIDTHS["display_bold" if font == "display" else "body_bold" if bold else "body"]
    w = table.get(c)
    if w is None:
        w = 1.0 if ord(c) >= 0x2E80 else 0.64  # full width scripts, and anything else not measured
    return w * 1.03


@dataclass
class Run:
    text: str
    bold: bool = False
    color: str = "ink"
    field: str = ""  # where the text lives in the slide ("heading", "points.2.text"), so the page can edit it; "" is ours


def _lines(runs: list[Run], width: float, size: float, font: str, upper: bool, track: float) -> int:
    """Lines a paragraph wraps to in `width` pixels."""
    words: list[tuple[str, bool]] = []
    for r in runs:
        t = r.text.upper() if upper else r.text
        words += [(w, r.bold) for w in t.split(" ") if w]
    if not words:
        return 0
    space = (_char_w(" ", font, False) + track) * size
    lines, x = 1, 0.0
    for word, bold in words:
        ww = sum((_char_w(c, font, bold) + track) * size for c in word)
        if ww > width:  # a word longer than the line breaks anywhere
            extra = x + (space if x else 0) + ww
            lines += int(extra // width)
            x = extra % width
            continue
        need = ww if x == 0 else x + space + ww
        if need <= width:
            x = need
        else:
            lines += 1
            x = ww
    return lines


# --- placed elements ------------------------------------------------------------------------------------------------

@dataclass
class El:
    kind: str  # text | rect | circle | line
    role: str
    x: float
    y: float
    w: float
    h: float
    paras: list[list[Run]] = field(default_factory=list)
    size: float = 0
    lh: float = 1.3
    font: str = "body"  # display | body | mono
    align: str = "left"
    valign: str = "top"
    upper: bool = False
    track: float = 0.0  # letter spacing in em
    gap: float = 0.0  # space between paragraphs, in px
    fill: str | None = None  # palette key
    stroke: str | None = None
    stroke_w: float = 0
    radius: float = 0
    opacity: float = 1.0

    def text_height(self) -> float:
        return text_height(self.paras, self.w, self.size, self.lh, self.font, self.upper, self.track, self.gap)


def text_height(paras: list[list[Run]], width: float, size: float, lh: float, font: str, upper: bool = False,
                track: float = 0.0, gap: float = 0.0) -> float:
    n = [_lines(p, width, size, font, upper, track) for p in paras]
    used = [k for k in n if k]
    return sum(k * size * lh for k in used) + max(len(used) - 1, 0) * gap


SCALES = (1.0, 0.92, 0.85, 0.78, 0.72, 0.66, 0.6, 0.55)
GROW = (1.4, 1.28, 1.18, 1.08)  # sparse content is drawn larger, so a slide with little on it is not half empty


def _scales(start: int, grow: bool = False) -> tuple[float, ...]:
    """Scales to try, largest first: from `start` down, with the growing ones first when allowed and not shrunk."""
    return (GROW + SCALES) if grow and start == 0 else SCALES[start:]

# Base font sizes in px, by format (both themes). Presenter slides carry fewer words, so they are drawn larger.
TYPE = {
    "detailed": {"kicker": 24, "heading": 66, "title": 110, "section": 88, "lead": 33, "title_lead": 37, "point": 31,
                 "card_term": 33, "card_text": 28, "value": 242, "label": 37, "quote": 57, "by": 26, "take": 31,
                 "closing": 51, "closing_big": 73, "agenda": 35, "col_label": 31, "col_item": 30, "num": 24,
                 "footer": 20},
    "presenter": {"kicker": 26, "heading": 79, "title": 123, "section": 101, "lead": 40, "title_lead": 42,
                  "point": 44, "card_term": 37, "card_text": 37, "value": 286, "label": 44, "quote": 66, "by": 29,
                  "take": 40, "closing": 62, "closing_big": 86, "agenda": 40, "col_label": 33, "col_item": 40,
                  "num": 26, "footer": 20},
}


def _fit_size(paras: list[list[Run]], width: float, height: float, base: float, lh: float, font: str,
              start: int, upper: bool = False, track: float = 0.0, gap_em: float = 0.0, grow: bool = False) -> float | None:
    """The largest size (base times a scale, from `start` down) at which the paragraphs fit the box, or None."""
    for scale in _scales(start, grow):
        size = round(base * scale, 1)
        if text_height(paras, width, size, lh, font, upper, track, size * gap_em) <= height:
            return size
    return None


class NoFit(Exception):
    """Text that does not fit even at the smallest size: the caller shortens it and tries again."""

    def __init__(self, field_name: str, index: int | None = None):
        super().__init__(field_name)
        self.field_name = field_name
        self.index = index


@dataclass
class Composed:
    slide: dict  # the slide as drawn (text shortened when it had to be)
    elements: list[El]
    seed: int


def _text(role: str, rect: tuple, paras: list[list[Run]], base: float, start: int, *, font: str = "body",
          lh: float = 1.35, upper: bool = False, track: float = 0.0, gap_em: float = 0.0, field_name: str = "",
          index: int | None = None, grow: bool = False) -> El:
    x, y, w, h, align, valign = rect[:6]
    size = _fit_size(paras, w, h, base, lh, font, start, upper, track, gap_em, grow)
    if size is None:
        raise NoFit(field_name or role, index)
    return El("text", role, x, y, w, h, paras=paras, size=size, lh=lh, font=font, align=align, valign=valign,
              upper=upper, track=track, gap=size * gap_em)


def _point_runs(p: dict, i: int, fmt: str) -> list[Run]:
    if p["term"] and fmt == "detailed":
        return [Run(p["term"], True, "ink", f"points.{i}.term"), Run(". ", True, "ink"),
                Run(p["text"], False, "mute", f"points.{i}.text")]
    return [Run(p["text"], False, "ink", f"points.{i}.text")]


def _body(els: list[El], s: dict, rect: tuple, kind: str, fmt: str, t: dict, start: int, dark: bool) -> None:
    """The slide's main content: points, agenda items or takeaways, drawn as `kind`."""
    x, y, w, h, _align, valign, _ = rect
    pts = s["points"]

    if kind in ("list", "list2", "agenda_list", "agenda_grid", "take_stack"):
        if kind in ("agenda_list", "agenda_grid"):
            items = [[Run(p["text"], False, "ink", f"points.{i}.text")] for i, p in enumerate(pts)]
            base, numbered = t["agenda"], True
        elif kind == "take_stack":
            items = [[Run(tx, False, "ink", f"takeaways.{i}")] for i, tx in enumerate(s["takeaways"])]
            base, numbered = t["take"], True
        else:
            items = [_point_runs(p, i, fmt) for i, p in enumerate(pts)]
            base, numbered = t["point"], False
        cols = 2 if kind in ("list2", "agenda_grid") and len(items) >= 3 else 1
        per = math.ceil(len(items) / cols)
        col_gap = 70
        cw = (w - col_gap * (cols - 1)) / cols
        indent = 78 if numbered else 44
        tw = cw - indent
        # One size for every item: the largest at which the tallest column fits with breathing room between items.
        size = None
        for scale in _scales(start, True):
            sz = round(base * scale, 1)
            gap = sz * 0.9
            heights = [text_height([it], tw, sz, 1.38, "body") for it in items]
            tallest = max(sum(heights[c * per:(c + 1) * per]) + gap * (len(heights[c * per:(c + 1) * per]) - 1)
                          for c in range(cols))
            if tallest <= h:
                size = sz
                break
        if size is None:
            raise NoFit("takeaways" if kind == "take_stack" else "points")
        heights = [text_height([it], tw, size, 1.38, "body") for it in items]
        for c in range(cols):
            chunk = list(range(c * per, min((c + 1) * per, len(items))))
            total = sum(heights[i] for i in chunk)
            free = h - total
            gap = min(free / max(len(chunk) - 1, 1), size * 2.2) if len(chunk) > 1 else 0
            block_h = total + gap * max(len(chunk) - 1, 0)
            cy = y + (h - block_h) / 2 if valign == "middle" else y
            cx = x + c * (cw + col_gap)
            for i in chunk:
                ih = heights[i]
                if numbered:
                    els.append(El("text", "num", cx, cy + size * 0.12, 64, size * 1.3, paras=[[Run(f"{i + 1:02d}", True, "accent")]],
                                  size=round(size * 0.82, 1), lh=1.2, font="mono"))
                else:
                    d = size * 0.34
                    els.append(El("circle", "dot", cx + 4, cy + size * 0.69 - d / 2, d, d, fill="accent"))
                els.append(El("text", "item", cx + indent, cy, tw, ih + 2, paras=[items[i]], size=size, lh=1.38))
                if numbered and kind != "take_stack" and i != chunk[-1]:
                    els.append(El("line", "rule", cx + indent, cy + ih + gap / 2, tw, 0, stroke="line", stroke_w=1.5))
                cy += ih + gap
        return

    if kind in ("cards", "take_cols", "take_row", "take_arc"):
        if kind == "cards":
            cells = [(p["term"] if fmt == "detailed" else "", p["text"]) for p in pts]
        else:
            cells = [("", tx) for tx in s["takeaways"]]
        n = max(len(cells), 1)
        gap = 36 if kind != "take_row" else 60
        cw = (w - gap * (n - 1)) / n
        boxed = kind in ("cards", "take_cols")
        pad = 40 if boxed else 0
        top = 0.0
        if kind == "take_arc":
            top = 120  # the glowing marker above each takeaway
        elif kind == "take_row":
            top = 70
        else:
            top = 64  # number row inside the card
        inner_w = cw - 2 * pad
        inner_h = h - 2 * pad - top
        term_base = t["card_term"]
        text_base = t["card_text"] if kind == "cards" else t["take"]
        size = None
        for scale in _scales(start, True):
            ts, xs = round(term_base * scale, 1), round(text_base * scale, 1)
            ok = True
            for term, text in cells:
                hh = (text_height([[Run(term, True)]], inner_w, ts, 1.15, "display") + ts * 0.5 if term else 0)
                hh += text_height([[Run(text)]], inner_w, xs, 1.4, "body")
                if hh > inner_h:
                    ok = False
                    break
            if ok:
                size = (ts, xs)
                break
        if size is None:
            raise NoFit("takeaways" if kind != "cards" else "points")
        ts, xs = size
        # Cards as tall as the tallest content (not the whole box), so short text does not float in a tall card.
        tallest = max((text_height([[Run(term, True)]], inner_w, ts, 1.15, "display") + ts * 0.5 if term else 0)
                      + text_height([[Run(text)]], inner_w, xs, 1.4, "body") for term, text in cells)
        h = min(h, tallest + 2 * pad + top + 12)
        for i, (term, text) in enumerate(cells):
            cx = x + i * (cw + gap)
            if boxed:
                els.append(El("rect", "card", cx, y, cw, h, fill="card", stroke="cardline", stroke_w=2, radius=22))
            if kind == "take_arc":
                r = 46
                els.append(El("circle", "halo", cx + cw / 2 - r * 1.5, y + 2 - r * 0.5, r * 3, r * 3, fill="accent2", opacity=0.18))
                els.append(El("circle", "marker", cx + cw / 2 - r, y + 2, r * 2, r * 2, fill="accent2"))
                els.append(El("text", "num", cx + cw / 2 - r, y + 2, r * 2, r * 2, paras=[[Run(f"{i + 1}", True, "white")]],
                              size=34, lh=1.0, font="display", align="center", valign="middle"))
            elif kind == "take_row":
                els.append(El("rect", "bar", cx, y, cw, 5, fill="accent"))
                els.append(El("text", "num", cx, y + 20, cw, 34, paras=[[Run(f"{i + 1:02d}", True, "accent")]],
                              size=24, lh=1.2, font="mono"))
            else:
                els.append(El("text", "num", cx + pad, y + pad, inner_w, 34, paras=[[Run(f"{i + 1:02d}", True, "accent")]],
                              size=t["num"], lh=1.2, font="mono"))
            cy = y + pad + top
            align = "center" if kind == "take_arc" else "left"
            if term:
                th = text_height([[Run(term, True)]], inner_w, ts, 1.15, "display")
                els.append(El("text", "term", cx + pad, cy, inner_w, th + 2, paras=[[Run(term, True, "ink", f"points.{i}.term")]], size=ts,
                              lh=1.15, font="display", align=align))
                cy += th + ts * 0.5
            where = f"points.{i}.text" if kind == "cards" else f"takeaways.{i}"
            els.append(El("text", "item", cx + pad, cy, inner_w, y + h - pad - cy,
                          paras=[[Run(text, False, "mute" if term else "ink", where)]], size=xs, lh=1.4, align=align))
        return

    if kind in ("timeline_v", "timeline_h"):
        items = [_point_runs(p, i, fmt) for i, p in enumerate(pts)]
        n = len(items)
        r = 28
        if kind == "timeline_v":
            tw = w - 96
            size = None
            for scale in _scales(start, True):
                sz = round(t["point"] * scale, 1)
                heights = [max(text_height([it], tw, sz, 1.38, "body"), r * 2) for it in items]
                if sum(heights) + sz * 1.2 * (n - 1) <= h:
                    size = sz
                    break
            if size is None:
                raise NoFit("points")
            heights = [max(text_height([it], tw, size, 1.38, "body"), r * 2) for it in items]
            gap = min((h - sum(heights)) / max(n - 1, 1), size * 2.4)
            total = sum(heights) + gap * (n - 1)
            cy = y + (h - total) / 2 if valign == "middle" else y
            els.append(El("line", "spine", x + r, cy + r, 0, total - 2 * r if total > 2 * r else 0, stroke="line", stroke_w=3))
            for i, it in enumerate(items):
                els.append(El("circle", "marker", x, cy, r * 2, r * 2, fill="card", stroke="accent", stroke_w=3))
                els.append(El("text", "num", x, cy, r * 2, r * 2, paras=[[Run(str(i + 1), True, "accent")]], size=24, lh=1.0,
                              font="display", align="center", valign="middle"))
                els.append(El("text", "item", x + 96, cy + max((r * 2 - size * 1.38) / 2, 0) if heights[i] <= r * 2 else cy,
                              tw, heights[i] + 2, paras=[it], size=size, lh=1.38))
                cy += heights[i] + gap
        else:
            gap = 40
            cw = (w - gap * (n - 1)) / n
            th = h - r * 2 - 40
            size = _fit_all([[it] for it in items], cw, th, t["point"] * 0.9, 1.38, start)
            if size is None:
                raise NoFit("points")
            els.append(El("line", "spine", x + r, y + r, w - 2 * r, 0, stroke="line", stroke_w=3))
            for i, it in enumerate(items):
                cx = x + i * (cw + gap)
                els.append(El("circle", "marker", cx, y, r * 2, r * 2, fill="card", stroke="accent", stroke_w=3))
                els.append(El("text", "num", cx, y, r * 2, r * 2, paras=[[Run(str(i + 1), True, "accent")]], size=24, lh=1.0,
                              font="display", align="center", valign="middle"))
                els.append(El("text", "item", cx, y + r * 2 + 40, cw, th, paras=[it], size=size, lh=1.38))
        return
    raise ValueError(f"unknown body kind {kind}")


def _fit_all(blocks: list[list[list[Run]]], width: float, height: float, base: float, lh: float, start: int) -> float | None:
    for scale in _scales(start, True):
        size = round(base * scale, 1)
        if all(text_height(b, width, size, lh, "body") <= height for b in blocks):
            return size
    return None


def _columns(els: list[El], s: dict, rects: tuple[tuple, tuple], t: dict, start: int) -> None:
    """The two sides of a comparison, at one font size, each panel as tall as the taller side's content."""
    kind = rects[0][6]
    pad = 44 if kind == "panel" else 0
    top = 0 if kind == "panel" else 28
    sides = [s["left"], s["right"]]

    def measure(col: dict, iw: float, ls: float, xs: float) -> tuple[float, list[float]]:
        label = [[Run(col["label"], True, "accent")]] if col["label"] else []
        lab = text_height(label, iw, ls, 1.2, "display") + (xs * 0.9 if label else 0)
        heights = [text_height([[Run(i)]], iw - 40, xs, 1.38, "body") for i in col["items"]]
        return lab + sum(heights) + xs * 0.75 * (len(heights) - 1), heights

    for scale in _scales(start, True):
        ls, xs = round(t["col_label"] * scale, 1), round(t["col_item"] * scale, 1)
        need = [measure(col, r[2] - 2 * pad, ls, xs)[0] for col, r in zip(sides, rects, strict=True)]
        bad = [i for i, (n, r) in enumerate(zip(need, rects, strict=True)) if n > r[3] - 2 * pad - top]
        if not bad:
            break
    else:
        raise NoFit(("left", "right")[bad[0]] + "_items")
    panel_h = max(need) + 2 * pad + top + 8
    for side, col, (x, y, w, h, *_) in zip(("left", "right"), sides, rects, strict=True):
        if kind == "panel":
            els.append(El("rect", "panel", x, y, w, min(h, panel_h), fill="card", stroke="cardline", stroke_w=2, radius=22))
        else:
            els.append(El("rect", "bar", x, y, 72, 5, fill="accent"))
        ix, iw = x + pad, w - 2 * pad
        cy = y + pad + top
        _, heights = measure(col, iw, ls, xs)
        if col["label"]:
            lab_h = text_height([[Run(col["label"], True)]], iw, ls, 1.2, "display")
            els.append(El("text", "col_label", ix, cy, iw, lab_h + 2, paras=[[Run(col["label"], True, "accent", f"{side}.label")]],
                          size=ls, lh=1.2, font="display"))
            cy += lab_h + xs * 0.9
        for n, (item, hh) in enumerate(zip(col["items"], heights, strict=True)):
            d = xs * 0.32
            els.append(El("circle", "dot", ix + 2, cy + xs * 0.69 - d / 2, d, d, fill="accent"))
            els.append(El("text", "item", ix + 40, cy, iw - 40, hh + 2, paras=[[Run(item, False, "ink", f"{side}.items.{n}")]],
                          size=xs, lh=1.38))
            cy += hh + xs * 0.75


def _compose_once(s: dict, deck: dict, index: int, theme: str, fmt: str, start: int) -> list[El]:
    from app.slides.themes import THEMES

    t = TYPE[fmt]
    dark = THEMES[theme].dark
    layout, v = s["layout"], s["variant"]
    els: list[El] = []

    lead_slot = block(theme, layout, v, "lead")

    def rect(name: str) -> tuple | None:
        r = block(theme, layout, v, name)
        # No lead: what sits right under the lead's slot (in the same column) moves up into it.
        if r and name in ("body", "left", "right") and lead_slot and not s["lead"]:
            lx, ly, lw, lh_ = lead_slot[:4]
            if r[1] >= ly + lh_ - 2 and r[1] - (ly + lh_) < 80 and r[0] < lx + lw and lx < r[0] + r[2]:
                return (r[0], ly, r[2], r[3] + r[1] - ly, *r[4:])
        return r

    k = rect("kicker")
    if k and s["kicker"]:
        x, y, w, h, align, *_ = k
        bar_x = x + (w - 64) / 2 if align == "center" else (x + w - 64 if align == "right" else x)
        els.append(El("rect", "bar", bar_x, y - 18, 64, 5, fill="accent"))
        els.append(_text("kicker", k, [[Run(s["kicker"], True, "accent", "kicker")]], t["kicker"], 0, font="mono", lh=1.2,
                         upper=True, track=0.16, field_name="kicker"))

    heading_base = {"title": t["title"], "section": t["section"]}.get(layout, t["heading"])
    hr = rect("heading")
    if hr and s["heading"]:
        els.append(_text("heading", hr, [[Run(s["heading"], True, "ink", "heading")]], heading_base, start, font="display",
                         lh=1.08, field_name="heading"))

    lr = rect("lead")
    if lr and s["lead"]:
        base = t["title_lead"] if layout == "title" else t["lead"]
        head = next((e for e in els if e.role == "heading"), None)
        if head and head.valign == "top" and abs(head.x - lr[0]) < 1 and head.y < lr[1]:
            # Under a top aligned heading in the same column: follow the heading instead of waiting at the box's top.
            top = head.y + head.text_height() + head.size * 0.55
            lr = (lr[0], top, lr[2], lr[1] + lr[3] - top, *lr[4:])
        els.append(_text("lead", lr, [[Run(s["lead"], False, "mute", "lead")]], base, start, lh=1.4, field_name="lead"))

    if layout == "stat":
        els.append(_text("value", rect("value"), [[Run(s["stat"]["value"], True, "accent", "stat.value")]], t["value"], start,
                         font="display", lh=1.0, field_name="stat_value"))
        els.append(_text("label", rect("label"), [[Run(s["stat"]["label"], False, "ink", "stat.label")]], t["label"], start, lh=1.35,
                         field_name="stat_label", grow=True))
    if layout == "quote":
        q = rect("quote")
        els.append(_text("quote", q, [[Run("“", True, "accent"), Run(s["quote"]["text"], False, "ink", "quote.text"),
                                       Run("”", True, "accent")]], t["quote"], start, font="display", lh=1.22,
                         field_name="quote", grow=True))
        if s["quote"]["by"] and (b := rect("by")):
            els.append(_text("by", b, [[Run(s["quote"]["by"], False, "mute", "quote.by")]], t["by"], 0, font="mono", lh=1.3,
                             upper=True, track=0.08, field_name="by"))
    if layout == "two_column":
        _columns(els, s, (rect("left"), rect("right")), t, start)
    br = rect("body")
    if br:
        _body(els, s, br, br[6], fmt, t, start, dark)
    cr = rect("closing")
    if cr and s["closing"]:
        kind = cr[6]
        if kind == "band":
            x, y, w, h, *_ = cr
            els.append(El("rect", "band", x, y, w, h, fill="band", radius=24))
            inner = (x + 60, y, w - 120, h, "left", "middle")
            els.append(_text("closing", inner, [[Run(s["closing"], True, "bandink", "closing")]], t["closing"], start,
                             font="display", lh=1.15, field_name="closing"))
        else:
            base = t["closing_big"] if kind == "big" else t["closing"]
            els.append(_text("closing", cr, [[Run(s["closing"], True, "ink", "closing")]], base, start, font="display", lh=1.12,
                             field_name="closing", grow=kind == "big"))

    if layout != "title":
        total = len(deck["slides"])
        foot = [[Run(clip(deck.get("title"), 70), False, "mute")]]
        els.append(El("text", "footer", 140, 1018, 1200, 30, paras=foot, size=t["footer"], lh=1.2, font="mono"))
        els.append(El("text", "footer", 1480, 1018, 300, 30, paras=[[Run(f"{index + 1:02d} / {total:02d}", False, "mute")]],
                      size=t["footer"], lh=1.2, font="mono", align="right"))
    return els


def _shorten(s: dict, err: NoFit, fmt: str) -> bool:
    """Make the text that did not fit shorter (or drop a point). False when there is nothing left to shorten."""
    lo = LIMITS[fmt]["points"][0]
    name = err.field_name

    def cut(text: str) -> str:
        return clip(text, max(int(len(text) * 0.82), 12)) if len(text) > 14 else text

    if name == "points":
        pts = s["points"]
        if s["layout"] == "agenda" or len(pts) > max(lo, 3):
            if len(pts) > 2:
                pts.pop()
                return True
        longest = max(range(len(pts)), key=lambda i: len(pts[i]["text"]) + len(pts[i]["term"]), default=None)
        if longest is None or len(pts[longest]["text"]) <= 14:
            return False
        pts[longest]["text"] = cut(pts[longest]["text"])
        return True
    if name == "takeaways":
        tk = s["takeaways"]
        i = max(range(len(tk)), key=lambda j: len(tk[j]), default=None)
        if i is None or len(tk[i]) <= 14:
            return False
        tk[i] = cut(tk[i])
        return True
    if name in ("left_items", "right_items"):
        col = s[name.split("_")[0]]
        if len(col["items"]) > 2:
            col["items"].pop()
            return True
        i = max(range(len(col["items"])), key=lambda j: len(col["items"][j]), default=None)
        if i is None or len(col["items"][i]) <= 14:
            return False
        col["items"][i] = cut(col["items"][i])
        return True
    path = {"stat_value": ("stat", "value"), "stat_label": ("stat", "label"), "quote": ("quote", "text"),
            "by": ("quote", "by")}.get(name)
    if path:
        holder, key = s[path[0]], path[1]
    elif name in s and isinstance(s[name], str):
        holder, key = s, name
    else:
        return False
    if len(holder[key]) <= 14:
        if name in ("lead", "by", "kicker"):
            holder[key] = ""
            return True
        return False
    holder[key] = cut(holder[key])
    return True


def compose(deck: dict, index: int, theme: str, fmt: str, seed: int = 0) -> Composed:
    """Slide `index` of a clamped deck, placed. Text that does not fit is shortened until it does; a slide that
    still cannot be drawn becomes a plain section slide with its heading."""
    theme, fmt = theme_id(theme), fmt if fmt in TYPE else "detailed"
    s = copy.deepcopy(deck["slides"][index])
    if s["variant"] not in VARIANTS[s["layout"]]:
        s["variant"] = VARIANTS[s["layout"]][0]
    start = min(int(s.get("shrink") or 0), len(SCALES) - 1)
    for _ in range(60):
        try:
            return Composed(s, _compose_once(s, deck, index, theme, fmt, start), seed)
        except NoFit as err:
            if not _shorten(s, err, fmt):
                break
    plain = {**copy.deepcopy(s), "layout": "section", "variant": VARIANTS["section"][0], "lead": "", "points": [],
             "heading": clip(s["heading"] or deck.get("title"), 60)}
    return Composed(plain, _compose_once(plain, deck, index, theme, fmt, 0), seed)


def seed_of(value: object) -> int:
    """A stable integer seed from a deck id."""
    digits = re.sub(r"[^0-9a-f]", "", str(value or "").lower())
    return int(digits[:12] or "0", 16)