slide deck and audio implemented

backend/app/infographics/image.py

@@ -1,6 +1,7 @@
 """An infographic's PNG: its stored HTML page drawn by a headless Chrome at the page's own size. No Remotion, no
 browser library: one `chrome --headless --screenshot` run per download (the result is kept for the next one)."""
 
+import functools
 import glob
 import hashlib
 import os
@@ -24,17 +25,29 @@ class ImageUnavailable(Exception):
     """No Chrome to draw with, or it failed."""
 
 
+@functools.cache
+def _runs(path: str) -> bool:
+    """Whether the binary actually starts (a package manager's wrapper can outlive the browser it points at)."""
+    try:
+        return subprocess.run([path, "--version"], capture_output=True, timeout=20).returncode == 0
+    except (subprocess.SubprocessError, OSError):
+        return False
+
+
 def chrome() -> str | None:
-    """CHROME, or a Chrome / Chromium found on the machine."""
+    """CHROME, or a working Chrome / Chromium found on the machine."""
     if env := os.environ.get("CHROME"):
         return env if Path(env).exists() else None
-    for name in ("chromium", "chromium-browser", "google-chrome", "google-chrome-stable", "chrome"):
-        if found := shutil.which(name):
-            return found
-    patterns = ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    found = [p for name in ("chromium", "chromium-browser", "google-chrome", "google-chrome-stable", "chrome")
+             if (p := shutil.which(name))]
+    # Playwright's headless shell first: desktop Chrome on macOS can hang taking a headless screenshot.
+    shell = "chromium_headless_shell-*/chrome-headless-shell-*/chrome-headless-shell"
+    patterns = [os.path.expanduser(f"~/Library/Caches/ms-playwright/{shell}"), os.path.expanduser(f"~/.cache/ms-playwright/{shell}"),
+                "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
                 os.path.expanduser("~/.cache/puppeteer/chrome/*/chrome-mac-*/"
                                    "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing")]
-    return next((p for pat in patterns for p in glob.glob(pat)), None)
+    found += [p for pat in patterns for p in glob.glob(pat)]
+    return next((p for p in found if _runs(p)), None)
 
 
 def render_png(html: str, layout: str = "portrait") -> bytes:

backend/app/llm/signatures.py

@@ -260,14 +260,25 @@ class ExtractClaims(dspy.Signature):
     claims: list[Claim] = dspy.OutputField()
 
 
-class PodcastScript(dspy.Signature):
-    """Write a two host conversation about the material. Hosts stay grounded in the passages and cite
-    them. Natural, warm, curious. No em dashes."""
+class WriteAudioScript(dspy.Signature):
+    """Write the script of an audio overview of the material, to be read aloud. Use only what the material says:
+    never add facts, numbers or names from outside it, and cite the lines each turn draws on. Follow the focus when
+    one is given: it says what to cover, what to emphasize and what to skip, as far as the material supports it. Write
+    in the style given. With two hosts, write a real back and forth: host_a and host_b take turns, every turn is one
+    to three sentences, and they react to each other (a question, a surprise, an example, a disagreement in a
+    debate). With one host, write a single narrator speaking straight to the listener, every turn host_a. Make it
+    sound spoken: plain sentences, no markdown, no lists, no stage directions, no sound effects, no reading out of
+    file names or line numbers. Aim for the target number of words. Write in the language requested. Never use em
+    dashes."""
 
-    passages: list[str] = dspy.InputField()
-    format: Literal["deep_dive", "brief", "debate"] = dspy.InputField()
-    target_minutes: int = dspy.InputField()
-    lines: list[ScriptLine] = dspy.OutputField()
+    title: str = dspy.InputField(desc="What the material is from")
+    material: list[str] = dspy.InputField(desc="Posts with path and numbered lines, or chat transcripts")
+    style: str = dspy.InputField(desc="The style's name and what it should sound like")
+    hosts: int = dspy.InputField(desc="1 (a single narrator) or 2 (a conversation)")
+    target_words: int = dspy.InputField(desc="About how many words the whole script should be")
+    focus: str = dspy.InputField(desc="What the person wants the episode to focus on, or (none)")
+    language: str = dspy.InputField(desc="The language to write in")
+    turns: list[ScriptLine] = dspy.OutputField()
 
 
 class HookGenerator(dspy.Signature):
@@ -680,3 +691,168 @@ class VideoFocusAngles(dspy.Signature):
         desc="Topics this material is about: 'Name (in how many items): what it covers'. May be empty")
     avoid_titles: list[str] = dspy.InputField(desc="Titles already suggested. Do not repeat or reword them")
     topics: list[FocusAngle] = dspy.OutputField(desc="Exactly 3 focus topics")
+
+
+# Slide decks: an outline, each slide written from the lines it cites, every claim checked against those lines,
+# then a conclusion written from the slides themselves. The model writes words only; code lays them out.
+
+
+class DeckSlidePlan(BaseModel):
+    layout: Literal["section", "points", "two_column", "stat", "quote"] = Field(
+        description="points: an idea explained in 2 to 5 parts; two_column: a comparison of two sides; stat: one "
+                    "number the material states; quote: one line the material says word for word; section: a short "
+                    "turning point between parts")
+    heading: str = Field(description="The slide's headline: a claim or a clear topic, at most 9 words")
+    purpose: str = Field(description="What this slide must get across, in one sentence")
+    sources: list[SourceRef] = Field(default_factory=list, description="The lines this slide draws on")
+
+
+class DeckOutline(BaseModel):
+    title: str = Field(description="The deck's title, at most 8 words")
+    subtitle: str = Field(description="One line that makes the audience want to listen, at most 18 words")
+    opening_kicker: str = Field(description="1 to 3 words above the title naming the field or the occasion")
+    agenda_heading: str = Field(description="Heading for the agenda slide, e.g. What we will cover")
+    slides: list[DeckSlidePlan]
+
+
+class OutlineDeck(dspy.Signature):
+    """Plan a slide deck from the material: the story it tells, in order, as content slides (an opening slide, an agenda
+    and a conclusion are added separately, so do not plan them). Use only what the material says. Each slide makes
+    one point and builds on the one before, so the deck reads as an argument from start to finish, not a list of
+    facts, and no two slides cover the same facts. When the posts are about unrelated subjects, give each its own
+    part of the deck and never connect them: a fact from one post is never said of another post's subject, in a
+    slide, the title or the subtitle (and the deck does not remark on keeping them apart). Vary the layouts: never
+    put two slides of the same layout in a row when another layout fits, use a stat slide only for a number the
+    material states, a quote slide only for a line the material says word for word, and a two_column slide only when
+    the material compares two things. The request, when given, decides the deck's focus, audience, angle, structure
+    and what to include or leave out: plan the deck it describes, as far as the material supports it, and leave out
+    what the material does not cover rather than invent it. The number of slides and the format are fixed by
+    slide_count and deck_format, whatever the request says. Cite the lines each slide draws on. Follow the request
+    when one is given. Write the headings in the language requested. Never use em dashes."""
+
+    title: str = dspy.InputField(desc="What the material is from")
+    material: list[str] = dspy.InputField(desc="Posts with path and numbered lines, or chat transcripts")
+    request: str = dspy.InputField(desc="What the person wants the deck to be about or how it should feel, or (none)")
+    deck_format: str = dspy.InputField(desc="detailed (read on its own) or presenter (shown while someone speaks)")
+    slide_count: str = dspy.InputField(desc="How many content slides to plan, e.g. 3 to 5")
+    language: str = dspy.InputField(desc="The language to write in")
+    outline: DeckOutline = dspy.OutputField()
+
+
+class SlidePoint(BaseModel):
+    term: str = Field(default="", description="Detailed: the idea's name in 1 to 4 words. Presenter: leave empty")
+    text: str = Field(description="Detailed: one or two sentences that explain the idea, at most 30 words. "
+                                  "Presenter: a highlight of at most 8 words")
+
+
+class SlideColumn(BaseModel):
+    label: str = Field(description="The side's name, 1 to 3 words")
+    items: list[str] = Field(description="2 to 4 short items, at most 14 words each (presenter: 8)")
+
+
+class SlideStat(BaseModel):
+    value: str = Field(description="The number as the material gives it, with its sign or unit, e.g. #1, 3x, 42%, $9")
+    label: str = Field(description="What the number measures, at most 16 words")
+
+
+class SlideQuote(BaseModel):
+    text: str = Field(description="Copied word for word from the source lines, at most 40 words")
+    by: str = Field(default="", description="Who said it, when the material says, else empty")
+
+
+class SlideOut(BaseModel):
+    kicker: str = Field(description="1 to 3 words above the heading: the slide's topic")
+    heading: str = Field(description="The headline, at most 9 words (presenter: 7)")
+    lead: str = Field(default="", description="Detailed: 1 or 2 sentences framing the slide, at most 35 words. "
+                                              "Presenter: one short line or empty")
+    points: list[SlidePoint] = Field(default_factory=list, description="For points slides: detailed 3 to 5, presenter 2 to 4")
+    left: SlideColumn | None = Field(default=None, description="For two_column slides: the first side")
+    right: SlideColumn | None = Field(default=None, description="For two_column slides: the second side")
+    stat: SlideStat | None = Field(default=None, description="For stat slides")
+    quote: SlideQuote | None = Field(default=None, description="For quote slides")
+    notes: str = Field(description="Speaker notes: what to say over this slide, 60 to 150 words, explaining it fully")
+    sources: list[SourceRef] = Field(default_factory=list, description="The lines this slide's words come from")
+
+
+class WriteSlide(dspy.Signature):
+    """Write one slide of a deck, using only the source lines given: never add facts, numbers or names from outside them.
+    The slide must make the point its plan describes and fit the deck's flow. Detailed format: the slide is read on
+    its own, so explain each idea: a clear heading, a lead that frames it, and points that each name an idea and
+    explain it in a full sentence (why it matters or how it works, not just what it is). Presenter format: the slide
+    supports a speaker, so keep it sparse: a short heading and a few highlights of a handful of words, and put the
+    full explanation in the speaker notes. Say only what this slide is for: the other slides in the outline cover
+    the rest, so do not repeat them. Apply the request's audience, tone and style to this slide, and anything it
+    asks of this part of the deck, as far as the source lines support it. Fill only the fields the layout uses. Keep
+    every line plain text: no markdown, no bullets characters, no numbering. Write in the language requested. Never
+    use em dashes."""
+
+    deck_title: str = dspy.InputField()
+    outline: list[str] = dspy.InputField(desc="Every slide in the deck, in order, so this one fits the flow")
+    position: str = dspy.InputField(desc="Which slide this is, e.g. Slide 3 of 8")
+    layout: str = dspy.InputField(desc="points, two_column, stat, quote or section")
+    heading: str = dspy.InputField(desc="The planned headline (improve it if the sources suggest a sharper one)")
+    purpose: str = dspy.InputField(desc="What the slide must get across")
+    deck_format: str = dspy.InputField(desc="detailed or presenter")
+    request: str = dspy.InputField(desc="What the person asked of the deck, or (none)")
+    source_lines: list[str] = dspy.InputField(desc="The lines to write from, with path and line numbers")
+    language: str = dspy.InputField(desc="The language to write in")
+    slide: SlideOut = dspy.OutputField()
+
+
+class ClaimCheck(BaseModel):
+    n: int = Field(description="The claim's number")
+    supported: bool = Field(description="True when the source lines say this (paraphrase is fine)")
+    fix: str = Field(default="", description="When not supported: the claim rewritten so the sources support it, in "
+                                             "the same style and length, or empty when they say nothing close")
+
+
+class CheckSlide(dspy.Signature):
+    """Check each numbered claim from a slide against the source lines. A claim is supported when the lines say it, in
+    other words or in fewer words. It is not supported when it adds a fact, number, name, cause or certainty the
+    lines do not give, or changes what they mean. For each unsupported claim, give a fixed version the lines do
+    support, or leave the fix empty. A fix is only the sentence itself, in the slide's own voice: no name or label
+    before it, and never a mention of the sources, the post, the resume or the material. Keep the claim's language.
+    Never use em dashes."""
+
+    claims: list[str] = dspy.InputField(desc="Numbered claims from one slide (a name before a colon is context only: "
+                                             "check and fix only what follows it)")
+    source_lines: list[str] = dspy.InputField(desc="What the slide was written from")
+    checks: list[ClaimCheck] = dspy.OutputField(desc="One check per claim")
+
+
+class DeckClosing(BaseModel):
+    kicker: str = Field(description="1 to 2 words above the heading, e.g. Conclusion")
+    heading: str = Field(description="Heading for the closing slide, e.g. Key takeaways")
+    takeaways: list[str] = Field(description="Exactly 3 takeaways, each a full sentence of at most 20 words "
+                                             "(presenter: 10)")
+    closing: str = Field(description="The one idea to remember, at most 12 words: a strong last line, not a thank you")
+    notes: str = Field(description="Speaker notes for the close, 50 to 120 words")
+
+
+class WriteClosing(dspy.Signature):
+    """Write the closing slide of a deck from its slides: three takeaways that sum up what the deck showed, in the order it
+    showed them, and one closing line that leaves the audience with the single idea to remember. Follow the request
+    when it asks something of the ending (for example next steps, a call to action or who it is for), as far as the
+    slides support it. Use only what the slides say. Write in the language requested. Never use em dashes."""
+
+    deck_title: str = dspy.InputField()
+    slides: list[str] = dspy.InputField(desc="Each content slide's heading and main text, in order")
+    deck_format: str = dspy.InputField(desc="detailed or presenter")
+    request: str = dspy.InputField(desc="What the person asked of the deck, or (none)")
+    language: str = dspy.InputField(desc="The language to write in")
+    closing: DeckClosing = dspy.OutputField()
+
+
+class RequestAsk(BaseModel):
+    ask: str = Field(description="One concrete thing the person asked of the deck, in a few words")
+    covered: bool = Field(description="True when the planned slides already do it")
+
+
+class CheckRequest(dspy.Signature):
+    """Read what the person asked of a slide deck and list each concrete ask in it: a topic or part to cover, an
+    audience or angle, a structure, something to include, to leave out, or to end with. For each, say whether the
+    planned slides already do it. Ignore asks about the number of slides or the visual style. Never use em dashes."""
+
+    request: str = dspy.InputField(desc="What the person asked of the deck")
+    slides: list[str] = dspy.InputField(desc="The planned slides: heading, then what each must get across")
+    asks: list[RequestAsk] = dspy.OutputField()

backend/app/pipeline/ingest.py

@@ -551,6 +551,9 @@ def store_entries(
         if not sections:
             skipped += 1
             continue
+        # Postgres text cannot hold NUL bytes, and some PDFs (icon glyphs) extract with them.
+        sections = [(h and h.replace("\x00", ""), t.replace("\x00", "")) for h, t in sections]
+        entry.title = entry.title.replace("\x00", "")
         if not doc:
             doc = Document(id=uuid.uuid4(), workspace_id=source.workspace_id, source_id=source.id, url=entry.url)
             db.add(doc)

backend/app/pipeline/media.py

@@ -1,5 +1,6 @@
-"""Audio overviews (two hosts, ElevenLabs), audiograms and stills (Remotion renderer)."""
+"""Audio overviews (one or two hosts, ElevenLabs), audiograms and stills (Remotion renderer)."""
 
+import re
 import uuid
 
 from sqlalchemy import select
@@ -8,10 +9,12 @@ from sqlalchemy.orm import Session
 from app.config import settings
 from app.corpus import Corpus
 from app.llm import run
-from app.llm.signatures import PickQuotes, PodcastScript
+from app.llm.signatures import PickQuotes, WriteAudioScript
 from app.models import Artifact, Document, Job, Source, User, VoiceProfile, Workspace
 from app.pipeline.generate import NothingToDo
+from app.pipeline.material import load_material
 from app.pipeline.passages import notebook_docs, passages_for, tools_for, verify_refs
+from app.pipeline.report import SAME_LANGUAGE
 from app.services import tts
 from app.services.jobs import record_usage, update_job
 from app.services.renderer import PermanentJobError, brand_props, request_render
@@ -48,28 +51,61 @@ def _require_tts() -> None:
 # Audio overview
 
 
+STYLES = {
+    "deep_dive": "Deep Dive: a lively, curious conversation that unpacks the ideas and connects them to each other",
+    "brief": "Brief: a short, bite sized overview that gets the core ideas across quickly",
+    "critique": "Critique: an expert review of the material, with honest, constructive feedback on how to improve it",
+    "debate": "Debate: two hosts take different sides on the material's main questions and argue them respectfully",
+}
+WORDS_PER_MINUTE = 150
+_MARKUP = re.compile(r"(\*\*|__|`|#{1,6}\s|^\s*[-*•]\s+|\[\d+\])", re.M)
+
+
+def script_turns(turns: list[dict], hosts: int) -> list[dict]:
+    """The model's turns ready to voice: empty ones dropped and markup removed. With two hosts, consecutive turns by
+    one host are joined and the speakers then strictly alternate, host A first, so the conversation always goes A, B,
+    A, B. With one host, every turn is host A's."""
+    clean = []
+    for t in turns or []:
+        text = re.sub(r"\s+", " ", _MARKUP.sub("", str((t or {}).get("text") or ""))).replace("\u2014", ", ").strip()
+        if text:
+            clean.append({"speaker": (t or {}).get("speaker") or "host_a", "text": text,
+                          "sources": list((t or {}).get("sources") or [])})
+    if hosts == 1:
+        return [{**t, "speaker": "host_a"} for t in clean]
+    merged: list[dict] = []
+    for t in clean:
+        if merged and merged[-1]["speaker"] == t["speaker"]:
+            merged[-1]["text"] += " " + t["text"]
+            merged[-1]["sources"] += t["sources"]
+        else:
+            merged.append(dict(t))
+    return [{**t, "speaker": "host_a" if i % 2 == 0 else "host_b"} for i, t in enumerate(merged)]
+
+
 def audio_overview(db: Session, job: Job, artifact: Artifact) -> dict:
     _require_tts()
-    params = job.params
-    docs = artifact_docs(db, artifact)
-    if not docs:
-        raise NothingToDo("Add posts before making an audio overview.")
-    corpus = Corpus(artifact.workspace_id)
-    update_job(db, job, progress=0.05, message=f"Reading {len(docs)} posts")
-    passages = passages_for(corpus, docs, budget_chars=90_000)
-    update_job(db, job, progress=0.15, message="Writing the conversation")
-    out = run.predict(PodcastScript, db=db, workspace_id=artifact.workspace_id, job=job, passages=passages,
-                      format=params.get("format", "deep_dive"), target_minutes=int(params.get("minutes", 6)))
-    lines = [ln for ln in (out.get("lines") or []) if (ln.get("text") or "").strip()]
+    params = dict(job.params)
+    if artifact.document_id and not params.get("document_ids") and not params.get("chat_ids"):
+        params["document_ids"] = [str(artifact.document_id)]  # made from one post
+    fmt = params.get("format") if params.get("format") in STYLES else "deep_dive"
+    hosts = 1 if params.get("hosts") == 1 else 2  # older jobs had no choice: two hosts
+    minutes = int(params.get("minutes", 6))
+    focus = (params.get("instructions") or "").strip()
+    material = load_material(db, artifact.workspace_id, artifact.notebook_id, params, job=job, what="audio overview")
+    update_job(db, job, progress=0.15, message="Writing the conversation" if hosts == 2 else "Writing the narration")
+    out = run.predict(WriteAudioScript, db=db, workspace_id=artifact.workspace_id, job=job, title=material.title,
+                      material=material.text, style=STYLES[fmt], hosts=hosts, target_words=minutes * WORDS_PER_MINUTE,
+                      focus=focus or "(none)", language=(params.get("language") or "").strip() or SAME_LANGUAGE)
+    lines = script_turns(out.get("turns") or [], hosts)
     if not lines:
         raise RuntimeError("The script came back empty")
-    tools = tools_for(corpus, docs)
     default_a, default_b = host_voices(db, artifact.workspace_id)
     voice_a, voice_b = params.get("host_a") or default_a, params.get("host_b") or default_b  # picked when made
     delivery = host_settings(db, artifact.workspace_id)
     script = [
-        tts.Line(text=ln["text"], voice_id=voice_b if ln.get("speaker") == "host_b" else voice_a,
-                 settings=delivery["host_b" if ln.get("speaker") == "host_b" else "host_a"])
+        tts.Line(text=ln["text"], voice_id=voice_b if ln["speaker"] == "host_b" else voice_a,
+                 settings=delivery[ln["speaker"]])
         for ln in lines
     ]
     update_job(db, job, progress=0.2, message=f"Recording {len(script)} lines")
@@ -80,14 +116,14 @@ def audio_overview(db: Session, job: Job, artifact: Artifact) -> dict:
                        message=f"Recorded {done} of {len(script)} lines")
 
     clips = tts.synthesize_many(artifact.workspace_id, script, on_done=progress)
+    # Every clip is the same MP3 format (mp3_44100_128), so the clips join into one file in order.
     audio = bytearray()
     segments = []
     t = 0.0
     for line, clip in zip(lines, clips, strict=True):
         seconds = tts.mp3_seconds(clip)
-        segments.append({"speaker": line.get("speaker", "host_a"), "text": line["text"],
-                         "start": round(t, 2), "end": round(t + seconds, 2),
-                         "sources": verify_refs(tools, line.get("sources") or [])})
+        segments.append({"speaker": line["speaker"], "text": line["text"],
+                         "start": round(t, 2), "end": round(t + seconds, 2), "sources": material.refs(line["sources"])})
         audio += clip
         t += seconds
     key = keys.artifact(artifact.workspace_id, artifact.id, "audio", "mp3")
@@ -96,10 +132,14 @@ def audio_overview(db: Session, job: Job, artifact: Artifact) -> dict:
     artifact.status = "ready"
     artifact.content_json = {
         **(artifact.content_json or {}),
-        "format": params.get("format", "deep_dive"),
+        "format": fmt,
+        "hosts": hosts,
+        "focus": focus,
+        "language": params.get("language") or "",
+        "source": material.source,
         "duration_s": round(t, 1),
         "segments": segments,
-        "voices": {"host_a": voice_a, "host_b": voice_b},
+        "voices": {"host_a": voice_a, **({"host_b": voice_b} if hosts == 2 else {})},
     }
     db.commit()
     record_usage(db, workspace_id=artifact.workspace_id, kind="tts", provider="elevenlabs",

backend/app/pipeline/slides.py

@@ -0,0 +1,374 @@
+"""Slide decks. The model plans the deck (OutlineDeck), writes each content slide from the lines it cites
+(WriteSlide, in parallel), has every claim checked against those lines (CheckSlide), and writes the conclusion from
+the finished slides (WriteClosing). The opening slide and the agenda come from the outline. Code then lays the deck
+out (app.slides): the model never writes markup, positions or colours, and only the deck's words are stored."""
+
+import logging
+import re
+import uuid
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.llm import run
+from app.llm.provider import fast_lm, report_lm
+from app.llm.signatures import CheckRequest, CheckSlide, OutlineDeck, WriteClosing, WriteSlide
+from app.models import Artifact, Job
+from app.pipeline.generate import NothingToDo
+from app.pipeline.material import Material, load_material
+from app.pipeline.report import SAME_LANGUAGE
+from app.services.jobs import update_job
+from app.slides.build import finish
+from app.slides.content import FORMATS, LENGTHS, clamp_deck, clamp_slide, plain
+from app.slides.layout import seed_of
+from app.slides.themes import theme_id
+
+log = logging.getLogger(__name__)
+
+CONTENT_LAYOUTS = ("section", "points", "two_column", "stat", "quote")
+SOURCE_BUDGET = 7_000  # characters of cited lines one slide is written from (a PDF's lines can be whole pages)
+CONTEXT_BUDGET = 9_000  # characters a slide without usable citations is written from
+
+
+def content_range(length: str) -> tuple[int, int]:
+    """How many content slides a deck of this length has: its total minus the opening, the closing and (above the
+    short length) the agenda."""
+    lo, hi = LENGTHS[length]
+    fixed = 3 if has_agenda(length) else 2
+    return lo - fixed, hi - fixed
+
+
+def has_agenda(length: str) -> bool:
+    return length != "short"
+
+
+def _missed(db: Session, job: Job, artifact: Artifact, request: str, plans: list[dict]) -> list[str]:
+    """What the request asked for that the planned slides do not do (empty when nothing is missing or the check fails)."""
+    if not request or not plans:
+        return []
+    try:
+        out = run.predict(CheckRequest, db=db, workspace_id=artifact.workspace_id, job=job, lm=fast_lm(), request=request,
+                          slides=[f"{p.get('heading')}: {p.get('purpose') or ''}" for p in plans])
+    except Exception:
+        return []
+    return [plain(a.get("ask")) for a in out.get("asks") or [] if isinstance(a, dict) and a.get("covered") is False
+            and plain(a.get("ask"))]
+
+
+def _outline(db: Session, job: Job, artifact: Artifact, material: Material, fmt: str, length: str, request: str,
+             language: str) -> dict:
+    lo, hi = content_range(length)
+    count = f"{lo} to {hi}" + (", including 2 to 4 section slides that divide the deck into parts" if length == "long" else "")
+    ask = request or "(none)"
+    best: dict = {}
+    for attempt in range(2):
+        try:
+            out = run.predict(OutlineDeck, db=db, workspace_id=artifact.workspace_id, job=job, lm=report_lm(),
+                              title=material.title, material=material.text, request=ask, deck_format=fmt,
+                              slide_count=count, language=language)
+        except Exception:
+            if attempt:
+                raise
+            continue
+        outline = out.get("outline") or {}
+        plans = [p for p in outline.get("slides") or []
+                 if isinstance(p, dict) and p.get("layout") in CONTENT_LAYOUTS and plain(p.get("heading"))]
+        outline["slides"] = plans
+        if len(plans) > len(best.get("slides") or []):
+            best = outline
+        if lo <= len(plans):
+            break
+        ask = f"{request or '(none)'}\n\nPlan between {lo} and {hi} content slides."
+    plans = best.get("slides") or []
+    if len(plans) < lo:
+        raise NothingToDo(f"The sources picked do not have enough in them for a {'short' if length == 'short' else 'full'} "
+                          "deck. Add posts, or choose Short.")
+    # The request decides what the deck is about: when the outline misses something it asked for, plan once more with
+    # the missing asks spelled out (kept only if the new outline is still long enough).
+    missed = _missed(db, job, artifact, request, plans)
+    if missed:
+        retry = f"{request}\n\nThe previous outline missed these asks; plan slides for them as far as the material supports: " \
+                + "; ".join(missed)
+        try:
+            out = run.predict(OutlineDeck, db=db, workspace_id=artifact.workspace_id, job=job, lm=report_lm(),
+                              title=material.title, material=material.text, request=retry, deck_format=fmt,
+                              slide_count=count, language=language)
+            again = out.get("outline") or {}
+            again_plans = [p for p in again.get("slides") or []
+                           if isinstance(p, dict) and p.get("layout") in CONTENT_LAYOUTS and plain(p.get("heading"))]
+            if len(again_plans) >= lo:
+                best, plans = {**again, "slides": again_plans}, again_plans
+        except Exception:
+            pass  # keep the first outline
+    # Too many: keep the first and last (the argument's start and end) and drop from the middle.
+    while len(plans) > hi:
+        plans.pop(len(plans) // 2)
+    best["slides"] = plans
+    return best
+
+
+def _source_lines(material: Material, refs: list[dict]) -> list[str]:
+    """What one slide is written from: the lines it cites with a little around them, or the material itself."""
+    out, used = [], 0
+    if material.tools:
+        for r in refs:
+            text = material.tools.quote(r["path"], max(1, r["line_start"] - 2), r["line_end"] + 6) or r["quote"]
+            block = f"FILE {r['path']} ({r.get('title') or ''}) from line {max(1, r['line_start'] - 2)}\n{text}"
+            if used + len(block) > SOURCE_BUDGET and out:
+                break
+            out.append(block[:SOURCE_BUDGET])
+            used += len(block)
+    if out:
+        return out
+    budget = CONTEXT_BUDGET // max(len(material.text), 1)
+    return [t[:budget] for t in material.text]
+
+
+def _norm(text: str) -> str:
+    return re.sub(r"[^\w%$€£]+", " ", text.lower()).strip()
+
+
+def _fallback_slide(plan: dict, sources: list[str]) -> dict:
+    """A slide written by code when the model could not write one: its planned heading and its first source lines."""
+    body = " ".join(re.sub(r"^\s*\d+\|\s?", "", line) for s in sources for line in s.splitlines()[1:])
+    sentences = [s.strip() for s in re.split(r"(?<=[.!?])\s+", body) if len(s.strip()) > 30][:3]
+    return {"layout": "points" if len(sentences) >= 2 else "section", "heading": plan.get("heading"),
+            "kicker": "", "lead": plan.get("purpose") or "", "points": [{"term": "", "text": s} for s in sentences],
+            "notes": plan.get("purpose") or ""}
+
+
+def _claims(slide: dict) -> list[tuple[tuple, str]]:
+    """Every checkable statement on a slide, with where it lives."""
+    out: list[tuple[tuple, str]] = []
+    if slide.get("layout") == "section" and slide.get("heading"):  # a section's heading is its claim
+        out.append((("heading",), slide["heading"]))
+    if slide.get("lead"):
+        out.append((("lead",), slide["lead"]))
+    for i, p in enumerate(slide.get("points") or []):
+        if p.get("text"):  # the term is context; only the sentence is checked and rewritten
+            out.append((("points", i), f"{p['term']}: {p['text']}" if p.get("term") else p["text"]))
+    for side in ("left", "right"):
+        for i, item in enumerate((slide.get(side) or {}).get("items") or []):
+            out.append(((side, i), item))
+    stat = slide.get("stat") or {}
+    if stat.get("value") and stat.get("label"):
+        out.append((("stat",), f"{stat['value']} {stat['label']}"))
+    return out
+
+
+def _apply_checks(slide: dict, claims: list[tuple[tuple, str]], checks: list[dict]) -> None:
+    """Replace unsupported claims with their fix, or remove them."""
+    drop: dict[str, set[int]] = {"points": set(), "left": set(), "right": set()}
+    for c in checks or []:
+        try:
+            n = int(c.get("n")) - 1
+        except (TypeError, ValueError):
+            continue
+        if not 0 <= n < len(claims) or c.get("supported") is not False:
+            continue
+        where, _ = claims[n]
+        fix = plain(c.get("fix"))
+        if where[0] == "heading":
+            if fix:
+                slide["heading"] = fix
+        elif where[0] == "lead":
+            slide["lead"] = fix
+        elif where[0] == "points":
+            term = slide["points"][where[1]].get("term") or ""
+            if term and fix.lower().startswith(term.lower()):  # the fix repeated the name: keep only the sentence
+                fix = fix[len(term):].lstrip(" :.-")
+            elif term and re.match(r"^[^:.!?]{1,40}:\s", fix):  # or put a label of its own before it
+                fix = fix.split(":", 1)[1].strip()
+            if fix:
+                slide["points"][where[1]]["text"] = fix[:1].upper() + fix[1:]
+            else:
+                drop["points"].add(where[1])
+        elif where[0] in ("left", "right"):
+            if fix:
+                slide[where[0]]["items"][where[1]] = fix
+            else:
+                drop[where[0]].add(where[1])
+        elif where[0] == "stat":
+            slide["stat"] = None  # a number is never rewritten: it is in the sources as it is, or it goes
+    slide["points"] = [p for i, p in enumerate(slide.get("points") or []) if i not in drop["points"]]
+    for side in ("left", "right"):
+        if slide.get(side):
+            slide[side]["items"] = [t for i, t in enumerate(slide[side]["items"]) if i not in drop[side]]
+
+
+def _verbatim(slide: dict, sources: list[str]) -> None:
+    """A quote must be in the sources word for word and a number as written; otherwise it is removed."""
+    text = _norm(" ".join(re.sub(r"^\s*\d+\|\s?", "", line) for s in sources for line in s.splitlines()))
+    quote = slide.get("quote") or {}
+    if quote.get("text") and _norm(quote["text"]) not in text:
+        slide["quote"] = None
+    stat = slide.get("stat") or {}
+    if stat.get("value") and _norm(stat["value"]) not in text:
+        slide["stat"] = None
+
+
+def _summary(slide: dict) -> str:
+    bits = [slide.get("heading") or "", slide.get("lead") or ""]
+    bits += [f"{p.get('term') or ''} {p.get('text') or ''}".strip() for p in slide.get("points") or []]
+    for side in ("left", "right"):
+        col = slide.get(side) or {}
+        if col.get("items"):
+            bits.append(f"{col.get('label') or ''}: " + "; ".join(col["items"]))
+    if (slide.get("stat") or {}).get("value"):
+        bits.append(f"{slide['stat']['value']} {slide['stat'].get('label') or ''}")
+    if (slide.get("quote") or {}).get("text"):
+        bits.append(f"“{slide['quote']['text']}”")
+    return " | ".join(b for b in bits if b)
+
+
+def _check_frame(db: Session, job: Job, ws: uuid.UUID, slides: list[dict], subtitle: str, takeaways: list[str],
+                 last_line: str) -> tuple[str, list[str], str]:
+    """The opening's subtitle, the takeaways and the closing line say only what the (already checked) slides say:
+    each is checked against them, and fixed or removed when it does not."""
+    claims = ([("subtitle", subtitle)] if subtitle else []) + [("takeaway", t) for t in takeaways] + \
+             ([("closing", last_line)] if last_line else [])
+    if not claims:
+        return subtitle, takeaways, last_line
+    try:
+        out = run.predict(CheckSlide, db=db, workspace_id=ws, job=job, lm=fast_lm(),
+                          claims=[f"{n + 1}. {t}" for n, (_, t) in enumerate(claims)],
+                          source_lines=[_summary(s) for s in slides])
+    except Exception:
+        return subtitle, takeaways, last_line
+    verdict: dict[int, str | None] = {}  # claim index -> its fix ("" to remove)
+    for c in out.get("checks") or []:
+        try:
+            n = int(c.get("n")) - 1
+        except (TypeError, ValueError):
+            continue
+        if 0 <= n < len(claims) and c.get("supported") is False:
+            verdict[n] = plain(c.get("fix"))
+    kept = [verdict.get(n, text) for n, (_, text) in enumerate(claims)]
+    subtitle = kept.pop(0) if subtitle else ""
+    last_line = kept.pop() if last_line else ""
+    return subtitle, [t for t in kept if t] or [s["heading"] for s in slides[:3]], last_line
+
+
+def _previous_variants(db: Session, artifact: Artifact) -> list[tuple[str, str]]:
+    """The layout and variant of each slide in the notebook's last deck, so this one can look different."""
+    if not artifact.notebook_id:
+        return []
+    last = db.scalars(select(Artifact).where(Artifact.notebook_id == artifact.notebook_id, Artifact.type == "slide_deck",
+                                             Artifact.status == "ready", Artifact.id != artifact.id)
+                      .order_by(Artifact.created_at.desc()).limit(1)).first()
+    slides = (((last.content_json or {}).get("deck") or {}).get("slides") or []) if last else []
+    return [(s.get("layout"), s.get("variant")) for s in slides if isinstance(s, dict)]
+
+
+def build_slide_deck(db: Session, job: Job, artifact: Artifact) -> dict:
+    params = job.params
+    ws = artifact.workspace_id
+    fmt = params.get("deck_format") if params.get("deck_format") in FORMATS else "detailed"
+    length = params.get("deck_length") if params.get("deck_length") in LENGTHS else "default"
+    theme = theme_id(params.get("theme"))
+    language = (params.get("language") or "").strip() or SAME_LANGUAGE
+    request = (params.get("instructions") or "").strip()
+    material = load_material(db, ws, artifact.notebook_id, params, job=job, what="slide deck")
+
+    update_job(db, job, progress=0.2, message="Planning the story")
+    outline = _outline(db, job, artifact, material, fmt, length, request, language)
+    plans = outline["slides"]
+    refs = [material.refs(p.get("sources")) for p in plans]
+    sources = [_source_lines(material, r) for r in refs]
+    lines = [f"{i + 2}. {p['heading']}" for i, p in enumerate(plans)]
+    total = len(plans) + (3 if has_agenda(length) else 2)
+
+    update_job(db, job, progress=0.35, message=f"Writing {len(plans)} slides")
+    first = 3 if has_agenda(length) else 2  # where content starts, counting from 1
+
+    def inputs(i: int) -> dict:
+        return {"deck_title": outline.get("title") or material.title, "outline": lines,
+                "position": f"Slide {first + i} of {total}", "layout": plans[i]["layout"],
+                "heading": plans[i]["heading"], "purpose": plans[i].get("purpose") or "", "deck_format": fmt,
+                "request": request or "(none)", "source_lines": sources[i], "language": language}
+
+    written = run.predict_many(WriteSlide, [inputs(i) for i in range(len(plans))], db=db, workspace_id=ws, lm=report_lm())
+    missing = [i for i, w in enumerate(written) if not (w and w.get("slide"))]
+    if missing:  # one more try for the slides that failed
+        again = run.predict_many(WriteSlide, [inputs(i) for i in missing], db=db, workspace_id=ws, lm=report_lm())
+        for i, w in zip(missing, again, strict=True):
+            written[i] = w
+    slides = []
+    for i, w in enumerate(written):
+        s = (w or {}).get("slide") or _fallback_slide(plans[i], sources[i])
+        s = dict(s)
+        s["layout"] = plans[i]["layout"] if not s.get("layout") else s["layout"]
+        s["heading"] = s.get("heading") or plans[i]["heading"]
+        cited = material.refs(s.get("sources")) if material.tools else []
+        s["sources"] = cited or refs[i]
+        _verbatim(s, sources[i])
+        slides.append(s)
+
+    update_job(db, job, progress=0.6, message="Checking every slide against your posts")
+    claims = [_claims(s) for s in slides]
+    todo = [i for i, c in enumerate(claims) if c]
+    checked = run.predict_many(
+        CheckSlide, [{"claims": [f"{n + 1}. {t}" for n, (_, t) in enumerate(claims[i])], "source_lines": sources[i]}
+                     for i in todo], db=db, workspace_id=ws, lm=fast_lm())
+    for i, out in zip(todo, checked, strict=True):
+        if out:
+            _apply_checks(slides[i], claims[i], out.get("checks") or [])
+
+    # A slide left with only its heading (its number or quote was not in the posts, its claims did not hold) says
+    # nothing checked: it goes, as long as the deck keeps its length.
+    lo = content_range(length)[0]
+    for i in reversed(range(len(slides))):
+        bare = (clamp_slide({**slides[i], "layout": slides[i].get("layout")}, fmt) or {}).get("layout") == "section"
+        if bare and plans[i]["layout"] != "section" and len(slides) > lo:
+            del slides[i]
+    # Two slides with the same heading (a part's title repeated by its first slide): the section one goes.
+    for i in reversed(range(len(slides))):
+        same = [j for j, o in enumerate(slides) if j != i and _norm(o.get("heading") or "") == _norm(slides[i].get("heading") or "")]
+        if same and slides[i].get("layout") == "section" and len(slides) > lo:
+            del slides[i]
+
+    update_job(db, job, progress=0.8, message="Writing the conclusion")
+    closing: dict = {}
+    for _ in range(2):  # one more try: a failed call would leave the deck without its real conclusion
+        try:
+            closing = run.predict(WriteClosing, db=db, workspace_id=ws, job=job, lm=fast_lm(),
+                                  deck_title=outline.get("title") or material.title, slides=[_summary(s) for s in slides],
+                                  deck_format=fmt, request=request or "(none)", language=language).get("closing") or {}
+        except Exception:
+            log.warning("WriteClosing failed", exc_info=True)
+            closing = {}
+        if closing.get("takeaways"):
+            break
+    takeaways = closing.get("takeaways") or [s["heading"] for s in slides[:3]]
+    subtitle = outline.get("subtitle") or ""
+    subtitle, takeaways, last_line = _check_frame(db, job, ws, slides, subtitle, takeaways, closing.get("closing") or "")
+
+    opening = {"layout": "title", "kicker": outline.get("opening_kicker") or "", "heading": outline.get("title") or material.title,
+               "lead": subtitle, "notes": subtitle}
+    deck_slides = [opening]
+    if has_agenda(length):
+        # A long deck's agenda lists its parts (its section slides); otherwise every slide.
+        parts = [s for s in slides if s.get("layout") == "section"]
+        listed = parts if len(parts) >= 2 else slides
+        deck_slides.append({"layout": "agenda", "kicker": "", "heading": outline.get("agenda_heading") or "Agenda",
+                            "points": [{"term": "", "text": s["heading"]} for s in listed]})
+    deck_slides += slides
+    deck_slides.append({"layout": "closing", "kicker": closing.get("kicker") or "",
+                        "heading": closing.get("heading") or opening["heading"], "takeaways": takeaways,
+                        "closing": last_line or opening["lead"], "notes": closing.get("notes") or ""})
+
+    update_job(db, job, progress=0.9, message="Laying out the slides")
+    deck = clamp_deck({"title": opening["heading"], "subtitle": opening["lead"], "slides": deck_slides}, fmt)
+    if not deck or len(deck["slides"]) < LENGTHS[length][0]:
+        raise NothingToDo("The deck came out too thin to show. Try other posts or add a description.")
+    seed = artifact.id.hex if isinstance(artifact.id, uuid.UUID) else str(artifact.id)
+    deck = finish(deck, theme, fmt, seed_of(seed), _previous_variants(db, artifact))
+
+    artifact.content_json = {**(artifact.content_json or {}), "title": f"Slide deck: {deck['title']}"[:140],
+                             "theme": theme, "format": fmt, "length": length,
+                             "language": params.get("language") or "", "instructions": request,
+                             "source": material.source, "seed": seed, "deck": deck}
+    artifact.storage_key = None
+    artifact.status = "ready"
+    db.commit()
+    return {"artifact_id": str(artifact.id), "slides": len(deck["slides"])}

backend/app/routers/artifacts.py

@@ -18,14 +18,18 @@ from app.services.plans import effective_plan, plan_limit_error
 from app.services.renderer import COMPOSITIONS
 from app.services.storage import storage
 from app.services.usage import check_limit
+from app.slides import export as slide_export
+from app.slides.build import stored as stored_deck
+from app.slides.themes import theme_id as slide_theme_id
 
 router = APIRouter(prefix="/api/artifacts", tags=["artifacts"])
 
 ArtifactType = Literal["summary", "audio_overview", "video", "quote_card", "carousel", "launch_kit", "mind_map", "quiz",
-                       "flashcards", "report", "infographic"]
+                       "flashcards", "report", "infographic", "slide_deck"]
 
 
-SOURCE_TYPES = ("quiz", "flashcards", "report", "infographic")  # made from posts or chats picked in the dialog
+# Made from posts or chats picked in the dialog
+SOURCE_TYPES = ("quiz", "flashcards", "report", "infographic", "slide_deck", "audio_overview")
 
 
 class RenderIn(BaseModel):
@@ -39,7 +43,8 @@ class GenerateIn(BaseModel):
     document_id: uuid.UUID | None = None
     archive: bool = False  # no notebook or post picked: use the "All posts" notebook
     # audio_overview
-    format: Literal["deep_dive", "brief", "debate"] = "deep_dive"
+    format: Literal["deep_dive", "brief", "critique", "debate"] = "deep_dive"
+    hosts: Literal[1, 2] = 2  # audio_overview: a single narrator or a two host conversation
     minutes: int = Field(6, ge=1, le=30)
     # the two hosts' voices, from the workspace's voices (none: the defaults)
     host_a: str | None = Field(None, max_length=100)
@@ -61,7 +66,10 @@ class GenerateIn(BaseModel):
     question_types: list[Literal["multiple_choice", "multiple_select", "fill_blank", "short_answer"]] = Field(
         default_factory=lambda: ["multiple_choice", "multiple_select"], min_length=1)
     language: str | None = Field(None, max_length=40)
-    theme: str | None = Field(None, max_length=30)  # infographic: one of app.infographics.themes
+    theme: str | None = Field(None, max_length=30)  # infographic: app.infographics.themes; slide_deck: app.slides.themes
+    # slide_deck: read on its own ("detailed") or shown behind a speaker ("presenter"), and how many slides
+    deck_format: Literal["detailed", "presenter"] = "detailed"
+    deck_length: Literal["short", "default", "long"] = "default"
     # report: a written "document" or an "interactive" one, the template it started from, and the instructions the
     # writer is given (the dialog's editable text; empty means the template's own)
     report_format: Literal["document", "interactive"] = "document"
@@ -152,8 +160,16 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
             raise HTTPException(400, "Pick at least one post or chat to make this from")
         target = _target_title(ctx, body.notebook_id, body.document_id)
     if body.type == "audio_overview":
+        if body.format == "debate" and body.hosts == 1:
+            raise HTTPException(400, "A debate needs two hosts")
         check_limit(ctx.db, ctx.workspace, "audio_minutes", body.minutes)
-        params = {"format": body.format, "minutes": body.minutes, **_hosts(ctx, body)}
+        ids = body.document_ids or ([body.document_id] if body.document_id else [])
+        hosts = _hosts(ctx, body)
+        if body.hosts == 1:
+            hosts.pop("host_b", None)
+        params = {"document_ids": [str(i) for i in ids], "chat_ids": [str(i) for i in body.chat_ids or []],
+                  "format": body.format, "minutes": body.minutes, "hosts": body.hosts, "language": body.language,
+                  "instructions": (body.instructions or "").strip(), **hosts}
         title = f"Audio overview: {target}"
     elif body.type == "mind_map":
         if not body.notebook_id:
@@ -180,6 +196,12 @@ def generate(body: GenerateIn, ctx: Ctx = Depends(get_ctx)):
         params = {"document_ids": [str(i) for i in ids], "chat_ids": [str(i) for i in body.chat_ids or []],
                   "theme": theme_id(body.theme), "instructions": (body.instructions or "").strip()[:600]}
         title = f"Infographic: {params['instructions'][:60] or target}"
+    elif body.type == "slide_deck":
+        ids = body.document_ids or ([body.document_id] if body.document_id else [])
+        params = {"document_ids": [str(i) for i in ids], "chat_ids": [str(i) for i in body.chat_ids or []],
+                  "theme": slide_theme_id(body.theme), "deck_format": body.deck_format, "deck_length": body.deck_length,
+                  "language": body.language, "instructions": (body.instructions or "").strip()}
+        title = f"Slide deck: {target}"
     elif body.type == "quiz":
         ids = body.document_ids or ([body.document_id] if body.document_id else [])
         params = {"document_ids": [str(i) for i in ids],
@@ -257,6 +279,24 @@ def infographic_image(artifact_id: uuid.UUID, layout: Literal["landscape", "port
     return Response(png, media_type="image/png", headers={"Content-Disposition": f'attachment; filename="{name} ({layout}).png"'})
 
 
+@router.get("/{artifact_id}/slides.{ext}")
+def slide_deck_file(artifact_id: uuid.UUID, ext: Literal["pdf", "pptx"], ctx: Ctx = Depends(get_ctx)):
+    """A finished slide deck as a PDF (exactly as shown) or an editable PowerPoint."""
+    a = get_artifact_or_404(ctx, artifact_id)
+    got = stored_deck(a.content_json or {}) if a.type == "slide_deck" and a.status == "ready" else None
+    if not got:
+        raise HTTPException(404, "This slide deck has nothing to download yet.")
+    deck, theme, fmt, seed = got
+    try:
+        data = (slide_export.render_pdf if ext == "pdf" else slide_export.build_pptx)(deck, theme, fmt, seed)
+    except ImageUnavailable as exc:
+        raise HTTPException(503, str(exc)) from exc
+    name = re.sub(r"[^\w\- ]+", "", deck.get("title") or "Slide deck").strip()[:80] or "Slide deck"
+    media = "application/pdf" if ext == "pdf" else \
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    return Response(data, media_type=media, headers={"Content-Disposition": f'attachment; filename="{name}.{ext}"'})
+
+
 @router.patch("/{artifact_id}")
 def patch_artifact(artifact_id: uuid.UUID, body: PatchIn, ctx: Ctx = Depends(get_ctx)):
     a = get_artifact_or_404(ctx, artifact_id)

backend/app/services/artifacts.py

@@ -9,6 +9,7 @@ from sqlalchemy.orm import Session, object_session
 from app.models import Artifact, Job
 from app.services.jobs import create_job, serialize_job
 from app.services.storage import storage
+from app.slides.build import view as slide_pages
 
 TYPE_LABELS = {
     "summary": "Summary",
@@ -22,6 +23,7 @@ TYPE_LABELS = {
     "flashcards": "Flashcards",
     "report": "Report",
     "infographic": "Infographic",
+    "slide_deck": "Slide deck",
     "upload": "Upload",
 }
 
@@ -84,6 +86,8 @@ def serialize_artifact(a: Artifact, job: Job | None = None) -> dict:
         from app.pipeline.infographic import infographic_html  # not at import: pipeline imports this module
 
         content = {**content, "html": infographic_html(content), "html_landscape": infographic_html(content, "landscape")}
+    if a.type == "slide_deck" and a.status == "ready":
+        content = {**content, "slides_html": slide_pages(content)}
     if a.type == "report" and any(b.get("type") == "infographic" for b in content.get("blocks") or []):
         content = {**content, "blocks": report_blocks(a)}
     slides = content.get("slide_keys") or []

backend/app/slides/__init__.py

@@ -0,0 +1,3 @@
+"""Slide decks: the model writes a deck as JSON (content.py clamps it to a fixed shape), layout.py places every slide
+on a 1920 x 1080 canvas, and the same placed elements are drawn as HTML (render.py: preview, presenting, PDF) and as
+an editable PowerPoint (export.py). The model never writes markup or picks positions, colours or sizes."""

backend/app/slides/build.py

@@ -0,0 +1,78 @@
+"""From a written deck to what is stored and shown. `finish` picks each slide's variant, fits its text, and checks
+the result in Chrome when one is installed. `view` reads a stored deck back (clamped again, so older or edited decks
+still draw) and gives its pages; one slide that cannot be drawn becomes a plain one instead of breaking the deck."""
+
+import copy
+import logging
+
+from app.infographics.image import ImageUnavailable
+from app.slides import export
+from app.slides.content import clamp_deck, clamp_slide, empty_slide
+from app.slides.layout import SCALES, assign_variants, compose, seed_of
+from app.slides.render import slide_html
+from app.slides.themes import theme_id
+
+log = logging.getLogger(__name__)
+
+
+def fit(deck: dict, theme: str, fmt: str, seed: int) -> dict:
+    """Every slide as it will be drawn: text shortened where it had to be, so what is stored is what is shown."""
+    out = copy.deepcopy(deck)
+    out["slides"] = [compose(out, i, theme, fmt, seed).slide for i in range(len(out["slides"]))]
+    return out
+
+
+def finish(deck: dict, theme: str, fmt: str, seed: int, previous: list[tuple[str, str]] | None = None) -> dict:
+    """Variants, fitted text, and a Chrome check that no text box overflows (slides that do are drawn a step
+    smaller and fitted again). Raises ValueError when a slide cannot be drawn at all."""
+    theme = theme_id(theme)
+    deck = copy.deepcopy(deck)
+    assign_variants(deck["slides"], theme, seed, previous)
+    deck = fit(deck, theme, fmt, seed)
+    for _ in range(3):
+        try:
+            bad = export.overflowing(deck, theme, fmt, seed)
+        except ImageUnavailable:
+            break  # no Chrome here: the measured fit alone keeps text inside its boxes
+        if not bad:
+            break
+        log.info("slides %s overflow in Chrome, drawing them smaller", sorted(bad))
+        for i in bad:
+            deck["slides"][i]["shrink"] = min(int(deck["slides"][i].get("shrink") or 0) + 1, len(SCALES) - 1)
+        deck = fit(deck, theme, fmt, seed)
+    for i in range(len(deck["slides"])):
+        slide_html(deck, i, theme, fmt, seed)  # raises if a slide cannot be drawn: better now than when shown
+    return deck
+
+
+def stored(content: dict) -> tuple[dict, str, str, int] | None:
+    """A stored deck, clamped, with its theme, format and seed (None when there is none)."""
+    fmt = content.get("format") if content.get("format") in ("detailed", "presenter") else "detailed"
+    deck = clamp_deck(content.get("deck") or {}, fmt)
+    if not deck:
+        return None
+    return deck, theme_id(content.get("theme")), fmt, seed_of(content.get("seed"))
+
+
+def _placeholder(deck: dict, index: int) -> dict:
+    s = empty_slide("section")
+    s["heading"] = deck.get("title") or "Slide"
+    return clamp_slide(s, "detailed")
+
+
+def view(content: dict) -> list[str]:
+    """Each slide of a stored deck as a standalone page."""
+    got = stored(content)
+    if not got:
+        return []
+    deck, theme, fmt, seed = got
+    pages = []
+    for i in range(len(deck["slides"])):
+        try:
+            pages.append(slide_html(deck, i, theme, fmt, seed))
+        except Exception:
+            log.exception("slide %s could not be drawn", i)
+            safe = copy.deepcopy(deck)
+            safe["slides"][i] = _placeholder(deck, i)
+            pages.append(slide_html(safe, i, theme, fmt, seed))
+    return pages

backend/app/slides/content.py

@@ -0,0 +1,187 @@
+"""What a deck says, in one fixed shape. Model output is never trusted: every slide is coerced to the same keys (empty
+defaults for what it lacks), stripped to plain text, cut to the format's limits, and moved to a simpler layout when
+it lacks what its own layout needs. Whatever goes in, what comes out can always be drawn."""
+
+import re
+
+LAYOUTS = ("title", "agenda", "section", "points", "two_column", "stat", "quote", "closing")
+FORMATS = ("detailed", "presenter")
+LENGTHS = {"short": (6, 8), "default": (9, 11), "long": (12, 16)}  # slides in the deck, opening and closing included
+
+# Characters per field. Detailed slides explain; presenter slides only cue the speaker.
+LIMITS = {
+    "detailed": {"title": 80, "subtitle": 170, "kicker": 32, "heading": 90, "lead": 240, "term": 44, "text": 220,
+                 "points": (2, 5), "label": 40, "item": 120, "items": 4, "value": 16, "stat_label": 120,
+                 "quote": 260, "by": 70, "takeaway": 150, "takeaways": 3, "closing": 140, "agenda": 64,
+                 "agenda_items": 14, "notes": 1500},
+    "presenter": {"title": 70, "subtitle": 130, "kicker": 32, "heading": 64, "lead": 130, "term": 36, "text": 80,
+                  "points": (2, 4), "label": 32, "item": 70, "items": 4, "value": 16, "stat_label": 90,
+                  "quote": 200, "by": 70, "takeaway": 90, "takeaways": 3, "closing": 110, "agenda": 56,
+                  "agenda_items": 14, "notes": 1500},
+}
+
+_TAGS = re.compile(r"<[^>]*>")
+_CTRL = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]")
+_MD_EMPH = re.compile(r"(\*\*|__|\*|`|~~)")
+_MD_LEAD = re.compile(r"^\s*(?:#{1,6}\s+|[-*+•]\s+|\d{1,2}[.)]\s+|>\s*)")
+_MD_LINK = re.compile(r"\[([^\]]*)\]\([^)]*\)")
+_CITE = re.compile(r"\s*\[\d+\]")
+_SPACE = re.compile(r"\s+")
+
+
+def plain(value: object) -> str:
+    """One line of plain text: no markup, markdown, citation markers, control characters or em dashes."""
+    if value is None or isinstance(value, dict | list | tuple | set):
+        return ""
+    s = _CTRL.sub(" ", str(value))
+    s = _MD_LINK.sub(r"\1", _TAGS.sub(" ", s))
+    s = _MD_LEAD.sub("", s)
+    s = _CITE.sub("", _MD_EMPH.sub("", s))
+    s = s.replace("—", ", ").replace("–", "-").replace("&nbsp;", " ")
+    s = _SPACE.sub(" ", s).strip()
+    return s.replace(" ,", ",").strip(" ,;")
+
+
+def clip(value: object, limit: int) -> str:
+    """Plain text of at most `limit` characters. A longer text ends at its last full sentence when one fits well,
+    otherwise at a word, with an ellipsis."""
+    s = plain(value)
+    if len(s) <= limit:
+        return s
+    head = s[:limit]
+    end = max(head.rfind(". "), head.rfind("! "), head.rfind("? "))
+    if end >= limit * 0.55:
+        return head[: end + 1]
+    # No sentence ends in reach: end at the last clause instead (", ensuring..." dropped), as a full stop.
+    clause = max(head.rfind(", "), head.rfind("; "), head.rfind(" and "), head.rfind(" while "), head.rfind(" which "))
+    if clause >= limit * 0.6:
+        return head[:clause].rstrip(" ,;:-") + "."
+    cut = head[: limit - 1].rsplit(" ", 1)[0].rstrip(" ,;:.-") or head[: limit - 1]
+    return cut + "…"
+
+
+def _dict(value: object) -> dict:
+    if hasattr(value, "model_dump"):
+        value = value.model_dump()
+    return value if isinstance(value, dict) else {}
+
+
+def _list(value: object) -> list:
+    return list(value) if isinstance(value, list | tuple) else []
+
+
+def _sources(raw: object) -> list[dict]:
+    out = []
+    for r in _list(raw):
+        r = _dict(r)
+        try:
+            start, end = int(r["line_start"]), int(r["line_end"])
+        except (KeyError, TypeError, ValueError):
+            continue
+        path = plain(r.get("path"))
+        if not path:
+            continue
+        item = {"path": path, "line_start": start, "line_end": max(start, end)}
+        for key in ("title", "document_id"):
+            if r.get(key):
+                item[key] = plain(r[key])[:200]
+        if r.get("quote"):
+            item["quote"] = clip(r["quote"], 400)
+        out.append(item)
+    return out[:8]
+
+
+def _points(raw: object, lim: dict) -> list[dict]:
+    out = []
+    for p in _list(raw):
+        if isinstance(p, str):
+            p = {"term": "", "text": p}
+        p = _dict(p)
+        term, text = clip(p.get("term"), lim["term"]), clip(p.get("text"), lim["text"])
+        if not text and term:  # a bare term is the point itself
+            term, text = "", clip(p.get("term"), lim["text"])
+        if text:
+            out.append({"term": term, "text": text})
+    return out
+
+
+def _column(raw: object, lim: dict) -> dict:
+    c = _dict(raw)
+    items = [t for t in (clip(i, lim["item"]) for i in _list(c.get("items"))) if t][: lim["items"]]
+    return {"label": clip(c.get("label"), lim["label"]), "items": items}
+
+
+def empty_slide(layout: str = "points") -> dict:
+    return {"layout": layout, "variant": "", "kicker": "", "heading": "", "lead": "", "points": [],
+            "left": {"label": "", "items": []}, "right": {"label": "", "items": []},
+            "stat": {"value": "", "label": ""}, "quote": {"text": "", "by": ""}, "takeaways": [], "closing": "",
+            "notes": "", "sources": [], "shrink": 0}
+
+
+def clamp_slide(raw: object, fmt: str) -> dict | None:
+    """One slide in the fixed shape, or None when nothing on it can be shown."""
+    lim = LIMITS[fmt if fmt in FORMATS else "detailed"]
+    r = _dict(raw)
+    s = empty_slide(r.get("layout") if r.get("layout") in LAYOUTS else "points")
+    s["variant"] = plain(r.get("variant"))[:4].lower()
+    s["kicker"] = clip(r.get("kicker"), lim["kicker"])
+    s["heading"] = clip(r.get("heading"), lim["title"] if s["layout"] == "title" else lim["heading"])
+    s["lead"] = clip(r.get("lead"), lim["subtitle"] if s["layout"] == "title" else lim["lead"])
+    lo, hi = lim["points"]
+    points = _points(r.get("points"), lim)
+    if s["layout"] == "agenda":
+        s["points"] = [{"term": "", "text": clip(p["text"], lim["agenda"])} for p in points][: lim["agenda_items"]]
+    else:
+        s["points"] = points[:hi]
+    s["left"], s["right"] = _column(r.get("left"), lim), _column(r.get("right"), lim)
+    stat = _dict(r.get("stat"))
+    s["stat"] = {"value": clip(stat.get("value"), lim["value"]), "label": clip(stat.get("label"), lim["stat_label"])}
+    quote = _dict(r.get("quote"))
+    s["quote"] = {"text": clip(quote.get("text"), lim["quote"]).strip("\"'“”"), "by": clip(quote.get("by"), lim["by"])}
+    s["takeaways"] = [t for t in (clip(t, lim["takeaway"]) for t in _list(r.get("takeaways"))) if t][: lim["takeaways"]]
+    s["closing"] = clip(r.get("closing"), lim["closing"])
+    s["notes"] = clip(r.get("notes"), lim["notes"])
+    s["sources"] = _sources(r.get("sources"))
+    try:
+        s["shrink"] = max(0, min(int(r.get("shrink") or 0), 4))
+    except (TypeError, ValueError):
+        s["shrink"] = 0
+
+    # A layout missing what it needs becomes a simpler one, so the drawing never meets an empty slot.
+    lay = s["layout"]
+    if lay == "two_column" and not (s["left"]["items"] and s["right"]["items"]):
+        merged = [{"term": "", "text": t} for t in s["left"]["items"] + s["right"]["items"]]
+        s["points"] = s["points"] or merged[:hi]
+        lay = "points"
+    if lay == "stat" and not (s["stat"]["value"] and s["stat"]["label"]):
+        lay = "points"
+    if lay == "quote" and not s["quote"]["text"]:
+        lay = "points"
+    if lay == "agenda" and len(s["points"]) < 2:
+        lay = "section"
+    if lay == "closing" and not s["takeaways"] and not s["closing"]:
+        lay = "section"
+    if lay == "points" and len(s["points"]) < lo:
+        if s["points"] and not s["lead"]:  # one point: say it as the slide's lead
+            s["lead"] = clip(s["points"][0]["text"], lim["lead"])
+        s["points"] = []
+        lay = "section"
+    if lay != s["layout"]:
+        s["variant"] = ""
+    s["layout"] = lay
+    if not s["heading"]:
+        s["heading"] = s["kicker"] or (s["closing"] if lay == "closing" else "")
+    if not s["heading"] and lay not in ("quote", "closing"):
+        return None
+    return s
+
+
+def clamp_deck(raw: object, fmt: str) -> dict | None:
+    """The deck in the fixed shape, or None when it has no slide that can be shown."""
+    r = _dict(raw)
+    lim = LIMITS[fmt if fmt in FORMATS else "detailed"]
+    slides = [s for s in (clamp_slide(x, fmt) for x in _list(r.get("slides"))) if s]
+    if not slides:
+        return None
+    title = clip(r.get("title"), lim["title"]) or (slides[0]["heading"] if slides[0]["layout"] == "title" else "") or "Slide deck"
+    return {"title": title, "subtitle": clip(r.get("subtitle"), lim["subtitle"]), "slides": slides}

backend/app/slides/decor.py

@@ -0,0 +1,152 @@
+"""The drawing behind a slide's text: stars, glows, planets, orbit rings and constellations. Each layout variant puts
+its drawing where its text is not, and the deck's seed moves it a little, so two decks never look alike while one deck
+always looks the same. The same list is drawn as SVG for the page and as a picture for the PowerPoint."""
+
+import hashlib
+import math
+import random
+from dataclasses import dataclass, field
+
+from app.slides.themes import H, W
+
+
+@dataclass
+class Shape:
+    kind: str  # glow | planet | ring | const | stars
+    cx: float = 0
+    cy: float = 0
+    r: float = 0
+    rx: float = 0
+    ry: float = 0
+    rot: float = 0
+    color: str = "accent"  # palette key
+    opacity: float = 1.0
+    width: float = 2.0
+    points: list[tuple[float, float, float, float]] = field(default_factory=list)  # stars: x, y, r, opacity
+    edges: list[tuple[int, int]] = field(default_factory=list)
+
+
+@dataclass
+class Decor:
+    hot: tuple[float, float]  # where the sky is brightest
+    shapes: list[Shape]
+
+
+# Where a variant has room for a drawing: (x0, y0, x1, y1). None: only stars and a soft glow.
+FREE = {
+    "dark-space": {
+        ("points", "a"): (1520, 140, 1900, 940), ("points", "c"): None, ("points", "b"): None, ("points", "d"): None,
+        ("agenda", "a"): (120, 660, 820, 1000), ("agenda", "b"): None,
+        ("two_column", "a"): None, ("two_column", "b"): None,
+        ("stat", "a"): None, ("stat", "b"): None, ("quote", "a"): None, ("quote", "b"): (140, 60, 760, 140),
+        ("section", "b"): (1500, 60, 1900, 560), ("closing", "b"): None, ("closing", "c"): (140, 860, 960, 1060),
+    },
+    "light-space": {
+        ("points", "a"): None, ("points", "b"): None, ("points", "c"): None, ("points", "d"): None,
+        ("agenda", "a"): None, ("agenda", "b"): (120, 760, 820, 1000),
+        ("two_column", "a"): None, ("two_column", "b"): None,
+        ("stat", "a"): None, ("stat", "b"): None, ("quote", "a"): None, ("quote", "b"): (100, 360, 400, 760),
+        ("closing", "a"): None, ("closing", "b"): None, ("closing", "c"): None,
+    },
+}
+
+
+def _stars(rnd: random.Random, dark: bool) -> Shape:
+    n = 120 if dark else 70
+    pts = []
+    for _ in range(n):
+        if dark:
+            r, op = rnd.choice((0.8, 1.0, 1.2, 1.2, 1.6, 2.2)), round(rnd.uniform(0.18, 0.85), 2)
+        else:
+            r, op = rnd.choice((0.9, 1.2, 1.5, 2.0)), round(rnd.uniform(0.08, 0.26), 2)
+        pts.append((rnd.uniform(0, W), rnd.uniform(0, H), r, op))
+    return Shape("stars", points=pts, color="star")
+
+
+def _constellation(rnd: random.Random, box: tuple[float, float, float, float], n: int = 7) -> Shape:
+    x0, y0, x1, y1 = box
+    pts = [(rnd.uniform(x0, x1), rnd.uniform(y0, y1), rnd.choice((4.0, 5.0, 6.0, 8.0)), 1.0) for _ in range(n)]
+    pts.sort(key=lambda p: p[0])
+    edges = [(i, i + 1) for i in range(n - 1)]
+    if n > 4:
+        edges.append((rnd.randrange(0, n - 3), rnd.randrange(n - 2, n)))
+    return Shape("const", points=pts, edges=edges, color="accent", opacity=0.85)
+
+
+def build(theme: str, layout: str, variant: str, seed: int, index: int) -> Decor:
+    """The drawing for one slide."""
+    dark = theme == "dark-space"
+    rnd = random.Random(int(hashlib.sha1(f"{seed}:{index}:{layout}:{variant}".encode()).hexdigest()[:12], 16))
+    j = lambda span: rnd.uniform(-span, span)  # noqa: E731  (a small, seeded nudge)
+    shapes = [_stars(rnd, dark)]
+    hot = (W * rnd.uniform(0.25, 0.75), H * rnd.uniform(0.15, 0.5))
+    key = (layout, variant)
+
+    if dark:
+        if key == ("title", "a"):
+            hot = (960, 760)
+            shapes += [Shape("glow", 960, 900, 900, color="accent2", opacity=0.55),
+                       Shape("planet", 960 + j(60), 1080 + 560 + j(40), 820),
+                       Shape("ring", 960, 860 + j(20), rx=1150, ry=150, rot=-4 + j(3), color="accent", opacity=0.45, width=2.5)]
+        elif key == ("title", "b"):
+            cx, cy = 1520 + j(60), 300 + j(50)
+            hot = (cx, cy)
+            shapes += [Shape("glow", cx, cy, 520, color="accent2", opacity=0.5), Shape("planet", cx, cy, 230 + j(25)),
+                       Shape("ring", cx, cy, rx=400, ry=78, rot=-18 + j(6), color="accent", opacity=0.55, width=2.5)]
+        elif key == ("title", "c"):
+            hot = (1450, 540)
+            shapes += [Shape("glow", 1450, 540, 620, color="accent2", opacity=0.35),
+                       _constellation(rnd, (1120, 170, 1800, 910), 8)]
+        elif layout == "section" and variant == "a":
+            hot = (960, 540)
+            shapes += [Shape("glow", 960, 540, 760, color="accent2", opacity=0.35),
+                       Shape("ring", 960, 540 + j(20), rx=980, ry=260, rot=-8 + j(5), color="accent", opacity=0.3, width=2)]
+        elif layout == "closing" and variant == "a":
+            hot = (960, 980)
+            shapes += [Shape("glow", 960, 1120, 760, color="accent2", opacity=0.5),
+                       Shape("ring", 960, 1210, rx=1080, ry=880, rot=0, color="accent", opacity=0.35, width=2.5)]
+        else:
+            corner = rnd.choice(((0, 0), (W, 0), (0, H), (W, H)))
+            shapes.append(Shape("glow", corner[0], corner[1], 700, color="accent2", opacity=0.32))
+            hot = (corner[0] * 0.8 + W * 0.1, corner[1] * 0.8 + H * 0.1)
+            free = FREE["dark-space"].get(key)
+            if free:
+                x0, y0, x1, y1 = free
+                r = min(x1 - x0, y1 - y0) * rnd.uniform(0.26, 0.34)
+                cx, cy = rnd.uniform(x0 + r, x1 - r), rnd.uniform(y0 + r, y1 - r)
+                shapes += [Shape("glow", cx, cy, r * 2.2, color="accent2", opacity=0.35), Shape("planet", cx, cy, r),
+                           Shape("ring", cx, cy, rx=r * 1.7, ry=r * 0.34, rot=-16 + j(10), color="accent", opacity=0.5, width=2)]
+    else:
+        ring = lambda cx, cy, r, op=0.3: Shape("ring", cx, cy, rx=r, ry=r, color="accent2", opacity=op, width=2)  # noqa: E731
+        if key == ("title", "a"):
+            cx, cy = 2010 + j(40), 540 + j(60)
+            hot = (1500, 540)
+            shapes += [ring(cx, cy, 360), ring(cx, cy, 540, 0.24), ring(cx, cy, 740, 0.18)]
+            a = math.radians(200 + j(20))
+            shapes.append(Shape("planet", cx + 540 * math.cos(a), cy + 540 * math.sin(a), 34))
+        elif key == ("title", "b"):
+            hot = (1500, 820)
+            shapes += [Shape("glow", 1560, 840, 520, color="accent", opacity=0.12),
+                       _constellation(rnd, (1360, 660, 1800, 980), 7)]
+        elif key == ("title", "c"):
+            hot = (960, 540)
+            shapes += [Shape("ring", 960, 520, rx=900, ry=330, rot=-10 + j(4), color="accent2", opacity=0.28, width=2.5),
+                       Shape("ring", 960, 520, rx=1040, ry=400, rot=-10 + j(4), color="accent2", opacity=0.14, width=2)]
+            a = math.radians(rnd.choice((20, 160, 200, 340)) + j(10))
+            shapes.append(Shape("planet", 960 + 900 * math.cos(a), 520 + 330 * math.sin(a), 30))
+        elif key == ("section", "a"):
+            shapes += [ring(1960, 560, 300), ring(1960, 560, 460, 0.22), ring(1960, 560, 640, 0.15),
+                       Shape("planet", 1960 - 460 + 6, 560 + j(80), 26)]
+        elif key == ("section", "b"):
+            shapes += [ring(-40, 560, 300), ring(-40, 560, 460, 0.22), ring(-40, 560, 640, 0.15),
+                       Shape("planet", -40 + 460 - 6, 560 + j(80), 26)]
+        elif key == ("closing", "c"):
+            hot = (960, 860)
+            shapes += [Shape("ring", 960, 540, rx=1000, ry=470, rot=6 + j(4), color="accent2", opacity=0.2, width=2.5)]
+        else:
+            corner = rnd.choice(((W + 60, -60), (W + 60, H + 60), (-60, H + 60)))
+            shapes += [ring(corner[0], corner[1], 260, 0.22), ring(corner[0], corner[1], 400, 0.15)]
+            free = FREE["light-space"].get(key)
+            if free:
+                shapes.append(_constellation(rnd, free, 5))
+    return Decor(hot, shapes)

backend/app/slides/export.py

@@ -0,0 +1,308 @@
+"""Files made from a deck: a PDF (the deck's own HTML printed by a headless Chrome, so it matches the preview) and an
+editable PowerPoint (the same placed elements as native text boxes and shapes over a drawn background). Also the
+overflow check: Chrome lays the slides out and reports any text box whose text is taller than the box."""
+
+import hashlib
+import io
+import json
+import math
+import re
+import subprocess
+import tempfile
+from collections import OrderedDict
+from pathlib import Path
+from threading import Lock
+
+from PIL import Image, ImageDraw
+from pptx import Presentation
+from pptx.dml.color import RGBColor
+from pptx.enum.shapes import MSO_CONNECTOR, MSO_SHAPE
+from pptx.enum.text import MSO_ANCHOR, MSO_AUTO_SIZE, PP_ALIGN
+from pptx.oxml.ns import qn
+from pptx.util import Emu, Pt
+
+from app.infographics.image import ImageUnavailable, chrome
+from app.slides.decor import Decor, Shape, build
+from app.slides.layout import El, compose
+from app.slides.render import color, deck_print_html, planet_colors
+from app.slides.themes import FONTS, THEMES, H, Palette, W, theme_id
+
+TIMEOUT = 120
+KEEP = 6
+EMU_PX = 6350  # 1920 px = 13.333 in: one pixel is half a point
+
+_cache: OrderedDict[str, bytes] = OrderedDict()
+_lock = Lock()
+
+
+def _cached(key: str, make) -> bytes:
+    with _lock:
+        if key in _cache:
+            _cache.move_to_end(key)
+            return _cache[key]
+    data = make()
+    with _lock:
+        _cache[key] = data
+        while len(_cache) > KEEP:
+            _cache.popitem(last=False)
+    return data
+
+
+def _key(kind: str, deck: dict, theme: str, fmt: str, seed: int) -> str:
+    blob = json.dumps([kind, deck, theme, fmt, seed], sort_keys=True, default=str)
+    return hashlib.sha256(blob.encode()).hexdigest()
+
+
+def _run_chrome(html: str, args: list[str], out_name: str | None) -> tuple[bytes, str]:
+    binary = chrome()
+    if not binary:
+        raise ImageUnavailable("No Chrome is installed here to draw the slides.")
+    with tempfile.TemporaryDirectory() as tmp:
+        src = Path(tmp) / "deck.html"
+        src.write_text(html, encoding="utf-8")
+        out = Path(tmp) / out_name if out_name else None
+        cmd = [binary, "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars",
+               f"--user-data-dir={tmp}/profile", "--virtual-time-budget=10000", "--run-all-compositor-stages-before-draw",
+               *[a.replace("{out}", str(out)) for a in args], f"file://{src}"]
+        try:
+            proc = subprocess.run(cmd, check=True, capture_output=True, timeout=TIMEOUT)
+        except (subprocess.SubprocessError, OSError) as exc:
+            raise ImageUnavailable("The slides could not be drawn.") from exc
+        if out and not out.exists():
+            raise ImageUnavailable("The slides could not be drawn.")
+        return (out.read_bytes() if out else b""), proc.stdout.decode("utf-8", "replace")
+
+
+# --- PDF ------------------------------------------------------------------------------------------------------------
+
+def render_pdf(deck: dict, theme: str, fmt: str, seed: int) -> bytes:
+    """The deck as a PDF, one slide per page at the slide's own size."""
+    theme = theme_id(theme)
+
+    def make() -> bytes:
+        html = deck_print_html(deck, theme, fmt, seed)
+        data, _ = _run_chrome(html, ["--print-to-pdf={out}", "--no-pdf-header-footer", "--print-to-pdf-no-header"],
+                              "deck.pdf")
+        return data
+
+    return _cached(_key("pdf", deck, theme, fmt, seed), make)
+
+
+# --- overflow check -------------------------------------------------------------------------------------------------
+
+_MEASURE = """<script>
+document.fonts.ready.then(function () {
+  var bad = [];
+  document.querySelectorAll('.slide').forEach(function (s, i) {
+    s.querySelectorAll('.t').forEach(function (t) {
+      var inner = t.firstElementChild;  // the text's own height, not its glyphs' ink
+      if (inner.offsetHeight > t.clientHeight + 2 || inner.scrollWidth > t.clientWidth + 2) { if (bad.indexOf(i) < 0) bad.push(i); }
+    });
+  });
+  var out = document.createElement('pre'); out.id = 'overflow'; out.textContent = 'OVERFLOW:' + bad.join(',') + ':END';
+  document.body.appendChild(out);
+});
+</script>"""
+
+
+def overflowing(deck: dict, theme: str, fmt: str, seed: int) -> set[int]:
+    """Indexes of slides where Chrome finds text taller or wider than its box. Raises ImageUnavailable without Chrome."""
+    html = deck_print_html(deck, theme_id(theme), fmt, seed, script=_MEASURE)
+    _, dom = _run_chrome(html, ["--dump-dom"], None)
+    m = re.search(r"OVERFLOW:([0-9,]*):END", dom)
+    if not m:
+        raise ImageUnavailable("The slides could not be measured.")
+    return {int(i) for i in m.group(1).split(",") if i}
+
+
+# --- PowerPoint -----------------------------------------------------------------------------------------------------
+
+def _rgb(hex_: str) -> RGBColor:
+    return RGBColor.from_string(hex_.lstrip("#").upper())
+
+
+def _hex_rgb(hex_: str) -> tuple[int, int, int]:
+    h = hex_.lstrip("#")
+    return int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+
+
+def _gradient_disc(size: int, inner: tuple[int, int, int, int], outer: tuple[int, int, int, int]) -> Image.Image:
+    """A size x size image fading from `inner` at the centre to `outer` at the edge (RGBA)."""
+    mask = Image.radial_gradient("L").resize((size, size))  # 0 in the centre, 255 at the corners
+    mask = mask.point(lambda v: min(255, int(v * 1.42)))  # 255 at the disc's edge
+    a, b = Image.new("RGBA", (size, size), inner), Image.new("RGBA", (size, size), outer)
+    return Image.composite(b, a, mask)
+
+
+def background(decor: Decor, pal: Palette, dark: bool) -> bytes:
+    """The slide's sky and drawing as a JPEG, for the PowerPoint's background."""
+    hx, hy = decor.hot
+    sky = Image.new("RGBA", (W, H), _hex_rgb(pal.bg1) + (255,))
+    big = int(W * 1.7)
+    disc = _gradient_disc(big, _hex_rgb(pal.bg2) + (255,), _hex_rgb(pal.bg1) + (255,))
+    sky.paste(disc, (int(hx - big / 2), int(hy - big / 2)))
+    layer = Image.new("RGBA", (W, H), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(layer)
+    for s in decor.shapes:
+        _draw(sky, layer, draw, s, pal, dark)
+    sky = Image.alpha_composite(sky, layer).convert("RGB")
+    buf = io.BytesIO()
+    sky.save(buf, "JPEG", quality=90)
+    return buf.getvalue()
+
+
+def _draw(sky: Image.Image, layer: Image.Image, draw: ImageDraw.ImageDraw, s: Shape, pal: Palette, dark: bool) -> None:
+    c = _hex_rgb(color(pal, s.color))
+    if s.kind == "stars":
+        for x, y, r, o in s.points:
+            draw.ellipse((x - r, y - r, x + r, y + r), fill=c + (int(255 * o),))
+    elif s.kind == "glow":
+        size = int(s.r * 2)
+        if size < 4:
+            return
+        _paste_clipped(sky, _gradient_disc(size, c + (int(255 * s.opacity),), c + (0,)), s.cx - s.r, s.cy - s.r)
+    elif s.kind == "planet":
+        hi, lo, rim = planet_colors(pal, dark)
+        size = int(s.r * 2)
+        if size < 4:
+            return
+        disc = Image.new("RGBA", (size, size), _hex_rgb(lo) + (255,))
+        shine = _gradient_disc(int(size * 1.6), _hex_rgb(hi) + (255,), _hex_rgb(lo) + (0,))
+        _paste_clipped(disc, shine, -size * 0.45, -size * 0.52)  # lit from the upper left, as in the page's gradient
+        mask = Image.new("L", (size, size), 0)
+        ImageDraw.Draw(mask).ellipse((0, 0, size - 1, size - 1), fill=255)
+        disc.putalpha(mask)
+        _paste_clipped(sky, disc, s.cx - s.r, s.cy - s.r)
+        draw.ellipse((s.cx - s.r, s.cy - s.r, s.cx + s.r, s.cy + s.r), outline=_hex_rgb(rim) + (180,), width=3)
+    elif s.kind == "ring":
+        steps = 360
+        rot = math.radians(s.rot)
+        pts = []
+        for k in range(steps + 1):
+            a = 2 * math.pi * k / steps
+            x, y = s.rx * math.cos(a), s.ry * math.sin(a)
+            pts.append((s.cx + x * math.cos(rot) - y * math.sin(rot), s.cy + x * math.sin(rot) + y * math.cos(rot)))
+        draw.line(pts, fill=c + (int(255 * s.opacity),), width=max(1, round(s.width)))
+    elif s.kind == "const":
+        for a, b in s.edges:
+            (x1, y1, *_), (x2, y2, *_) = s.points[a], s.points[b]
+            draw.line((x1, y1, x2, y2), fill=c + (int(255 * s.opacity * 0.5),), width=2)
+        for x, y, r, _ in s.points:
+            draw.ellipse((x - r, y - r, x + r, y + r), fill=c + (int(255 * s.opacity),))
+
+
+def _paste_clipped(base: Image.Image, img: Image.Image, x: float, y: float) -> None:
+    """alpha_composite `img` onto `base` at (x, y), clipping whatever falls outside."""
+    x, y = int(x), int(y)
+    left, top = max(0, -x), max(0, -y)
+    right, bottom = min(img.width, base.width - x), min(img.height, base.height - y)
+    if right <= left or bottom <= top:
+        return
+    base.alpha_composite(img.crop((left, top, right, bottom)), (x + left, y + top))
+
+
+def _emu(px: float) -> Emu:
+    return Emu(int(round(px * EMU_PX)))
+
+
+def _no_style(shape) -> None:
+    """Drop the theme's default shape style (shadows, outlines) so only what we set is drawn."""
+    style = shape._element.find(qn("p:style"))
+    if style is not None:
+        shape._element.remove(style)
+
+
+def _alpha(fill_fore_color_el, opacity: float) -> None:
+    if opacity >= 1:
+        return
+    clr = fill_fore_color_el.find(qn("a:srgbClr"))
+    if clr is not None:
+        a = clr.makeelement(qn("a:alpha"), {"val": str(int(opacity * 100000))})
+        clr.append(a)
+
+
+def _add_el(slide, e: El, pal: Palette) -> None:
+    if e.kind == "text":
+        box = slide.shapes.add_textbox(_emu(e.x), _emu(e.y), _emu(e.w), _emu(e.h))
+        tf = box.text_frame
+        tf.word_wrap = True
+        tf.auto_size = MSO_AUTO_SIZE.NONE
+        tf.margin_left = tf.margin_right = tf.margin_top = tf.margin_bottom = 0
+        tf.vertical_anchor = {"middle": MSO_ANCHOR.MIDDLE, "bottom": MSO_ANCHOR.BOTTOM}.get(e.valign, MSO_ANCHOR.TOP)
+        for i, runs in enumerate(e.paras):
+            p = tf.paragraphs[0] if i == 0 else tf.add_paragraph()
+            p.alignment = {"center": PP_ALIGN.CENTER, "right": PP_ALIGN.RIGHT}.get(e.align, PP_ALIGN.LEFT)
+            p.line_spacing = e.lh * 0.96
+            if i and e.gap:
+                p.space_before = Pt(e.gap * 0.5)
+            for r in runs:
+                run = p.add_run()
+                run.text = r.text
+                f = run.font
+                f.name = FONTS[e.font]
+                f.size = Pt(e.size * 0.5)
+                f.bold = r.bold or e.font == "display"
+                f.color.rgb = _rgb(color(pal, r.color))
+                rpr = run._r.get_or_add_rPr()
+                if e.upper:
+                    rpr.set("cap", "all")
+                if e.track:
+                    rpr.set("spc", str(int(e.track * e.size * 0.5 * 100)))
+        return
+    if e.kind == "line":
+        horizontal = e.h == 0
+        x2, y2 = (e.x + e.w, e.y) if horizontal else (e.x, e.y + e.h)
+        ln = slide.shapes.add_connector(MSO_CONNECTOR.STRAIGHT, _emu(e.x), _emu(e.y), _emu(x2), _emu(y2))
+        _no_style(ln)
+        ln.line.color.rgb = _rgb(color(pal, e.stroke))
+        ln.line.width = _emu(e.stroke_w)
+        return
+    kind = MSO_SHAPE.OVAL if e.kind == "circle" else (MSO_SHAPE.ROUNDED_RECTANGLE if e.radius else MSO_SHAPE.RECTANGLE)
+    sh = slide.shapes.add_shape(kind, _emu(e.x), _emu(e.y), _emu(e.w), _emu(e.h))
+    _no_style(sh)
+    if kind == MSO_SHAPE.ROUNDED_RECTANGLE:
+        sh.adjustments[0] = min(0.5, e.radius / max(min(e.w, e.h), 1))
+    if e.fill:
+        sh.fill.solid()
+        sh.fill.fore_color.rgb = _rgb(color(pal, e.fill))
+        _alpha(sh.fill._xPr.find(qn("a:solidFill")), e.opacity)
+    else:
+        sh.fill.background()
+    if e.stroke and e.stroke_w:
+        sh.line.color.rgb = _rgb(color(pal, e.stroke))
+        sh.line.width = _emu(e.stroke_w)
+    else:
+        sh.line.fill.background()
+
+
+def _notes(slide_data: dict) -> str:
+    notes = slide_data.get("notes") or ""
+    srcs = [f"{s.get('title') or s['path']} (lines {s['line_start']}-{s['line_end']})" for s in slide_data.get("sources") or []]
+    return notes + (("\n\nSources: " + "; ".join(dict.fromkeys(srcs))) if srcs else "")
+
+
+def build_pptx(deck: dict, theme: str, fmt: str, seed: int) -> bytes:
+    """The deck as an editable PowerPoint: text boxes you can type in, over each slide's drawn background."""
+    theme = theme_id(theme)
+
+    def make() -> bytes:
+        t = THEMES[theme]
+        prs = Presentation()
+        prs.slide_width, prs.slide_height = _emu(W), _emu(H)
+        blank = prs.slide_layouts[6]
+        for i in range(len(deck["slides"])):
+            c = compose(deck, i, theme, fmt, seed)
+            slide = prs.slides.add_slide(blank)
+            d = build(theme, c.slide["layout"], c.slide["variant"], seed, i)
+            slide.shapes.add_picture(io.BytesIO(background(d, t.pal, t.dark)), 0, 0, _emu(W), _emu(H))
+            for e in c.elements:
+                _add_el(slide, e, t.pal)
+            note = _notes(c.slide)
+            if note:
+                slide.notes_slide.notes_text_frame.text = note
+        prs.core_properties.title = deck.get("title") or "Slide deck"
+        buf = io.BytesIO()
+        prs.save(buf)
+        return buf.getvalue()
+
+    return _cached(_key("pptx", deck, theme, fmt, seed), make)

backend/app/slides/layout.py

@@ -0,0 +1,730 @@
+"""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.
+# Dark space: cinematic, centred openers and closers, asymmetric splits. 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(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(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"
+
+
+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. Presenter slides carry fewer words, so they are drawn larger.
+TYPE = {
+    "detailed": {"kicker": 22, "heading": 60, "title": 100, "section": 80, "lead": 30, "title_lead": 34, "point": 28,
+                 "card_term": 30, "card_text": 25, "value": 220, "label": 34, "quote": 52, "by": 24, "take": 28,
+                 "closing": 46, "closing_big": 66, "agenda": 32, "col_label": 28, "col_item": 27, "num": 22,
+                 "footer": 18},
+    "presenter": {"kicker": 24, "heading": 72, "title": 112, "section": 92, "lead": 36, "title_lead": 38,
+                  "point": 40, "card_term": 34, "card_text": 34, "value": 260, "label": 40, "quote": 60, "by": 26,
+                  "take": 36, "closing": 56, "closing_big": 78, "agenda": 36, "col_label": 30, "col_item": 36,
+                  "num": 24, "footer": 18},
+}
+
+
+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, fmt: str) -> list[Run]:
+    if p["term"] and fmt == "detailed":
+        return [Run(p["term"] + ".", True, "ink"), Run(" " + p["text"], False, "mute")]
+    return [Run(p["text"], False, "ink")]
+
+
+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")] for p in pts]
+            base, numbered = t["agenda"], True
+        elif kind == "take_stack":
+            items = [[Run(tx, False, "ink")] for tx in s["takeaways"]]
+            base, numbered = t["take"], True
+        else:
+            items = [_point_runs(p, fmt) for p in 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")]], size=ts,
+                              lh=1.15, font="display", align=align))
+                cy += th + ts * 0.5
+            els.append(El("text", "item", cx + pad, cy, inner_w, y + h - pad - cy, paras=[[Run(text, False, "mute" if term else "ink")]],
+                          size=xs, lh=1.4, align=align))
+        return
+
+    if kind in ("timeline_v", "timeline_h"):
+        items = [_point_runs(p, fmt) for p in 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 col, (x, y, w, h, *_) in zip(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")]],
+                          size=ls, lh=1.2, font="display"))
+            cy += lab_h + xs * 0.9
+        for item, hh in 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")]], 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")]], 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_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")]], base, start, lh=1.4, field_name="lead"))
+
+    if layout == "stat":
+        els.append(_text("value", rect("value"), [[Run(s["stat"]["value"], True, "accent")]], t["value"], start,
+                         font="display", lh=1.0, field_name="stat_value"))
+        els.append(_text("label", rect("label"), [[Run(s["stat"]["label"], False, "ink")]], 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"),
+                                       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")]], 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")]], 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")]], 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)

backend/app/slides/metrics.py

@@ -0,0 +1,39 @@
+"""Advance widths (in em) of the characters slides use most, measured in Chrome with the fonts the slides load
+(Space Grotesk bold for headings, Inter regular and bold for text). Text is measured with these before it is placed,
+so a line breaks where the browser will break it. Regenerate if the fonts change: draw each character ten times
+between two x's at 100px in headless Chrome and subtract the width of "xx"."""
+
+CHARS = "".join(chr(c) for c in range(32, 127)) + "\u2026\u201c\u201d\u2018\u2019\u2013\u2014\u00e9"
+
+_DISPLAY_BOLD = (
+    0.254, 0.298, 0.514, 0.636, 0.606, 0.758, 0.591, 0.294, 0.398, 0.390, 0.540, 0.620, 0.294, 0.425, 0.298, 0.388,
+    0.648, 0.452, 0.594, 0.608, 0.636, 0.600, 0.618, 0.554, 0.600, 0.618, 0.298, 0.298, 0.620, 0.620, 0.620, 0.578,
+    1.014, 0.634, 0.664, 0.644, 0.646, 0.554, 0.534, 0.662, 0.656, 0.264, 0.578, 0.626, 0.542, 0.882, 0.670, 0.676,
+    0.604, 0.676, 0.632, 0.606, 0.580, 0.672, 0.616, 0.898, 0.644, 0.617, 0.576, 0.358, 0.388, 0.358, 0.620, 0.620,
+    0.296, 0.577, 0.635, 0.580, 0.635, 0.571, 0.337, 0.635, 0.616, 0.266, 0.268, 0.564, 0.266, 0.854, 0.616, 0.606,
+    0.635, 0.635, 0.396, 0.522, 0.391, 0.616, 0.548, 0.784, 0.592, 0.616, 0.518, 0.466, 0.258, 0.466, 0.620, 0.798,
+    0.514, 0.514, 0.294, 0.294, 0.577, 0.881, 0.571,
+)
+
+_BODY = (
+    0.281, 0.288, 0.466, 0.633, 0.642, 0.982, 0.644, 0.300, 0.365, 0.365, 0.501, 0.657, 0.288, 0.455, 0.288, 0.360,
+    0.631, 0.407, 0.610, 0.618, 0.646, 0.593, 0.620, 0.584, 0.619, 0.620, 0.288, 0.302, 0.662, 0.655, 0.662, 0.511,
+    0.966, 0.703, 0.654, 0.730, 0.722, 0.601, 0.590, 0.746, 0.743, 0.269, 0.571, 0.672, 0.565, 0.903, 0.753, 0.765,
+    0.639, 0.765, 0.644, 0.642, 0.633, 0.744, 0.703, 1.007, 0.682, 0.679, 0.629, 0.365, 0.316, 0.365, 0.471, 0.456,
+    0.323, 0.562, 0.610, 0.567, 0.610, 0.579, 0.337, 0.611, 0.591, 0.242, 0.242, 0.549, 0.242, 0.876, 0.591, 0.595,
+    0.610, 0.610, 0.392, 0.528, 0.329, 0.591, 0.562, 0.818, 0.546, 0.562, 0.552, 0.426, 0.333, 0.426, 0.657, 0.864,
+    0.440, 0.440, 0.261, 0.261, 0.500, 1.000, 0.579,
+)
+
+_BODY_BOLD = (
+    0.237, 0.338, 0.551, 0.649, 0.655, 1.015, 0.672, 0.339, 0.377, 0.377, 0.559, 0.674, 0.334, 0.463, 0.334, 0.388,
+    0.674, 0.431, 0.630, 0.645, 0.676, 0.622, 0.650, 0.599, 0.651, 0.650, 0.334, 0.343, 0.679, 0.672, 0.679, 0.559,
+    1.016, 0.760, 0.662, 0.740, 0.722, 0.607, 0.587, 0.751, 0.747, 0.281, 0.584, 0.719, 0.565, 0.932, 0.762, 0.770,
+    0.648, 0.777, 0.657, 0.655, 0.661, 0.732, 0.760, 1.057, 0.738, 0.731, 0.664, 0.377, 0.344, 0.377, 0.487, 0.476,
+    0.365, 0.580, 0.628, 0.584, 0.628, 0.592, 0.362, 0.630, 0.623, 0.271, 0.271, 0.580, 0.271, 0.912, 0.622, 0.609,
+    0.628, 0.628, 0.415, 0.560, 0.358, 0.623, 0.600, 0.850, 0.580, 0.602, 0.573, 0.469, 0.372, 0.469, 0.674, 1.002,
+    0.540, 0.532, 0.311, 0.311, 0.500, 1.000, 0.592,
+)
+
+WIDTHS = {name: dict(zip(CHARS, table, strict=True)) for name, table in
+          (("display_bold", _DISPLAY_BOLD), ("body", _BODY), ("body_bold", _BODY_BOLD))}

backend/app/slides/render.py

@@ -0,0 +1,145 @@
+"""A deck as HTML: one standalone page per slide (shown in the app in a sandboxed frame, scaled to fit) and one page
+with every slide (printed to PDF). Every word from the model is escaped; the markup is all ours."""
+
+from markupsafe import escape
+
+from app.slides.decor import Decor, Shape, build
+from app.slides.layout import Composed, El, compose
+from app.slides.themes import FONTS, THEMES, H, Palette, W, theme_id
+
+FONT_LINK = ("https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@500;700&family=Inter:wght@400;500;700"
+             "&family=JetBrains+Mono:wght@400;700&display=swap")
+
+_FAMILY = {"display": f"'{FONTS['display']}','{FONTS['body']}',sans-serif", "body": f"'{FONTS['body']}',sans-serif",
+           "mono": f"'{FONTS['mono']}',monospace"}
+
+
+def color(pal: Palette, key: str | None) -> str:
+    if not key:
+        return "transparent"
+    return "#ffffff" if key == "white" else getattr(pal, key)
+
+
+CSS = f"""
+html,body{{margin:0;padding:0}}
+.slide{{position:relative;width:{W}px;height:{H}px;overflow:hidden;font-family:{_FAMILY['body']};
+  -webkit-font-smoothing:antialiased;text-rendering:optimizeLegibility}}
+.slide svg.bg{{position:absolute;inset:0}}
+.e{{position:absolute;box-sizing:border-box;margin:0}}
+.t{{display:flex;flex-direction:column;overflow:visible;overflow-wrap:anywhere}}
+.t>.in{{display:block}}
+.t.v-middle{{justify-content:center}}.t.v-bottom{{justify-content:flex-end}}
+.t p{{margin:0}}
+.t b{{font-weight:700}}
+.r-heading,.r-quote,.r-closing,.r-term{{text-wrap:balance}}
+.dark .r-heading.l-title,.dark .r-value{{text-shadow:0 0 48px rgba(33,124,255,.45)}}
+.dark .r-marker{{box-shadow:0 0 36px rgba(33,124,255,.75)}}
+.dark .r-bar{{box-shadow:0 0 18px rgba(77,148,255,.8)}}
+.light .r-card,.light .r-panel{{box-shadow:0 18px 44px rgba(11,26,58,.08)}}
+.light .r-band{{box-shadow:0 18px 44px rgba(11,26,58,.18)}}
+"""
+
+
+def _style(**kw) -> str:
+    return ";".join(f"{k.replace('_', '-')}:{v}" for k, v in kw.items() if v is not None)
+
+
+def _el(e: El, pal: Palette, layout: str) -> str:
+    box = dict(left=f"{e.x:.1f}px", top=f"{e.y:.1f}px", width=f"{e.w:.1f}px", height=f"{e.h:.1f}px")
+    if e.kind == "text":
+        paras = []
+        for i, p in enumerate(e.paras):
+            runs = "".join(
+                f'<span style="color:{color(pal, r.color)}{";font-weight:700" if r.bold else ""}">{escape(r.text)}</span>'
+                for r in p)
+            gap = f' style="margin-top:{e.gap:.1f}px"' if i and e.gap else ""
+            paras.append(f"<p{gap}>{runs}</p>")
+        css = _style(**box, font_size=f"{e.size}px", line_height=str(e.lh), font_family=_FAMILY[e.font],
+                     text_align=e.align, letter_spacing=f"{e.track}em" if e.track else None,
+                     text_transform="uppercase" if e.upper else None,
+                     font_weight="700" if e.font == "display" else None)
+        return f'<div class="e t r-{e.role} l-{layout} v-{e.valign}" style="{css}"><div class="in">{"".join(paras)}</div></div>'
+    if e.kind == "line":
+        horizontal = e.h == 0
+        css = _style(left=f"{e.x:.1f}px", top=f"{e.y - (e.stroke_w / 2 if horizontal else 0):.1f}px",
+                     width=f"{e.w if horizontal else e.stroke_w:.1f}px", height=f"{e.stroke_w if horizontal else e.h:.1f}px",
+                     background=color(pal, e.stroke), border_radius="2px")
+        return f'<div class="e r-{e.role}" style="{css}"></div>'
+    radius = "50%" if e.kind == "circle" else f"{e.radius}px"
+    border = f"{e.stroke_w}px solid {color(pal, e.stroke)}" if e.stroke and e.stroke_w else None
+    css = _style(**box, background=color(pal, e.fill), border=border, border_radius=radius,
+                 opacity=str(e.opacity) if e.opacity < 1 else None)
+    return f'<div class="e r-{e.role}" style="{css}"></div>'
+
+
+def _svg(d: Decor, pal: Palette, dark: bool, uid: str) -> str:
+    defs, out = [], []
+    for n, s in enumerate(d.shapes):
+        out.append(_shape(s, pal, dark, f"{uid}{n}", defs))
+    hx, hy = d.hot
+    sky = (f'<radialGradient id="{uid}sky" gradientUnits="userSpaceOnUse" cx="{hx:.0f}" cy="{hy:.0f}" r="{W * 0.85:.0f}">'
+           f'<stop offset="0" stop-color="{pal.bg2}"/><stop offset="1" stop-color="{pal.bg1}"/></radialGradient>')
+    return (f'<svg class="bg" width="{W}" height="{H}" viewBox="0 0 {W} {H}"><defs>{sky}{"".join(defs)}</defs>'
+            f'<rect width="{W}" height="{H}" fill="url(#{uid}sky)"/>{"".join(out)}</svg>')
+
+
+def _shape(s: Shape, pal: Palette, dark: bool, gid: str, defs: list[str]) -> str:
+    c = color(pal, s.color)
+    if s.kind == "stars":
+        return "".join(f'<circle cx="{x:.0f}" cy="{y:.0f}" r="{r}" fill="{c}" opacity="{o}"/>' for x, y, r, o in s.points)
+    if s.kind == "glow":
+        defs.append(f'<radialGradient id="{gid}"><stop offset="0" stop-color="{c}" stop-opacity="{s.opacity}"/>'
+                    f'<stop offset="1" stop-color="{c}" stop-opacity="0"/></radialGradient>')
+        return f'<circle cx="{s.cx:.0f}" cy="{s.cy:.0f}" r="{s.r:.0f}" fill="url(#{gid})"/>'
+    if s.kind == "planet":
+        hi, lo, rim = planet_colors(pal, dark)
+        defs.append(f'<radialGradient id="{gid}" cx="35%" cy="28%" r="80%"><stop offset="0" stop-color="{hi}"/>'
+                    f'<stop offset="1" stop-color="{lo}"/></radialGradient>')
+        return (f'<circle cx="{s.cx:.0f}" cy="{s.cy:.0f}" r="{s.r:.0f}" fill="url(#{gid})"/>'
+                f'<circle cx="{s.cx:.0f}" cy="{s.cy:.0f}" r="{s.r:.0f}" fill="none" stroke="{rim}" stroke-width="3" opacity=".7"/>')
+    if s.kind == "ring":
+        return (f'<ellipse cx="{s.cx:.0f}" cy="{s.cy:.0f}" rx="{s.rx:.0f}" ry="{s.ry:.0f}" fill="none" stroke="{c}" '
+                f'stroke-width="{s.width}" opacity="{s.opacity}" transform="rotate({s.rot:.1f} {s.cx:.0f} {s.cy:.0f})"/>')
+    if s.kind == "const":
+        lines = "".join(f'<line x1="{s.points[a][0]:.0f}" y1="{s.points[a][1]:.0f}" x2="{s.points[b][0]:.0f}" '
+                        f'y2="{s.points[b][1]:.0f}" stroke="{c}" stroke-width="1.6" opacity="{s.opacity * 0.5:.2f}"/>'
+                        for a, b in s.edges)
+        dots = "".join(f'<circle cx="{x:.0f}" cy="{y:.0f}" r="{r}" fill="{c}" opacity="{s.opacity}"/>' for x, y, r, _ in s.points)
+        return lines + dots
+    return ""
+
+
+def planet_colors(pal: Palette, dark: bool) -> tuple[str, str, str]:
+    """Lit side, dark side and rim of a planet."""
+    return ("#1d4fb3", "#020713", pal.accent) if dark else ("#5d9bff", pal.accent2, pal.accent)
+
+
+def slide_body(c: Composed, deck: dict, index: int, theme: str) -> str:
+    t = THEMES[theme]
+    s = c.slide
+    d = build(theme, s["layout"], s["variant"], c.seed, index)
+    els = "".join(_el(e, t.pal, s["layout"]) for e in c.elements)
+    cls = f"slide {'dark' if t.dark else 'light'} l-{s['layout']} v-{s['variant']}"
+    return f'<div class="{cls}" style="background:{t.pal.bg1}">{_svg(d, t.pal, t.dark, f"s{index}g")}{els}</div>'
+
+
+def _page(body: str, extra_css: str = "") -> str:
+    return (f'<!doctype html><html><head><meta charset="utf-8"><link rel="stylesheet" href="{FONT_LINK}">'
+            f"<style>{CSS}{extra_css}</style></head><body>{body}</body></html>")
+
+
+def slide_html(deck: dict, index: int, theme: str, fmt: str, seed: int) -> str:
+    """One slide as a standalone page."""
+    theme = theme_id(theme)
+    return _page(slide_body(compose(deck, index, theme, fmt, seed), deck, index, theme),
+                 f"body{{background:{THEMES[theme].pal.bg1}}}")
+
+
+def deck_print_html(deck: dict, theme: str, fmt: str, seed: int, script: str = "") -> str:
+    """Every slide on one page, one per printed page."""
+    theme = theme_id(theme)
+    body = "".join(slide_body(compose(deck, i, theme, fmt, seed), deck, i, theme) for i in range(len(deck["slides"])))
+    css = (f"@page{{size:{W}px {H}px;margin:0}}body{{background:{THEMES[theme].pal.bg1}}}"
+           ".slide{break-after:page;page-break-after:always}.slide:last-child{break-after:auto;page-break-after:auto}"
+           "*{-webkit-print-color-adjust:exact;print-color-adjust:exact}")
+    return _page(body + script, css)

backend/app/slides/themes.py

@@ -0,0 +1,47 @@
+"""The two deck themes. Both are space themes in the app's own palette (black, #217cff, white): one on a night sky, one
+on a pale daylight sky. Colours are plain hex so the HTML and the PowerPoint use exactly the same values."""
+
+from dataclasses import dataclass
+
+W, H = 1920, 1080  # every slide is drawn at this size
+
+
+@dataclass(frozen=True)
+class Palette:
+    bg1: str  # sky at the edges
+    bg2: str  # sky at its brightest point
+    ink: str  # headings and body text
+    mute: str  # secondary text
+    accent: str  # kickers, numbers, markers
+    accent2: str  # second accent (planets, rings)
+    card: str  # card and panel fill
+    cardline: str  # card and panel border
+    line: str  # rules and dividers
+    band: str  # the closing band
+    bandink: str  # text on the band
+    star: str  # star colour
+
+
+@dataclass(frozen=True)
+class Theme:
+    id: str
+    name: str
+    dark: bool
+    pal: Palette
+
+
+THEMES: dict[str, Theme] = {t.id: t for t in (
+    Theme("dark-space", "Dark space", True, Palette(
+        bg1="#000000", bg2="#0a1736", ink="#ffffff", mute="#b4bccc", accent="#4d94ff", accent2="#217cff",
+        card="#0b1326", cardline="#1f3156", line="#26385c", band="#0e1c3d", bandink="#ffffff", star="#ffffff")),
+    Theme("light-space", "Light space", False, Palette(
+        bg1="#e9eef9", bg2="#ffffff", ink="#0b1a3a", mute="#4b5a7a", accent="#217cff", accent2="#0b3d91",
+        card="#ffffff", cardline="#d3dcef", line="#c6d1ea", band="#0b1a3a", bandink="#ffffff", star="#0b1a3a")),
+)}
+DEFAULT_THEME = "dark-space"
+
+FONTS = {"display": "Space Grotesk", "body": "Inter", "mono": "JetBrains Mono"}
+
+
+def theme_id(value: object) -> str:
+    return value if isinstance(value, str) and value in THEMES else DEFAULT_THEME

backend/app/worker.py

@@ -45,7 +45,7 @@ from app.models import (
     Workspace,
     WorkspaceMember,
 )
-from app.pipeline import flashcards, generate, infographic, launchkit, media, quiz, report
+from app.pipeline import flashcards, generate, infographic, launchkit, media, quiz, report, slides
 from app.pipeline.generate import NothingToDo
 from app.pipeline.ingest import FeedNotFound, entry_from_upload, extract_article, ingest_source, store_entries
 from app.pipeline.memory import learn_from_message
@@ -295,6 +295,7 @@ HANDLERS: dict[str, Callable[[Session, Job], object]] = {
     "flashcards": _artifact_handler(flashcards.build_flashcards, "Flashcards ready"),
     "report": _artifact_handler(report.build_report, "Report ready"),
     "infographic": _artifact_handler(infographic.build_infographic, "Infographic ready"),
+    "slide_deck": _artifact_handler(slides.build_slide_deck, "Slide deck ready"),
     "report_block": report.handle_report_block,
     "audio_overview": _artifact_handler(media.audio_overview, "Audio overview ready"),
     "video": _artifact_handler(media.make_video, "Audiogram ready"),  # audiograms; videos come from blog2video
@@ -338,9 +339,10 @@ def run_job(
             mark_artifact_failed(db, job, str(exc))
             return
         except Exception as exc:
-            log.exception("job %s (%s) attempt %s failed", job.id, job.kind, job.attempts)
+            # Roll back first: after a failed flush, touching `job` raises PendingRollbackError.
             db.rollback()
             job = db.get(Job, job_id)
+            log.exception("job %s (%s) attempt %s failed", job_id, job.kind, job.attempts)
             if not retry_or_fail(db, job, f"{type(exc).__name__}: {exc}"):
                 mark_artifact_failed(db, job, f"{type(exc).__name__}: {exc}")
             return
@@ -489,6 +491,15 @@ def run_periodic(now: float) -> None:
 # Main loop
 
 
+def _log_crash(job_id: uuid.UUID) -> Callable[[Future], None]:
+    """run_job handles job errors itself; anything escaping it would otherwise vanish inside the Future and leave
+    the job 'running' until recover_stale."""
+    def callback(future: Future) -> None:
+        if exc := future.exception():
+            log.error("job %s crashed outside its error handling", job_id, exc_info=exc)
+    return callback
+
+
 def run_loop(stop: threading.Event, worker_id: str | None = None) -> None:
     """Claim and run jobs until `stop` is set. Used by the CLI and, in development, by the API."""
     worker_id = worker_id or f"{socket.gethostname()}:{os.getpid()}"
@@ -509,7 +520,9 @@ def run_loop(stop: threading.Event, worker_id: str | None = None) -> None:
                 break
             if not job_id:
                 break
-            running.add(pool.submit(run_job, job_id))
+            future = pool.submit(run_job, job_id)
+            future.add_done_callback(_log_crash(job_id))
+            running.add(future)
             claimed = True
         if not claimed:
             stop.wait(settings.worker_poll_seconds)

backend/requirements.txt

@@ -19,6 +19,7 @@ rank-bm25==0.2.*
 feedparser==6.*
 beautifulsoup4==4.*
 pypdf==5.*
+python-pptx==1.*
 stripe==13.*
 jinja2==3.*
 

backend/scripts/render_slide_thumbnails.py

@@ -0,0 +1,44 @@
+"""Draws a sample opening slide in each slide deck theme with a local Chrome, for the theme picker's thumbnails.
+
+  python scripts/render_slide_thumbnails.py      # writes ../frontend/public/slides/<theme>.png
+Set CHROME to the browser binary if it is not found (see app.infographics.image.chrome)."""
+
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from PIL import Image  # noqa: E402
+
+from app.infographics.image import chrome  # noqa: E402
+from app.slides.content import clamp_deck  # noqa: E402
+from app.slides.render import slide_html  # noqa: E402
+from app.slides.themes import THEMES  # noqa: E402
+
+SAMPLE = {"title": "Your ideas, in orbit", "slides": [
+    {"layout": "title", "kicker": "Slide deck", "heading": "Your ideas, in orbit",
+     "lead": "Every post you have written, turned into a story worth presenting."},
+]}
+
+PICK = {"dark-space": "b", "light-space": "a"}  # each theme's most telling opener
+
+if __name__ == "__main__":
+    binary = chrome()
+    if not binary:
+        sys.exit("No Chrome found: set CHROME")
+    folder = Path(__file__).resolve().parents[2] / "frontend/public/slides"
+    folder.mkdir(parents=True, exist_ok=True)
+    deck = clamp_deck(SAMPLE, "presenter")
+    for tid in THEMES:
+        deck["slides"][0]["variant"] = PICK[tid]
+        with tempfile.TemporaryDirectory() as tmp:
+            src, shot = Path(tmp) / "s.html", Path(tmp) / "s.png"
+            src.write_text(slide_html(deck, 0, tid, "presenter", 2024), encoding="utf-8")
+            subprocess.run([binary, "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars",
+                            "--force-device-scale-factor=1", f"--user-data-dir={tmp}/p", "--window-size=1920,1080",
+                            "--virtual-time-budget=8000", f"--screenshot={shot}", f"file://{src}"],
+                           check=True, capture_output=True, timeout=120)
+            Image.open(shot).convert("RGB").resize((800, 450), Image.LANCZOS).save(folder / f"{tid}.png", optimize=True)
+        print(folder / f"{tid}.png")

backend/tests/test_buildout.py

@@ -447,7 +447,7 @@ def test_audio_overview_and_limits(client, auth, run_jobs, feed, llm, monkeypatc
     client.put("/api/voice", json={"host_voices": {"host_a": "voiceA", "host_b": "voiceB"},
                                    "delivery": {"host_b": {"stability": 0.9, "similarity_boost": 0.7,
                                                            "style": 0.1, "speed": 1.1}}}, headers=auth)
-    llm["PodcastScript"] = {"lines": [
+    llm["WriteAudioScript"] = {"turns": [
         {"speaker": "host_a", "text": "Welcome in.", "sources": []},
         {"speaker": "host_b", "text": "Prices went up.", "sources": [{"path": doc["path"], "line_start": 12,
                                                                       "line_end": 13}]},
@@ -1094,8 +1094,8 @@ def test_audio_overview_hosts_are_picked_from_the_voices(client, auth, run_jobs,
     used = []
     monkeypatch.setattr(tts, "synthesize", lambda ws, text, voice, vs=None, *a: used.append((text, voice)) or
                         b"\x00" * 16000)
-    llm["PodcastScript"] = {"lines": [{"speaker": "host_a", "text": "Welcome in.", "sources": []},
-                                      {"speaker": "host_b", "text": "Thanks.", "sources": []}]}
+    llm["WriteAudioScript"] = {"turns": [{"speaker": "host_a", "text": "Welcome in.", "sources": []},
+                                         {"speaker": "host_b", "text": "Thanks.", "sources": []}]}
     ws_id = db_session.get(Document, uuid.UUID(doc["id"])).workspace_id
     db_session.add_all([UserSavedVoice(workspace_id=ws_id, voice_id=v, name=v) for v in ("mine-1", "mine-2")])
     db_session.commit()
@@ -1116,6 +1116,59 @@ def test_audio_overview_hosts_are_picked_from_the_voices(client, auth, run_jobs,
     assert voices == {"host_a": settings.elevenlabs_voice_a, "host_b": settings.elevenlabs_voice_b}
 
 
+def test_audio_overview_alternates_two_hosts_or_uses_one(client, auth, run_jobs, feed, llm, monkeypatch, db_session):
+    from app.config import settings
+    from app.services import tts
+
+    connect(client, auth, run_jobs)
+    pricing = next(d for d in docs(client, auth) if d["title"] == "On Pricing")
+    nb = client.post("/api/notebooks", json={"title": "Money", "document_ids": [pricing["id"]]}, headers=auth).json()
+    monkeypatch.setattr(settings, "elevenlabs_api_key", "test")
+    used = []
+    monkeypatch.setattr(tts, "synthesize", lambda ws, text, voice, vs=None, *a: used.append((text, voice)) or
+                        b"\x00" * 16000)
+    seen = {}
+
+    def script(**kw):
+        seen.update(kw)
+        return {"turns": [  # host A twice in a row, **markup**, an empty turn: cleaned and made to alternate
+            {"speaker": "host_a", "text": "Welcome in.", "sources": []},
+            {"speaker": "host_a", "text": "Today, **pricing**.", "sources": []},
+            {"speaker": "host_b", "text": "", "sources": []},
+            {"speaker": "host_b", "text": "Prices went up.", "sources": []},
+            {"speaker": "host_b", "text": "And readers stayed.", "sources": []},
+            {"speaker": "host_a", "text": "Exactly.", "sources": []},
+        ]}
+
+    llm["WriteAudioScript"] = script
+    body = {"type": "audio_overview", "notebook_id": nb["id"], "document_ids": [pricing["id"]], "minutes": 3,
+            "format": "critique", "language": "Spanish", "instructions": "- Focus on raising prices"}
+    art = client.post("/api/artifacts/generate", json=body, headers=auth).json()
+    run_jobs()
+    done = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
+    assert done["status"] == "ready", done["content"]
+    segs = done["content"]["segments"]
+    assert [(s["speaker"], s["text"]) for s in segs] == [
+        ("host_a", "Welcome in. Today, pricing."), ("host_b", "Prices went up. And readers stayed."), ("host_a", "Exactly.")]
+    assert seen["hosts"] == 2 and seen["target_words"] == 450 and seen["language"] == "Spanish"
+    assert seen["focus"] == "- Focus on raising prices" and seen["style"].startswith("Critique")
+    assert any(pricing["path"] in m for m in seen["material"])  # the picked post is what the script reads
+    voices = done["content"]["voices"]
+    assert used[1][1] == voices["host_b"] != voices["host_a"] == used[0][1]
+
+    used.clear()
+    one = client.post("/api/artifacts/generate", json={**body, "hosts": 1, "format": "brief"}, headers=auth).json()
+    run_jobs()
+    done = client.get(f"/api/artifacts/{one['id']}", headers=auth).json()
+    assert {s["speaker"] for s in done["content"]["segments"]} == {"host_a"} and seen["hosts"] == 1
+    assert list(done["content"]["voices"]) == ["host_a"] and {v for _, v in used} == {done["content"]["voices"]["host_a"]}
+    assert done["content"]["hosts"] == 1 and done["content"]["focus"] == "- Focus on raising prices"
+
+    r = client.post("/api/artifacts/generate", json={**body, "hosts": 1, "format": "debate"}, headers=auth)
+    assert r.status_code == 400 and "two hosts" in r.json()["detail"]
+    assert client.post("/api/artifacts/generate", json={**body, "document_ids": []}, headers=auth).status_code == 400
+
+
 def test_tts_retries_rate_limits(monkeypatch):
     from app.config import settings
     from app.services import tts

backend/tests/test_slides.py

@@ -0,0 +1,438 @@
+"""Slide decks: what the model writes is clamped to a fixed shape, laid out by code in either theme, checked against
+the sources, and drawn the same way as pages, a PDF and an editable PowerPoint. The LLM is faked at app.llm.run."""
+
+import copy
+import io
+import re
+
+import pytest
+from pptx import Presentation
+
+from app.infographics.image import chrome
+from app.slides import export
+from app.slides.build import finish, view
+from app.slides.content import LIMITS, clamp_deck, clamp_slide
+from app.slides.layout import GEOMETRY, VARIANTS, assign_variants, compose
+from app.slides.render import deck_print_html, slide_html
+from tests.test_buildout import _notebook_with_pricing, auth, feed, llm  # noqa: F401  (fixtures)
+
+LONG = "Words that keep going and going " * 40
+
+FULL = {
+    "title": {"heading": "Pricing that readers say yes to", "kicker": "From 4 posts", "lead": "What two years taught us."},
+    "agenda": {"heading": "What we will cover", "points": [{"text": f"Part {i}"} for i in range(9)]},
+    "section": {"heading": "The numbers behind trials", "kicker": "Part two", "lead": "Short trials converted twice as well."},
+    "points": {"heading": "Why tiers work", "kicker": "Tiers", "lead": "Readers self-select.",
+               "points": [{"term": "Anchoring", "text": "A higher tier makes the middle one feel fair."}] * 4},
+    "two_column": {"heading": "Monthly or annual", "left": {"label": "Monthly", "items": ["Low commitment", "Easy to leave"]},
+                   "right": {"label": "Annual", "items": ["Two months free", "Lower churn"]}},
+    "stat": {"heading": "Short trials win", "stat": {"value": "2x", "label": "more paid signups"}, "lead": "A decision point."},
+    "quote": {"heading": "In their words", "quote": {"text": "Thursday would feel empty without it.", "by": "A reader"}},
+    "closing": {"heading": "Key takeaways", "takeaways": ["One.", "Two.", "Three."], "closing": "Price the habit."},
+}
+
+
+def _stuff(slide: dict, text: str) -> dict:
+    """The same slide with every text field set to `text` (the longest anything could be)."""
+    s = copy.deepcopy(slide)
+    for k in ("heading", "kicker", "lead", "closing"):
+        if k in s:
+            s[k] = text
+    for p in s.get("points") or []:
+        p["text"], p["term"] = text, text[:60]
+    for side in ("left", "right"):
+        if side in s:
+            s[side] = {"label": text, "items": [text] * 6}
+    if "stat" in s:
+        s["stat"] = {"value": "123456789012345678", "label": text}
+    if "quote" in s:
+        s["quote"] = {"text": text, "by": text}
+    if "takeaways" in s:
+        s["takeaways"] = [text] * 5
+    return s
+
+
+@pytest.mark.parametrize("theme", ["dark-space", "light-space"])
+@pytest.mark.parametrize("fmt", ["detailed", "presenter"])
+def test_every_variant_draws_inside_its_boxes_at_any_length(theme, fmt):
+    for layout, variants in VARIANTS.items():
+        for v in variants:
+            for text in ("Short text here", LONG, "長い日本語のテキスト" * 30, "Supercalifragilistic" * 12):
+                raw = {**_stuff(FULL[layout], text), "layout": layout, "variant": v}
+                deck = clamp_deck({"title": "Deck", "slides": [raw, raw]}, fmt)
+                for i in range(2):
+                    c = compose(deck, i, theme, fmt, seed=7)
+                    for e in c.elements:
+                        assert 0 <= e.x and e.x + e.w <= 1920 + 1 and 0 <= e.y and e.y + e.h <= 1080 + 1, (layout, v, e.role)
+                        if e.kind == "text":
+                            assert e.text_height() <= e.h + 1, (layout, v, e.role, text[:20])
+
+
+def test_clamp_never_lets_bad_input_through():
+    garbage = [None, 5, "text", [], {"layout": "nonsense", "heading": "<script>alert(1)</script>**Bold** [1]"},
+               {"layout": "stat", "heading": "No number", "stat": {"value": "", "label": "x"}},
+               {"layout": "quote", "heading": "No quote", "quote": None, "points": [{"text": "a"}, {"text": "b"}]},
+               {"layout": "two_column", "heading": "One side", "left": {"items": ["x"]}, "right": None},
+               {"layout": "points", "heading": "Nul\x00 byte— dash", "points": "not a list"},
+               {"layout": "closing", "heading": "", "takeaways": None, "closing": None},
+               {"layout": "points", "heading": "x" * 5000, "points": [{"term": None, "text": {"nested": 1}}] * 30}]
+    deck = clamp_deck({"title": None, "slides": garbage}, "detailed")
+    assert deck and deck["title"]
+    keys = set(clamp_slide({"heading": "x"}, "detailed"))
+    for s in deck["slides"]:
+        assert set(s) == keys  # every slide has every key
+        for value in (s["heading"], s["lead"], s["kicker"]):
+            assert "<" not in value and "\x00" not in value and "—" not in value and "**" not in value
+        assert len(s["heading"]) <= LIMITS["detailed"]["heading"]
+    layouts = [s["layout"] for s in deck["slides"]]
+    assert layouts[0] == "points" or layouts[0] == "section"  # unknown layout becomes a simpler one
+    assert "stat" not in layouts and "quote" not in layouts and "two_column" not in layouts
+    assert clamp_deck({"slides": []}, "detailed") is None and clamp_deck("nope", "presenter") is None
+
+
+def test_pages_escape_everything_the_model_wrote():
+    raw = {"layout": "points", "heading": "Fine <b onmouseover=x>heading</b>", "lead": "a & b < c",
+           "points": [{"term": "<img src=x>", "text": "\"quoted\" <script>x</script> text"}] * 3}
+    deck = clamp_deck({"title": "<title>", "slides": [raw]}, "detailed")
+    deck["slides"][0]["variant"] = "a"
+    html = slide_html(deck, 0, "dark-space", "detailed", 1)
+    assert "<script" not in html and "<img" not in html and "onmouseover" not in html
+    assert "a &amp; b &lt; c" in html
+
+
+def test_variants_never_repeat_in_a_row_and_differ_between_decks():
+    slides = [clamp_slide({**FULL[k], "layout": k}, "detailed") for k in
+              ("title", "agenda", "points", "points", "points", "stat", "points", "quote", "points", "closing")]
+    a, b = copy.deepcopy(slides), copy.deepcopy(slides)
+    assign_variants(a, "dark-space", seed=1)
+    pairs = [(s["layout"], s["variant"]) for s in a]
+    assert all(pairs[i] != pairs[i + 1] for i in range(len(pairs) - 1))
+    points = [s["variant"] for s in a if s["layout"] == "points"]
+    assert len(set(points)) == len(VARIANTS["points"])  # every points variant used before any repeats
+    assign_variants(b, "dark-space", seed=2, previous=pairs)
+    assert [s["variant"] for s in b] != [s["variant"] for s in a]
+    assert b[0]["variant"] != a[0]["variant"] and b[-1]["variant"] != a[-1]["variant"]  # new opener and closer
+    again = copy.deepcopy(slides)
+    assign_variants(again, "dark-space", seed=1)
+    assert [s["variant"] for s in again] == [s["variant"] for s in a]  # one deck always draws the same
+
+
+def test_the_two_themes_compose_differently():
+    for layout, variants in VARIANTS.items():
+        for v in variants:
+            assert GEOMETRY["dark-space"][layout][v] != GEOMETRY["light-space"][layout][v] or layout in ("points", "two_column"), \
+                (layout, v)
+
+
+def _deck(fmt: str = "detailed") -> dict:
+    src = [{"path": "p.md", "line_start": 1, "line_end": 2, "title": "On Pricing"}]
+    slides = [{**FULL[k], "layout": k, "notes": f"Say {k}", "sources": src}
+              for k in ("title", "agenda", "points", "two_column", "stat", "quote", "closing")]
+    deck = clamp_deck({"title": "Pricing", "slides": slides}, fmt)
+    assign_variants(deck["slides"], "light-space", seed=3)
+    return deck
+
+
+def test_powerpoint_has_every_slide_as_editable_text_with_notes():
+    deck = _deck()
+    data = export.build_pptx(deck, "light-space", "detailed", 3)
+    prs = Presentation(io.BytesIO(data))
+    assert len(prs.slides) == len(deck["slides"]) and prs.slide_width == 12192000
+    texts = [" ".join(sh.text_frame.text for sh in s.shapes if sh.has_text_frame) for s in prs.slides]
+    assert "Why tiers work" in texts[2] and "Anchoring" in texts[2] and "middle one feel fair" in texts[2]
+    notes = prs.slides[2].notes_slide.notes_text_frame.text
+    assert "Say points" in notes and "On Pricing (lines 1-2)" in notes
+
+
+@pytest.mark.skipif(not chrome(), reason="no Chrome to print with")
+def test_pdf_has_one_page_per_slide_and_nothing_overflows():
+    from pypdf import PdfReader
+
+    deck = finish(_deck(), "dark-space", "detailed", 3)
+    assert export.overflowing(deck, "dark-space", "detailed", 3) == set()
+    pdf = PdfReader(io.BytesIO(export.render_pdf(deck, "dark-space", "detailed", 3)))
+    assert len(pdf.pages) == len(deck["slides"])
+    assert round(float(pdf.pages[0].mediabox.width) / float(pdf.pages[0].mediabox.height), 2) == round(1920 / 1080, 2)
+
+
+def test_a_stored_deck_with_a_broken_slide_still_shows():
+    content = {"theme": "dark-space", "format": "detailed", "seed": "abc", "deck": _deck()}
+    content["deck"]["slides"][2]["variant"] = "zz"  # unknown: drawn with the first variant
+    content["deck"]["slides"][3]["points"] = None
+    pages = view(content)
+    assert len(pages) == len(content["deck"]["slides"]) and all(p.startswith("<!doctype html>") for p in pages)
+    assert view({"deck": {"slides": []}}) == [] and view({}) == []
+    assert "Pricing" in deck_print_html(clamp_deck(content["deck"], "detailed"), "x", "detailed", 1)
+
+
+# --- the whole flow, through the API ------------------------------------------------------------------------------
+
+@pytest.fixture()
+def no_chrome(monkeypatch):
+    """Generation measures slides in Chrome when one is installed; the API tests run without it."""
+    monkeypatch.setattr(export, "chrome", lambda: None)
+
+
+def _fake_many(monkeypatch, pricing_path: str, log: dict):
+    from app.llm import run
+
+    def predict_many(signature, inputs_list, *, db, workspace_id, lm=None, workers=5):
+        name = signature.__name__
+        log.setdefault(name, []).extend(inputs_list)
+        out = []
+        for inp in inputs_list:
+            if name == "WriteSlide":
+                good = {"path": pricing_path, "line_start": 1, "line_end": 12}
+                fake = {"path": "sources/made-up.md", "line_start": 1, "line_end": 3}
+                slide = {"kicker": "Pricing", "heading": inp["heading"], "lead": "Charging more made readers take it seriously.",
+                         "points": [{"term": "Price", "text": "The paid tier doubled after the price went up."},
+                                    {"term": "Invented", "text": "Ninety percent of readers loved it."},
+                                    {"term": "Seriousness", "text": "Readers took the work seriously."}],
+                         "notes": "Talk about pricing.", "sources": [good, fake]}
+                if inp["layout"] == "stat":
+                    slide["stat"] = {"value": "90%", "label": "of readers upgraded"}  # not in the post: removed
+                if inp["layout"] == "quote":
+                    slide["quote"] = {"text": "Charging more made my readers take the work seriously.", "by": "Ada"}
+                if inp["layout"] == "two_column":
+                    slide["left"] = {"label": "Before", "items": ["Low price", "Few paid readers"]}
+                    slide["right"] = {"label": "After", "items": ["Ten dollars", "Paid tier doubled"]}
+                out.append({"slide": slide})
+            elif name == "CheckSlide":
+                bad = [c for c in inp["claims"] if "Ninety percent" in c]
+                out.append({"checks": [{"n": int(c.split(".")[0]), "supported": False, "fix": ""} for c in bad]})
+            else:
+                out.append(None)
+        return out
+
+    monkeypatch.setattr(run, "predict_many", predict_many)
+
+
+def _outline(n: int, layouts=("points", "quote", "stat", "points", "section", "points", "points", "two_column", "points")):
+    def make(**inputs):
+        return {"outline": {"title": "Pricing for writers", "subtitle": "Why charging more worked",
+                            "opening_kicker": "Pricing", "agenda_heading": "What we cover",
+                            "slides": [{"layout": layouts[i % len(layouts)], "heading": f"Slide idea {i}",
+                                        "purpose": "Make a point", "sources": []} for i in range(n)]}}
+    return make
+
+
+CLOSING = {"closing": {"kicker": "Conclusion", "heading": "Key takeaways",
+                       "takeaways": ["Charge more.", "Readers take it seriously.", "The paid tier grows."],
+                       "closing": "Price the work like it matters.", "notes": "Close."}}
+
+
+def test_short_detailed_deck_is_grounded_checked_and_downloadable(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    log: dict = {}
+    _fake_many(monkeypatch, pricing["path"], log)
+    llm["OutlineDeck"] = _outline(9)  # too many for a short deck: trimmed
+    llm["WriteClosing"] = CLOSING
+    art = client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]], "deck_format": "detailed", "deck_length": "short",
+                      "theme": "light-space", "instructions": "For new writers"}, headers=auth).json()
+    assert art["type_label"] == "Slide deck"
+    run_jobs()
+    done = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
+    assert done["status"] == "ready", done["content"].get("error")
+    c = done["content"]
+    slides = c["deck"]["slides"]
+    assert 6 <= len(slides) <= 8 and len(done["content"]["slides_html"]) == len(slides)
+    assert slides[0]["layout"] == "title" and slides[-1]["layout"] == "closing"
+    assert slides[-1]["closing"] == "Price the work like it matters." and len(slides[-1]["takeaways"]) == 3
+    assert not any(s["layout"] == "agenda" for s in slides)  # short decks have no agenda
+    assert c["theme"] == "light-space" and c["format"] == "detailed"
+    body = [s for s in slides[1:-1]]
+    for s in body:
+        assert all(src["path"] == pricing["path"] for src in s["sources"])  # the invented path is gone
+        assert all("Ninety percent" not in p["text"] for p in s["points"])  # unsupported claim removed
+        assert s["layout"] != "stat"  # its number was not in the post
+    assert any(s["layout"] == "quote" for s in body)  # the quote is in the post word for word
+    pairs = [(s["layout"], s["variant"]) for s in slides]
+    assert all(pairs[i] != pairs[i + 1] for i in range(len(pairs) - 1))
+    assert all(log["WriteSlide"][0]["source_lines"]) and log["WriteSlide"][0]["deck_format"] == "detailed"
+    html = "".join(c["slides_html"])
+    assert "<script" not in html and "Pricing for writers" in html
+
+    pptx = client.get(f"/api/artifacts/{art['id']}/slides.pptx", headers=auth)
+    assert pptx.status_code == 200 and "Pricing for writers.pptx" in pptx.headers["content-disposition"]
+    assert len(Presentation(io.BytesIO(pptx.content)).slides) == len(slides)
+    assert client.get(f"/api/artifacts/{art['id']}/slides.pdf", headers=auth).status_code == 503  # no Chrome here
+    assert client.get(f"/api/artifacts/{art['id']}/slides.doc", headers=auth).status_code == 422
+
+
+def test_default_presenter_deck_has_an_agenda_and_stays_in_range(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    log: dict = {}
+    _fake_many(monkeypatch, pricing["path"], log)
+    llm["OutlineDeck"] = _outline(7)
+    llm["WriteClosing"] = CLOSING
+    art = client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]], "deck_format": "presenter", "deck_length": "default",
+                      "language": "Spanish"}, headers=auth).json()
+    run_jobs()
+    done = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
+    slides = done["content"]["deck"]["slides"]
+    assert done["status"] == "ready" and 9 <= len(slides) <= 11
+    assert slides[1]["layout"] == "agenda" and [p["text"] for p in slides[1]["points"]][:2] == ["Slide idea 0", "Slide idea 1"]
+    assert done["content"]["theme"] == "dark-space"  # the default
+    assert log["WriteSlide"][0]["language"] == "Spanish" and log["WriteSlide"][0]["deck_format"] == "presenter"
+    for s in slides:
+        assert all(len(p["text"]) <= LIMITS["presenter"]["text"] for p in s["points"] if s["layout"] != "agenda")
+
+
+def test_too_little_material_fails_cleanly_and_sources_are_required(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    _fake_many(monkeypatch, pricing["path"], {})
+    llm["OutlineDeck"] = _outline(1)
+    art = client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]], "deck_length": "default"}, headers=auth).json()
+    run_jobs()
+    failed = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
+    assert failed["status"] == "failed" and "Short" in failed["content"]["error"]
+    assert llm["_calls"].count("OutlineDeck") >= 2  # asked again before giving up
+    assert client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                       "document_ids": []}, headers=auth).status_code == 400
+    assert client.get(f"/api/artifacts/{art['id']}/slides.pptx", headers=auth).status_code == 404
+
+
+def test_a_slide_the_model_fails_to_write_is_written_from_its_sources(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    from app.llm import run
+
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    log: dict = {}
+    _fake_many(monkeypatch, pricing["path"], log)
+    real = run.predict_many
+
+    def flaky(signature, inputs_list, **kw):
+        out = real(signature, inputs_list, **kw)
+        return [None] * len(out) if signature.__name__ == "WriteSlide" else out
+
+    monkeypatch.setattr(run, "predict_many", flaky)
+    llm["OutlineDeck"] = lambda **kw: {"outline": {"title": "Pricing", "subtitle": "", "opening_kicker": "", "agenda_heading": "",
+                                                   "slides": [{"layout": "points", "heading": f"Idea {i}", "purpose": "A point",
+                                                               "sources": [{"path": pricing["path"], "line_start": 1, "line_end": 14}]}
+                                                              for i in range(4)]}}
+    llm["WriteClosing"] = lambda **kw: (_ for _ in ()).throw(RuntimeError("model down"))
+    art = client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]], "deck_length": "short"}, headers=auth).json()
+    run_jobs()
+    done = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
+    assert done["status"] == "ready", done["content"].get("error")
+    slides = done["content"]["deck"]["slides"]
+    assert [s["heading"] for s in slides[1:-1]] == [f"Idea {i}" for i in range(4)]
+    assert slides[-1]["layout"] == "closing" and slides[-1]["takeaways"]
+    assert len(log["WriteSlide"]) == 8  # each slide tried twice
+    assert re.search(r"Charging more|ten dollars|seriously", " ".join(str(s) for s in slides[1:-1]))
+
+
+def test_the_opening_and_closing_say_only_what_the_slides_say(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    _fake_many(monkeypatch, pricing["path"], {})
+    outline = _outline(4)
+
+    def mixed_up(**kw):
+        out = outline(**kw)
+        out["outline"]["subtitle"] = "Ada won a writing award for her pricing"  # joins two things no slide says
+        return out
+
+    llm["OutlineDeck"] = mixed_up
+    takeaways = ["Charge more.", "Ada sold a million copies.", "The paid tier grows."]
+    llm["WriteClosing"] = {"closing": {**CLOSING["closing"], "takeaways": takeaways}}
+
+    def check(**kw):
+        claims = kw["claims"]
+        return {"checks": [{"n": int(c.split(".")[0]), "supported": False, "fix": ""} for c in claims
+                           if "award" in c or "million" in c]}
+
+    llm["CheckSlide"] = check
+    art = client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]], "deck_length": "short"}, headers=auth).json()
+    run_jobs()
+    slides = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()["content"]["deck"]["slides"]
+    assert "award" not in slides[0]["lead"] and slides[0]["heading"] == "Pricing for writers"
+    assert slides[-1]["takeaways"] == ["Charge more.", "The paid tier grows."]
+
+
+def test_long_deck_has_parts_and_the_request_reaches_every_step(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    log: dict = {}
+    _fake_many(monkeypatch, pricing["path"], log)
+    layouts = ("section", "points", "stat", "points", "section", "quote", "points", "two_column", "section", "points",
+               "points", "points")
+    llm["OutlineDeck"] = _outline(12, layouts)
+    llm["CheckRequest"] = {"asks": [{"ask": "For new writers", "covered": True}]}
+    seen: dict = {}
+
+    def closing(**kw):
+        seen["closing"] = kw["request"]
+        return CLOSING
+
+    llm["WriteClosing"] = closing
+    art = client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]], "deck_length": "long", "instructions": "For new writers"},
+                      headers=auth).json()
+    run_jobs()
+    done = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
+    assert done["status"] == "ready", done["content"].get("error")
+    slides = done["content"]["deck"]["slides"]
+    assert 12 <= len(slides) <= 16 and done["content"]["length"] == "long"
+    sections = [s["heading"] for s in slides if s["layout"] == "section"]
+    assert slides[1]["layout"] == "agenda" and [p["text"] for p in slides[1]["points"]] == sections  # the parts
+    assert all(w["request"] == "For new writers" for w in log["WriteSlide"]) and seen["closing"] == "For new writers"
+    assert llm["_calls"].count("OutlineDeck") == 1  # nothing missed: no second plan
+
+
+def test_a_missed_ask_is_planned_again(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    _fake_many(monkeypatch, pricing["path"], {})
+    requests: list[str] = []
+    first, second = _outline(4), _outline(5)
+
+    def outline(**kw):
+        requests.append(kw["request"])
+        out = (first if len(requests) == 1 else second)(**kw)
+        if len(requests) > 1:
+            out["outline"]["slides"][-1]["heading"] = "Pricing for beginners"
+        return out
+
+    llm["OutlineDeck"] = outline
+    llm["CheckRequest"] = {"asks": [{"ask": "a slide for beginners", "covered": False}, {"ask": "pricing", "covered": True}]}
+    llm["WriteClosing"] = CLOSING
+    art = client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]], "deck_length": "short",
+                      "instructions": "Pricing, with a slide for beginners"}, headers=auth).json()
+    run_jobs()
+    slides = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()["content"]["deck"]["slides"]
+    assert len(requests) == 2 and "a slide for beginners" in requests[1] and "pricing" not in requests[1].split("supports: ")[1]
+    assert any(s["heading"] == "Pricing for beginners" for s in slides)
+    assert client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                       "document_ids": [pricing["id"]], "deck_length": "huge"}, headers=auth).status_code == 422
+
+
+def test_the_closing_is_tried_again_and_a_repeated_heading_goes(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    _fake_many(monkeypatch, pricing["path"], {})
+    outline = _outline(6, ("points", "section", "points", "quote", "points", "two_column"))
+
+    def with_repeat(**kw):
+        out = outline(**kw)
+        out["outline"]["slides"][1]["heading"] = out["outline"]["slides"][2]["heading"]  # a part titled like its slide
+        return out
+
+    llm["OutlineDeck"] = with_repeat
+    tries = []
+
+    def closing(**kw):
+        tries.append(1)
+        if len(tries) == 1:
+            raise RuntimeError("model hiccup")
+        return CLOSING
+
+    llm["WriteClosing"] = closing
+    art = client.post("/api/artifacts/generate", json={"type": "slide_deck", "notebook_id": nb["id"],
+                      "document_ids": [pricing["id"]], "deck_length": "short"}, headers=auth).json()
+    run_jobs()
+    slides = client.get(f"/api/artifacts/{art['id']}", headers=auth).json()["content"]["deck"]["slides"]
+    assert len(tries) == 2 and slides[-1]["closing"] == "Price the work like it matters."
+    headings = [s["heading"] for s in slides]
+    assert len(headings) == len(set(headings)) and 6 <= len(slides) <= 8

frontend/src/api/endpoints.ts

@@ -116,7 +116,9 @@ export type GenerateBody = {
   document_id?: string;
   /** No notebook or post: use the "All posts" notebook. */
   archive?: boolean;
-  format?: "deep_dive" | "brief" | "debate";
+  format?: "deep_dive" | "brief" | "critique" | "debate";
+  /** audio_overview: a single narrator or a two host conversation. */
+  hosts?: 1 | 2;
   minutes?: number;
   style?: "audiogram";
   audio_artifact_id?: string;
@@ -139,8 +141,11 @@ export type GenerateBody = {
   report_format?: "document" | "interactive";
   template_id?: string;
   instructions?: string;
-  /** infographic: one of the premade themes (see components/Infographic.tsx). */
+  /** infographic: one of the premade themes (see components/Infographic.tsx); slide_deck: dark-space or light-space. */
   theme?: string;
+  /** slide_deck: read on its own ("detailed") or shown behind a speaker ("presenter"), and how many slides. */
+  deck_format?: "detailed" | "presenter";
+  deck_length?: "short" | "default" | "long";
 };
 
 export const artifactsApi = {
@@ -154,6 +159,8 @@ export const artifactsApi = {
   /** An infographic drawn as a PNG. */
   image: (id: string, layout: "landscape" | "portrait" = "landscape") => apiBlob(`/api/artifacts/${id}/image${qs({ layout })}`),
   retry: (id: string) => post<Artifact>(`/api/artifacts/${id}/retry`),
+  /** A slide deck as a PDF (exactly as shown) or an editable PowerPoint. */
+  slidesFile: (id: string, ext: "pdf" | "pptx") => apiBlob(`/api/artifacts/${id}/slides.${ext}`),
 };
 
 export const jobsApi = {

frontend/src/api/types.ts

@@ -89,7 +89,7 @@ export type AnswerFeedback = { rating: "up" | "down"; reasons: string[]; comment
 export type WorkspaceChat = ChatSummary & { notebook_id: string; notebook_title: string };
 export type ChatMessage = { id: string; role: "user" | "assistant"; text: string; citations: Citation[]; feedback?: AnswerFeedback | null };
 
-export type ArtifactType = "summary" | "audio_overview" | "video" | "quote_card" | "carousel" | "launch_kit" | "mind_map" | "quiz" | "flashcards" | "report" | "infographic"| "upload";
+export type ArtifactType = "summary" | "audio_overview" | "video" | "quote_card" | "carousel" | "launch_kit" | "mind_map" | "quiz" | "flashcards" | "report" | "infographic" | "slide_deck" | "upload";
 
 export type QuizQuestionType = "multiple_choice" | "multiple_select" | "fill_blank" | "short_answer";
 export type QuizQuestion = {

frontend/src/components/ArtifactCard.tsx

@@ -68,7 +68,7 @@ export function CitationList({
   );
 }
 
-function Transcript({ segments, onSeek }: { segments: Segment[]; onSeek: (t: number) => void }) {
+export function Transcript({ segments, onSeek }: { segments: Segment[]; onSeek: (t: number) => void }) {
   return (
     <ol className="transcript">
       {segments.map((s, i) => (

frontend/src/components/AudioOverview.tsx

@@ -0,0 +1,318 @@
+import { useEffect, useRef, useState, type RefObject } from "react";
+import { artifactsApi, videoVoicesApi, type GenerateBody } from "../api/endpoints";
+import type { Artifact, ChatSummary, Segment, VideoSavedVoice } from "../api/types";
+import { useJob } from "../hooks/useJob";
+import { Transcript } from "./ArtifactCard";
+import { Dropdown } from "./Dropdown";
+import { CheckIcon, ChevronIcon, HeadphonesIcon } from "./icons/Icons";
+import { LANGUAGES, Pills, SourceFocusFields, type SourceSelection } from "./SourceFocusFields";
+import { ConfirmDeleteModal, errorMessage, JobProgress, Modal, StatusPill } from "./ui";
+
+/** The audio styles. The server describes each to the script writer (backend/app/pipeline/media.py STYLES). */
+const STYLES = [
+  { id: "deep_dive", name: "Deep Dive", blurb: "A lively conversation that unpacks the ideas in your sources and connects them." },
+  { id: "brief", name: "Brief", blurb: "A bite sized overview to help you grasp the core ideas from your sources quickly." },
+  { id: "critique", name: "Critique", blurb: "An expert review of your sources, with constructive feedback to help you improve your material." },
+  { id: "debate", name: "Debate", blurb: "A thoughtful debate between two hosts, bringing out different perspectives on your sources." },
+] as const;
+type Style = (typeof STYLES)[number]["id"];
+
+const LENGTHS = [
+  { value: "3", label: "Short", hint: "about 3 min" },
+  { value: "6", label: "Default", hint: "about 6 min" },
+  { value: "12", label: "Long", hint: "about 12 min" },
+];
+
+export type AudioOverviewRequest = Omit<GenerateBody, "type">;
+
+/** The workspace's voices, asked for once (the list takes a few seconds): the notebook asks ahead of time, so the
+ * pickers are ready when the settings open. A failure is forgotten, so the next open asks again. */
+let voicesAsked: Promise<VideoSavedVoice[]> | null = null;
+export function prefetchVoices(): Promise<VideoSavedVoice[]> {
+  voicesAsked ??= videoVoicesApi.list().then((r) => r.saved).catch((e) => {
+    voicesAsked = null;
+    throw e;
+  });
+  return voicesAsked;
+}
+
+/** The audio overview settings: a style, one or two hosts and their voices, length, language, the sources, and what
+ * the hosts should focus on. */
+export function AudioOverviewDialog({ notebookId, notebookTitle, chats, currentChatId, onClose, onCreate }: {
+  notebookId: string;
+  notebookTitle?: string;
+  chats: ChatSummary[];
+  currentChatId?: string | null;
+  onClose: () => void;
+  onCreate: (body: AudioOverviewRequest) => void;
+}) {
+  const [sel, setSel] = useState<SourceSelection | null>(null);
+  const [style, setStyle] = useState<Style>("deep_dive");
+  const [hosts, setHosts] = useState<"1" | "2">("2");
+  const [minutes, setMinutes] = useState("6");
+  const [language, setLanguage] = useState("English");
+  const [focus, setFocus] = useState("");
+  // The hosts' voices, from the workspace's voices (none to pick when they cannot load: the default voices are used).
+  const [voices, setVoices] = useState<VideoSavedVoice[] | null>(null);
+  const [voice, setVoice] = useState<[string, string]>(["", ""]);
+
+  useEffect(() => {
+    let live = true;
+    prefetchVoices().then((saved) => {
+      if (!live) return;
+      setVoices(saved);
+      setVoice([saved[0]?.voice_id ?? "", (saved[1] ?? saved[0])?.voice_id ?? ""]);
+    }).catch(() => live && setVoices([]));
+    return () => {
+      live = false;
+    };
+  }, []);
+
+  const two = hosts === "2";
+  // A debate needs two hosts: with one, the style moves to Deep Dive.
+  useEffect(() => {
+    if (!two && style === "debate") setStyle("deep_dive");
+  }, [two, style]);
+
+  /** Pick a host's voice; the other host moves off it, so the two never share one (when there are two to pick). */
+  const pickVoice = (i: 0 | 1, voiceId: string) =>
+    setVoice((cur) => {
+      const next: [string, string] = [...cur];
+      next[i] = voiceId;
+      const other = i === 0 ? 1 : 0;
+      if (two && next[other] === voiceId) next[other] = voices?.find((v) => v.voice_id !== voiceId)?.voice_id ?? voiceId;
+      return next;
+    });
+
+
+  const voiceOptions = (voices ?? []).map((v) => ({ value: v.voice_id, label: v.name }));
+  const create = () => {
+    if (!sel) return;
+    onCreate({
+      ...sel.request, format: style, hosts: two ? 2 : 1, minutes: Number(minutes), language, instructions: focus.trim(),
+      ...(voice[0] ? { host_a: voice[0], ...(two ? { host_b: voice[1] || voice[0] } : {}) } : {}),
+    });
+  };
+
+  return (
+    <Modal title="Customize audio overview" onClose={onClose} wide>
+      <div className="stack vw-in-modal ao-dialog">
+        <section className="field">
+          <span className="vw-label">Style</span>
+          <div className="ao-styles" role="radiogroup" aria-label="Style">
+            {STYLES.map((s) => {
+              const off = s.id === "debate" && !two;
+              return (
+                <button key={s.id} type="button" role="radio" aria-checked={style === s.id} disabled={off}
+                        className={`ao-style${style === s.id ? " on" : ""}`} onClick={() => setStyle(s.id)}>
+                  <span className="ao-style-head">
+                    <strong>{s.name}</strong>
+                    <span className="ao-radio" aria-hidden="true">{style === s.id && <CheckIcon size={12} />}</span>
+                  </span>
+                  <span className="ao-style-blurb">{off ? "Needs two hosts." : s.blurb}</span>
+                </button>
+              );
+            })}
+          </div>
+        </section>
+
+        <section className="sd-opts ao-opts">
+          <div className="field">
+            <span className="vw-label">Hosts</span>
+            <Pills<"1" | "2"> label="Hosts" value={hosts} onChange={setHosts}
+              options={[{ id: "1", label: "One host" }, { id: "2", label: "Two hosts" }]} />
+          </div>
+          <div className="field">
+            <span className="vw-label">Length</span>
+            <Dropdown<string> label="Length" value={minutes} onChange={setMinutes} options={LENGTHS} />
+          </div>
+          <div className="field">
+            <span className="vw-label">Language</span>
+            <Dropdown<string> label="Language" value={language} onChange={setLanguage}
+              options={LANGUAGES.map((l) => ({ value: l, label: l }))} />
+          </div>
+        </section>
+
+        <section className="ao-voices">
+          {voices === null && <p className="muted small">Loading your voices...</p>}
+          {voices !== null && voices.length === 0 && (
+            <p className="muted small">Your voices could not load, so the default {two ? "voices are" : "voice is"} used.</p>
+          )}
+          {voices !== null && voices.length > 0 && ([0, 1] as const).filter((i) => i === 0 || two).map((i) => (
+            <div key={i} className="field">
+              <span className="vw-label">{two ? `Host ${i + 1} voice` : "Host voice"}</span>
+              <Dropdown<string> label={two ? `Host ${i + 1} voice` : "Host voice"} value={voice[i]} onChange={(v) => pickVoice(i, v)}
+                options={voiceOptions} />
+            </div>
+          ))}
+        </section>
+
+        <SourceFocusFields notebookId={notebookId} notebookTitle={notebookTitle} chats={chats} currentChatId={currentChatId}
+                           what="audio overview" noFocus onChange={setSel} />
+
+        <label className="field">
+          <span className="vw-label">What should the AI {two ? "hosts" : "host"} focus on in this episode? <span className="muted">(optional)</span></span>
+          <textarea className="input sd-prompt" rows={4} maxLength={4000} value={focus} onChange={(e) => setFocus(e.target.value)}
+                    placeholder={"- List the core ideas worth remembering\n- Explain how the pieces connect"} />
+        </label>
+        {!sel?.ready && <p className="muted small">Select at least one post or chat to make an audio overview.</p>}
+        <div className="vw-nav">
+          <button type="button" className="btn btn-primary vw-next" disabled={!sel?.ready} onClick={create}>
+            Generate audio overview
+          </button>
+        </div>
+      </div>
+    </Modal>
+  );
+}
+
+const SPEEDS = [1, 1.25, 1.5, 1.75, 2, 0.75];
+
+function clock(seconds: number): string {
+  const s = Math.max(0, Math.floor(seconds || 0));
+  return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+}
+
+/** The audio's own player: play or pause, where it is, a bar to move through it, and the playback speed. */
+function AudioPlayer({ src, duration: known, audioRef }: { src: string; duration?: number; audioRef: RefObject<HTMLAudioElement> }) {
+  const [playing, setPlaying] = useState(false);
+  const [time, setTime] = useState(0);
+  const [duration, setDuration] = useState(known ?? 0);
+  const [speed, setSpeed] = useState(1);
+  useEffect(() => {
+    const a = audioRef.current;
+    if (!a) return;
+    const sync = () => {
+      setTime(a.currentTime);
+      if (Number.isFinite(a.duration) && a.duration > 0) setDuration(a.duration);
+      setPlaying(!a.paused && !a.ended);
+    };
+    const events = ["timeupdate", "loadedmetadata", "durationchange", "play", "pause", "ended"];
+    events.forEach((e) => a.addEventListener(e, sync));
+    return () => events.forEach((e) => a.removeEventListener(e, sync));
+  }, [audioRef]);
+  const toggle = () => {
+    const a = audioRef.current;
+    if (!a) return;
+    if (a.paused) void a.play();
+    else a.pause();
+  };
+  const nextSpeed = () => {
+    const next = SPEEDS[(SPEEDS.indexOf(speed) + 1) % SPEEDS.length];
+    setSpeed(next);
+    if (audioRef.current) audioRef.current.playbackRate = next;
+  };
+  const pct = duration ? Math.min(100, (time / duration) * 100) : 0;
+  return (
+    <div className="ao-player">
+      <audio ref={audioRef} src={src} preload="metadata" />
+      <button type="button" className="ao-play" onClick={toggle} aria-label={playing ? "Pause" : "Play"}>
+        {playing ? (
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><rect x="6" y="5" width="4" height="14" rx="1" /><rect x="14" y="5" width="4" height="14" rx="1" /></svg>
+        ) : (
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M8 5.5v13a1 1 0 0 0 1.5.86l10.5-6.5a1 1 0 0 0 0-1.72L9.5 4.64A1 1 0 0 0 8 5.5z" /></svg>
+        )}
+      </button>
+      <span className="ao-time mono">{clock(time)} / {clock(duration)}</span>
+      <input className="ao-seek" type="range" min={0} max={duration || 0} step={0.1} value={Math.min(time, duration || 0)}
+             aria-label="Position" style={{ ["--ao-fill" as string]: `${pct}%` }}
+             onChange={(e) => {
+               const a = audioRef.current;
+               if (a) a.currentTime = Number(e.target.value);
+               setTime(Number(e.target.value));
+             }} />
+      <button type="button" className="ao-speed mono" onClick={nextSpeed} aria-label={`Playback speed ${speed}x`} title="Playback speed">
+        {speed}x
+      </button>
+    </div>
+  );
+}
+
+const STYLE_NAMES: Record<string, string> = Object.fromEntries(STYLES.map((s) => [s.id, s.name]));
+
+/** An audio overview in the notebook's list: a row with its title and length that opens (chevron) to its player,
+ * transcript, Download and Delete. Shows its progress while it is being made. */
+export function AudioOverviewCard({ artifact: initial, onRemoved }: { artifact: Artifact; onRemoved: (id: string) => void }) {
+  const [artifact, setArtifact] = useState(initial);
+  const [open, setOpen] = useState(false);
+  const [transcript, setTranscript] = useState(false);
+  const [confirming, setConfirming] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const audio = useRef<HTMLAudioElement>(null);
+  const job = useJob(artifact.job, () => {
+    artifactsApi.get(artifact.id).then(setArtifact);
+  });
+  const running = job && (job.status === "queued" || job.status === "running");
+  const ready = artifact.status === "ready";
+  const failed = artifact.status === "failed" ? (artifact.content.error as string | undefined) ?? job?.error ?? "Could not make this audio." : null;
+  const c = artifact.content;
+  const segments = (c.segments as Segment[] | undefined) ?? [];
+  const meta = [
+    c.duration_s ? clock(c.duration_s as number) : "",
+    c.hosts === 1 ? "1 host" : c.hosts === 2 ? "2 hosts" : "",
+    STYLE_NAMES[c.format as string] ?? "",
+  ].filter(Boolean).join(" · ") || (running ? "Making the audio..." : "");
+
+  const remove = async () => {
+    await artifactsApi.remove(artifact.id);
+    onRemoved(artifact.id);
+  };
+
+  return (
+    <article className={`ao-card${open ? " open" : ""}`}>
+      <div className="ao-card-head" role={ready ? "button" : undefined} tabIndex={ready ? 0 : undefined} aria-expanded={ready ? open : undefined}
+           onClick={() => ready && setOpen((o) => !o)}
+           onKeyDown={(e) => ready && (e.key === "Enter" || e.key === " ") && (e.preventDefault(), setOpen((o) => !o))}>
+        <span className="ao-card-icon" aria-hidden="true">{running ? <span className="nbv-send-spinner" /> : <HeadphonesIcon size={20} />}</span>
+        <span className="ao-card-text">
+          <strong title={artifact.title}>{artifact.title}</strong>
+          <span className="ao-card-meta">{meta}</span>
+        </span>
+        {!ready && !failed && <StatusPill status={running ? (job!.status === "queued" ? "queued" : "working") : artifact.status} />}
+        {ready && (
+          <span className="ao-chevron" aria-hidden="true"><ChevronIcon size={18} className={`chevron${open ? " open" : ""}`} /></span>
+        )}
+      </div>
+      {running && job && <div className="ao-card-progress"><JobProgress job={job} compact /></div>}
+      {failed && (
+        <div className="ao-card-progress sd-item-failed">
+          <p className="error-text small">{failed}</p>
+          <button type="button" className="link-btn" onClick={async () => {
+            setError(null);
+            try {
+              setArtifact(await artifactsApi.retry(artifact.id));
+            } catch (e) {
+              setError(errorMessage(e));
+            }
+          }}>Retry</button>
+          <button type="button" className="link-btn" onClick={() => setConfirming(true)}>Remove</button>
+        </div>
+      )}
+      {ready && open && (
+        <div className="ao-card-body">
+          {artifact.url && <AudioPlayer src={artifact.url} duration={c.duration_s as number | undefined} audioRef={audio} />}
+          {segments.length > 0 && (
+            <button type="button" className="link-btn ao-transcript-toggle" aria-expanded={transcript} onClick={() => setTranscript((t) => !t)}>
+              {transcript ? "Hide transcript" : `Show transcript (${segments.length} lines)`}
+            </button>
+          )}
+          {transcript && (
+            <Transcript segments={segments} onSeek={(t) => {
+              const a = audio.current;
+              if (!a) return;
+              a.currentTime = t;
+              void a.play();
+            }} />
+          )}
+          <div className="row ao-card-actions">
+            {artifact.download_url && <a className="btn btn-small" href={artifact.download_url}>Download</a>}
+            <button type="button" className="btn btn-small ao-delete" onClick={() => setConfirming(true)}>Delete</button>
+          </div>
+        </div>
+      )}
+      {error && <p className="error-text small ao-card-progress">{error}</p>}
+      {confirming && <ConfirmDeleteModal heading="Delete audio overview?" name={artifact.title} onCancel={() => setConfirming(false)}
+                                         onConfirm={remove} />}
+    </article>
+  );
+}

frontend/src/components/PaneResizer.tsx

@@ -0,0 +1,188 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState, type CSSProperties, type RefObject } from "react";
+
+/** The notebook's side panels, resized by dragging the line between a panel and the chat. Widths are kept per browser;
+ * nothing set means the stylesheet's default width. A panel never goes under its minimum, and the chat always keeps
+ * room, so a narrower window simply takes the extra width back. */
+
+export const PANE_MIN = { left: 220, right: 300 } as const;
+const CHAT_MIN = 440;
+const GUTTER = 16; // the space between the chat and the right panel (.nbv-side's margin)
+const KEYS = { left: "ns_nbv_left", right: "ns_nbv_right" } as const;
+
+type Side = "left" | "right";
+type Widths = { left: number | null; right: number | null };
+
+function read(side: Side): number | null {
+  try {
+    const v = Number(localStorage.getItem(KEYS[side]));
+    return Number.isFinite(v) && v > 0 ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+function write(side: Side, value: number | null) {
+  try {
+    if (value === null) localStorage.removeItem(KEYS[side]);
+    else localStorage.setItem(KEYS[side], String(Math.round(value)));
+  } catch {
+    /* Private browsing can prevent persistence; resizing still works for this visit. */
+  }
+}
+
+function useMedia(query: string): boolean {
+  const [on, setOn] = useState(() => typeof window !== "undefined" && window.matchMedia(query).matches);
+  useEffect(() => {
+    const m = window.matchMedia(query);
+    const change = () => setOn(m.matches);
+    change();
+    m.addEventListener("change", change);
+    return () => m.removeEventListener("change", change);
+  }, [query]);
+  return on;
+}
+
+/** Where the panes are now: the container's width and the two boundaries (px from its left edge). */
+type Frame = { width: number; leftEdge: number | null; rightEdge: number | null };
+
+export function usePaneWidths(container: RefObject<HTMLElement | null>, opts: { leftOpen: boolean }) {
+  const [saved, setSaved] = useState<Widths>(() => ({ left: read("left"), right: read("right") }));
+  const [frame, setFrame] = useState<Frame>({ width: 0, leftEdge: null, rightEdge: null });
+  // The left panel sits beside the chat from 900px; the right one from 1350px (below that it stacks under the chat).
+  const leftActive = useMedia("(min-width: 900px)") && opts.leftOpen;
+  const rightActive = useMedia("(min-width: 1350px)");
+
+  // Measure the real boundaries after layout changes, so the handles sit exactly on them (state only changes when a
+  // number does, so this cannot loop).
+  const measure = useCallback(() => {
+    const el = container.current;
+    if (!el) return;
+    const box = el.getBoundingClientRect();
+    const history = el.querySelector<HTMLElement>(":scope > .nbv-history");
+    const side = el.querySelector<HTMLElement>(":scope > .nbv-side");
+    const next: Frame = {
+      width: Math.round(box.width),
+      leftEdge: history ? Math.round(history.getBoundingClientRect().right - box.left) : null,
+      rightEdge: side ? Math.round(side.getBoundingClientRect().left - box.left - GUTTER / 2) : null,
+    };
+    setFrame((cur) => (cur.width === next.width && cur.leftEdge === next.leftEdge && cur.rightEdge === next.rightEdge ? cur : next));
+  }, [container]);
+  useLayoutEffect(() => {
+    measure();
+  });
+  useEffect(() => {
+    const el = container.current;
+    if (!el || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(measure);
+    ro.observe(el);
+    el.querySelectorAll(":scope > .nbv-history, :scope > .nbv-side").forEach((p) => ro.observe(p));
+    window.addEventListener("resize", measure);
+    return () => {
+      ro.disconnect();
+      window.removeEventListener("resize", measure);
+    };
+  }, [container, measure, leftActive, rightActive]);
+
+  const { width } = frame;
+  // What each panel measures by default (the stylesheet's width), when nothing is saved for it.
+  const measuredLeft = frame.leftEdge ?? 0;
+  const measuredRight = frame.rightEdge !== null ? width - frame.rightEdge - GUTTER / 2 : 0;
+  const wantLeft = leftActive ? (saved.left ?? measuredLeft) : 0;
+  const wantRight = rightActive ? (saved.right ?? measuredRight) : 0;
+  // Each panel: at least its minimum, and never so wide that the chat gets less than CHAT_MIN.
+  const maxLeft = Math.max(PANE_MIN.left, width - CHAT_MIN - (rightActive ? wantRight + GUTTER : 0));
+  const maxRight = Math.max(PANE_MIN.right, width - CHAT_MIN - GUTTER - (leftActive ? wantLeft : 0));
+  const fit = (v: number, max: number, min: number) => Math.max(min, Math.min(v, max));
+  const left = leftActive && saved.left !== null && width ? fit(saved.left, maxLeft, PANE_MIN.left) : null;
+  const right = rightActive && saved.right !== null && width ? fit(saved.right, maxRight, PANE_MIN.right) : null;
+
+  const set = useCallback((side: Side, value: number | null, persist = false) => {
+    setSaved((cur) => ({ ...cur, [side]: value }));
+    if (persist) write(side, value);
+  }, []);
+
+  const style: CSSProperties = {
+    ...(left !== null ? { ["--nbv-left" as string]: `${Math.round(left)}px` } : {}),
+    ...(right !== null ? { ["--nbv-right" as string]: `${Math.round(right + GUTTER)}px` } : {}),
+  };
+
+  return {
+    style,
+    frame,
+    active: { left: leftActive && frame.leftEdge !== null, right: rightActive && frame.rightEdge !== null },
+    current: { left: left ?? measuredLeft, right: right ?? measuredRight },
+    bounds: { left: { min: PANE_MIN.left, max: maxLeft }, right: { min: PANE_MIN.right, max: maxRight } },
+    set,
+  };
+}
+
+type Panes = ReturnType<typeof usePaneWidths>;
+
+/** The line between a side panel and the chat: drag it (or focus it and use the arrow keys) to resize the panel;
+ * double click puts the panel back to its default width. */
+export function PaneResizer({ side, panes, container, label }: {
+  side: Side;
+  panes: Panes;
+  container: RefObject<HTMLElement | null>;
+  label: string;
+}) {
+  const [dragging, setDragging] = useState(false);
+  const frameReq = useRef(0);
+  const { min, max } = panes.bounds[side];
+  const value = Math.round(panes.current[side]);
+  const clamp = (v: number) => Math.max(min, Math.min(max, v));
+  const at = side === "left" ? panes.frame.leftEdge : panes.frame.rightEdge;
+
+  const fromPointer = (clientX: number) => {
+    const box = container.current?.getBoundingClientRect();
+    if (!box) return value;
+    return clamp(side === "left" ? clientX - box.left : box.right - clientX - GUTTER / 2);
+  };
+
+  const onPointerDown = (e: React.PointerEvent<HTMLDivElement>) => {
+    if (e.button !== 0) return;
+    e.preventDefault();
+    e.currentTarget.setPointerCapture(e.pointerId);
+    setDragging(true);
+    document.body.classList.add("nbv-resizing");
+  };
+  const onPointerMove = (e: React.PointerEvent<HTMLDivElement>) => {
+    if (!dragging) return;
+    const x = e.clientX;
+    cancelAnimationFrame(frameReq.current);
+    frameReq.current = requestAnimationFrame(() => panes.set(side, fromPointer(x)));
+  };
+  const end = (e: React.PointerEvent<HTMLDivElement>) => {
+    if (!dragging) return;
+    cancelAnimationFrame(frameReq.current);
+    setDragging(false);
+    document.body.classList.remove("nbv-resizing");
+    panes.set(side, fromPointer(e.clientX), true);
+  };
+  useEffect(() => () => document.body.classList.remove("nbv-resizing"), []);
+
+  const onKeyDown = (e: React.KeyboardEvent<HTMLDivElement>) => {
+    const step = e.shiftKey ? 64 : 16;
+    // The left panel grows to the right; the right panel grows to the left.
+    const grow = side === "left" ? "ArrowRight" : "ArrowLeft";
+    const shrink = side === "left" ? "ArrowLeft" : "ArrowRight";
+    let next: number | null = null;
+    if (e.key === grow) next = value + step;
+    else if (e.key === shrink) next = value - step;
+    else if (e.key === "Home") next = min;
+    else if (e.key === "End") next = max;
+    else return;
+    e.preventDefault();
+    panes.set(side, clamp(next), true);
+  };
+
+  if (!panes.active[side] || at === null) return null;
+  return (
+    <div className={`nbv-resizer nbv-resizer-${side}${dragging ? " dragging" : ""}`} style={{ left: at }}
+         role="separator" aria-orientation="vertical" aria-label={label} tabIndex={0}
+         aria-valuenow={value} aria-valuemin={min} aria-valuemax={Math.round(max)}
+         title="Drag to resize. Double click to reset."
+         onPointerDown={onPointerDown} onPointerMove={onPointerMove} onPointerUp={end} onPointerCancel={end}
+         onDoubleClick={() => panes.set(side, null, true)} onKeyDown={onKeyDown} />
+  );
+}

frontend/src/components/SlideDeck.tsx

@@ -0,0 +1,605 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState, type CSSProperties, type ReactNode } from "react";
+import { createPortal } from "react-dom";
+import { artifactsApi, type GenerateBody } from "../api/endpoints";
+import type { Artifact, ChatSummary } from "../api/types";
+import { Dropdown } from "./Dropdown";
+import { useJob } from "../hooks/useJob";
+import { CheckIcon, CollapseIcon, DownloadIcon, ExpandIcon, MoreIcon, PdfIcon, PlayIcon, PptxIcon, SlidesIcon, TrashIcon } from "./icons/Icons";
+import { LANGUAGES, Pills, SourceFocusFields, sourceSummary, type SourceSelection } from "./SourceFocusFields";
+import { ConfirmDeleteModal, errorMessage, formatDate, JobProgress, Modal } from "./ui";
+
+/** The two deck themes. Their slides are laid out on the server (backend/app/slides); the thumbnails are rendered from
+ * them (backend/scripts/render_slide_thumbnails.py). */
+export const SLIDE_THEMES = [
+  { id: "dark-space", name: "Dark space", blurb: "Night sky, planets and a blue glow" },
+  { id: "light-space", name: "Light space", blurb: "Daylight sky, orbits and constellations" },
+] as const;
+
+const FORMATS = [
+  { id: "detailed", label: "Detailed deck", blurb: "Full text and details, perfect for emailing or reading on its own." },
+  { id: "presenter", label: "Presenter slides", blurb: "Clean slides with key talking points to support you while you speak." },
+] as const;
+
+const LENGTHS = [
+  { id: "short", label: "Short", range: "6 to 8 slides" },
+  { id: "default", label: "Default", range: "9 to 11 slides" },
+  { id: "long", label: "Long", range: "12 to 16 slides" },
+] as const;
+
+const SLIDE_W = 1920;
+const SLIDE_H = 1080;
+
+export type SlideDeckRequest = Omit<GenerateBody, "type">;
+type DeckFormat = "detailed" | "presenter";
+type DeckLength = "short" | "default" | "long";
+
+/** The slide deck settings: a visual style on top, then the format, language, length, sources and what it should say. */
+export function SlideDeckDialog({ notebookId, notebookTitle, chats, currentChatId, onClose, onCreate }: {
+  notebookId: string;
+  notebookTitle?: string;
+  chats: ChatSummary[];
+  currentChatId?: string | null;
+  onClose: () => void;
+  onCreate: (body: SlideDeckRequest) => void;
+}) {
+  const [sel, setSel] = useState<SourceSelection | null>(null);
+  const [theme, setTheme] = useState<string>("dark-space");
+  const [format, setFormat] = useState<DeckFormat>("detailed");
+  const [length, setLength] = useState<DeckLength>("default");
+  const [language, setLanguage] = useState("English");
+  const [prompt, setPrompt] = useState("");
+
+  return (
+    <Modal title="Customize slide deck" onClose={onClose} wide>
+      <div className="stack vw-in-modal sd-dialog">
+        <section className="field">
+          <span className="vw-label">Visual style</span>
+          <div className="sd-themes" role="radiogroup" aria-label="Visual style">
+            {SLIDE_THEMES.map((t) => (
+              <button key={t.id} type="button" role="radio" aria-checked={theme === t.id} title={t.blurb}
+                      className={`sd-theme${theme === t.id ? " on" : ""}`} onClick={() => setTheme(t.id)}>
+                <span className="sd-theme-img">
+                  <img src={`/slides/${t.id}.png`} alt="" loading="lazy" />
+                  {theme === t.id && <span className="sd-check" aria-hidden="true"><CheckIcon size={12} /></span>}
+                </span>
+                <span className="sd-theme-name">{t.name}</span>
+              </button>
+            ))}
+          </div>
+        </section>
+
+        <section className="sd-opts">
+          <div className="field">
+            <span className="vw-label">Format</span>
+            <Pills<DeckFormat> label="Format" value={format} onChange={setFormat} options={FORMATS} />
+            <small className="muted">{FORMATS.find((f) => f.id === format)?.blurb}</small>
+          </div>
+          <div className="field">
+            <span className="vw-label">Length</span>
+            <Dropdown<DeckLength> label="Length" value={length} onChange={setLength}
+              options={LENGTHS.map((l) => ({ value: l.id, label: l.label, hint: l.range }))} />
+          </div>
+          <div className="field">
+            <span className="vw-label">Language</span>
+            <Dropdown<string> label="Language" value={language} onChange={setLanguage}
+              options={LANGUAGES.map((l) => ({ value: l, label: l }))} />
+          </div>
+        </section>
+
+        <SourceFocusFields notebookId={notebookId} notebookTitle={notebookTitle} chats={chats} currentChatId={currentChatId}
+                           what="slide deck" noFocus onChange={setSel} />
+
+        <label className="field">
+          <span className="vw-label">Describe the slide deck you want to create <span className="muted">(optional)</span></span>
+          <textarea className="input sd-prompt" rows={3} maxLength={4000} value={prompt} onChange={(e) => setPrompt(e.target.value)}
+                    placeholder={'Add a high-level outline, or guide the audience, style, and focus: "Create a deck for beginners with a focus on step-by-step instructions."'} />
+        </label>
+
+        {!sel?.ready && <p className="muted small">Select at least one post or chat to make a slide deck.</p>}
+        <div className="vw-nav">
+          <button type="button" className="btn btn-primary vw-next" disabled={!sel?.ready}
+                  onClick={() => sel && onCreate({ ...sel.request, theme, deck_format: format, deck_length: length,
+                                                   language, instructions: prompt.trim() })}>
+            Generate slide deck
+          </button>
+        </div>
+      </div>
+    </Modal>
+  );
+}
+
+/** One slide (HTML from our own layout, every word escaped) in a sandboxed frame, scaled to fit the box it is given. */
+export function SlideFrame({ html, title, fit = "width", hidden = false }: {
+  html: string;
+  title: string;
+  /** "width": as wide as the box, 16:9. "contain": as large as fits in the box both ways (presenting). */
+  fit?: "width" | "contain";
+  hidden?: boolean;
+}) {
+  const box = useRef<HTMLDivElement>(null);
+  const [scale, setScale] = useState(0.2);
+  useEffect(() => {
+    const el = box.current;
+    if (!el) return;
+    const measure = () => {
+      const s = fit === "contain" ? Math.min(el.clientWidth / SLIDE_W, el.clientHeight / SLIDE_H) : el.clientWidth / SLIDE_W;
+      if (s > 0) setScale(s);
+    };
+    measure();
+    if (typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(measure);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [fit]);
+  return (
+    <div ref={box} className={`sd-frame sd-frame-${fit}`} style={hidden ? { visibility: "hidden" } : undefined} aria-hidden={hidden}>
+      <iframe title={title} srcDoc={html} sandbox="" tabIndex={-1} width={SLIDE_W} height={SLIDE_H}
+              style={{ transform: `translate(-50%, -50%) scale(${scale})` }} />
+    </div>
+  );
+}
+
+type DeckSlide = { layout: string; heading: string; notes?: string; sources?: { title?: string; path: string; line_start: number; line_end: number }[] };
+
+function deckOf(artifact: Artifact): { pages: string[]; slides: DeckSlide[] } {
+  const c = artifact.content;
+  const pages = Array.isArray(c.slides_html) ? (c.slides_html as string[]) : [];
+  const slides = Array.isArray(c.deck?.slides) ? (c.deck.slides as DeckSlide[]) : [];
+  return { pages, slides };
+}
+
+/** Playing the deck: full screen, one slide at a time. Arrows, Space, Page Up/Down, Home and End move; a click goes on;
+ * Escape (or leaving full screen) stops. Every slide is loaded at once and only the current one shown, so moving between
+ * them never flashes. */
+export function SlidePresenter({ artifact, start = 0, onClose }: { artifact: Artifact; start?: number; onClose: () => void }) {
+  const { pages } = deckOf(artifact);
+  const [i, setI] = useState(Math.min(start, Math.max(pages.length - 1, 0)));
+  const [idle, setIdle] = useState(false);
+  const root = useRef<HTMLDivElement>(null);
+  const timer = useRef<number | undefined>(undefined);
+  const dark = artifact.content.theme !== "light-space";
+
+  const go = useCallback((to: number) => setI(Math.max(0, Math.min(pages.length - 1, to))), [pages.length]);
+
+  useEffect(() => {
+    const el = root.current;
+    // Full screen when the browser allows it (not iOS Safari): the overlay already fills the window either way.
+    if (el?.requestFullscreen) el.requestFullscreen().catch(() => undefined);
+    const onChange = () => {
+      if (!document.fullscreenElement) onClose();
+    };
+    document.addEventListener("fullscreenchange", onChange);
+    return () => {
+      document.removeEventListener("fullscreenchange", onChange);
+      if (document.fullscreenElement) document.exitFullscreen().catch(() => undefined);
+    };
+  }, [onClose]);
+
+  useEffect(() => {
+    const onKey = (e: KeyboardEvent) => {
+      if (["ArrowRight", "ArrowDown", "PageDown", " ", "Enter"].includes(e.key)) go(i + 1);
+      else if (["ArrowLeft", "ArrowUp", "PageUp", "Backspace"].includes(e.key)) go(i - 1);
+      else if (e.key === "Home") go(0);
+      else if (e.key === "End") go(pages.length - 1);
+      else if (e.key === "Escape") onClose();
+      else return;
+      // Ours alone: the viewer (and its modal) underneath must not move or close too.
+      e.preventDefault();
+      e.stopImmediatePropagation();
+    };
+    document.addEventListener("keydown", onKey, true);
+    return () => document.removeEventListener("keydown", onKey, true);
+  }, [go, i, pages.length, onClose]);
+
+  const wake = () => {
+    setIdle(false);
+    window.clearTimeout(timer.current);
+    timer.current = window.setTimeout(() => setIdle(true), 2200);
+  };
+  useEffect(() => {
+    wake();
+    return () => window.clearTimeout(timer.current);
+  }, []);
+
+  return createPortal(
+    <div ref={root} className={`sd-present${dark ? "" : " light"}${idle ? " idle" : ""}`} role="dialog" aria-modal="true"
+         aria-label={`${artifact.title}, slide ${i + 1} of ${pages.length}`} onMouseMove={wake}
+         onClick={(e) => (e.target as HTMLElement).closest(".sd-present-bar") ? undefined : go(i + 1)}>
+      <div className="sd-present-stage">
+        {pages.map((html, k) => (
+          <SlideFrame key={k} html={html} title={`Slide ${k + 1}`} fit="contain" hidden={k !== i} />
+        ))}
+      </div>
+      <div className="sd-present-bar" role="toolbar" aria-label="Presenting">
+        <button type="button" className="btn btn-small" onClick={() => go(i - 1)} disabled={i === 0} aria-label="Previous slide">Prev</button>
+        <span className="sd-count" aria-live="polite">{i + 1} / {pages.length}</span>
+        <button type="button" className="btn btn-small" onClick={() => go(i + 1)} disabled={i === pages.length - 1} aria-label="Next slide">Next</button>
+        <button type="button" className="btn btn-small" onClick={onClose}>Exit</button>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+/** A small menu under an icon button. Closes on a click outside or Escape (an Escape that closes the menu does not
+ * also close the popup it sits in). */
+function useMenu() {
+  const [open, setOpen] = useState(false);
+  const ref = useRef<HTMLDivElement>(null); // the button's wrapper
+  const menuRef = useRef<HTMLDivElement>(null); // the floating menu (rendered in <body>)
+  useEffect(() => {
+    if (!open) return;
+    const inside = (t: EventTarget | null) => !!t && (ref.current?.contains(t as Node) || menuRef.current?.contains(t as Node));
+    const onDown = (e: MouseEvent) => {
+      if (!inside(e.target)) setOpen(false);
+    };
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key !== "Escape") return;
+      e.stopImmediatePropagation();
+      setOpen(false);
+    };
+    // The menu floats at a fixed place: scrolling what is under it (not the menu itself) closes it.
+    const onScroll = (e: Event) => {
+      if (!inside(e.target)) setOpen(false);
+    };
+    const onResize = () => setOpen(false);
+    document.addEventListener("mousedown", onDown);
+    document.addEventListener("keydown", onKey, true);
+    window.addEventListener("scroll", onScroll, true);
+    window.addEventListener("resize", onResize);
+    return () => {
+      document.removeEventListener("mousedown", onDown);
+      document.removeEventListener("keydown", onKey, true);
+      window.removeEventListener("scroll", onScroll, true);
+      window.removeEventListener("resize", onResize);
+    };
+  }, [open]);
+  return { open, setOpen, ref, menuRef };
+}
+
+/** A menu under its button, drawn in <body> so a scrolling list or a popup can never clip it. Opens below and to the
+ * left of the button's right edge, and above it when there is no room below. */
+function FloatingMenu({ menu, children }: { menu: ReturnType<typeof useMenu>; children: ReactNode }) {
+  const [pos, setPos] = useState<CSSProperties>({ visibility: "hidden" });
+  useLayoutEffect(() => {
+    const button = menu.ref.current?.getBoundingClientRect();
+    const box = menu.menuRef.current?.getBoundingClientRect();
+    if (!button || !box) return;
+    const below = button.bottom + 6 + box.height <= window.innerHeight - 8;
+    setPos({
+      top: below ? button.bottom + 6 : Math.max(8, button.top - 6 - box.height),
+      left: Math.max(8, Math.min(button.right - box.width, window.innerWidth - box.width - 8)),
+    });
+  }, [menu.ref, menu.menuRef]);
+  return createPortal(
+    <div ref={menu.menuRef} className="sd-menu sd-menu-floating" role="menu" style={pos} onClick={(e) => e.stopPropagation()}>
+      {children}
+    </div>,
+    document.body,
+  );
+}
+
+/** Saves the deck as a PDF (exactly as shown) or an editable PowerPoint, drawn by the server. */
+function useDeckDownload(artifact: Artifact) {
+  const [busy, setBusy] = useState<"pdf" | "pptx" | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const name = deckTitle(artifact).replace(/[^\w\- ]+/g, "").trim().slice(0, 80) || "Slide deck";
+  const save = async (ext: "pdf" | "pptx") => {
+    setBusy(ext);
+    setError(null);
+    try {
+      const blob = await artifactsApi.slidesFile(artifact.id, ext);
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `${name}.${ext}`;
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      setTimeout(() => URL.revokeObjectURL(url), 10_000);
+    } catch (e) {
+      setError(errorMessage(e));
+    } finally {
+      setBusy(null);
+    }
+  };
+  return { busy, error, save };
+}
+
+function deckTitle(artifact: Artifact): string {
+  return artifact.title.replace(/^Slide deck: /, "") || (artifact.content.deck?.title as string | undefined) || "Slide deck";
+}
+
+/** "5d ago", "3h ago", "just now". */
+function ago(iso: string | null): string {
+  if (!iso) return "";
+  const s = Math.max(0, (Date.now() - new Date(iso).getTime()) / 1000);
+  if (s < 60) return "just now";
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
+  if (s < 86400 * 30) return `${Math.floor(s / 86400)}d ago`;
+  return formatDate(iso);
+}
+
+/** Download, in the popup's header: a menu of PDF or PowerPoint. */
+function DownloadMenu({ artifact }: { artifact: Artifact }) {
+  const menu = useMenu();
+  const dl = useDeckDownload(artifact);
+  return (
+    <div className="sd-menu-wrap" ref={menu.ref}>
+      <button type="button" className="sd-icon-btn" aria-haspopup="menu" aria-expanded={menu.open} disabled={dl.busy !== null}
+              title={dl.busy ? "Preparing the file..." : "Download"} aria-label={dl.busy ? "Preparing the file" : "Download"}
+              onClick={() => menu.setOpen((o) => !o)}>
+        {dl.busy ? <span className="nbv-send-spinner" aria-hidden="true" /> : <DownloadIcon size={20} />}
+      </button>
+      {menu.open && (
+        <FloatingMenu menu={menu}>
+          <button type="button" role="menuitem" onClick={() => { menu.setOpen(false); void dl.save("pdf"); }}>
+            <PdfIcon size={20} /> Download PDF Document (.pdf)
+          </button>
+          <button type="button" role="menuitem" onClick={() => { menu.setOpen(false); void dl.save("pptx"); }}>
+            <PptxIcon size={20} /> Download PowerPoint (.pptx)
+          </button>
+        </FloatingMenu>
+      )}
+      {dl.error && <span className="sd-menu-error error-text small" role="alert">{dl.error}</span>}
+    </div>
+  );
+}
+
+/** Everything a deck can do, behind its three dots (the row's and the popup's): rename, download, present, speaker
+ * notes (in the popup) and delete (asks once more first). */
+function DeckMenu({ artifact, onRename, onPresent, onDelete, notes, onNotes }: {
+  artifact: Artifact;
+  onRename?: () => void;
+  onPresent: () => void;
+  onDelete: () => Promise<void>;
+  notes?: boolean;
+  onNotes?: () => void;
+}) {
+  const menu = useMenu();
+  const dl = useDeckDownload(artifact);
+  const [confirming, setConfirming] = useState(false);
+  const pick = (fn: () => void) => () => {
+    menu.setOpen(false);
+    fn();
+  };
+  return (
+    <div className="sd-menu-wrap" ref={menu.ref} onClick={(e) => e.stopPropagation()}>
+      <button type="button" className="sd-icon-btn" aria-haspopup="menu" aria-expanded={menu.open} title="More" aria-label="More"
+              onClick={() => menu.setOpen((o) => !o)}>
+        {dl.busy ? <span className="nbv-send-spinner" aria-hidden="true" /> : <MoreIcon size={20} />}
+      </button>
+      {menu.open && (
+        <FloatingMenu menu={menu}>
+          {onRename && <button type="button" role="menuitem" onClick={pick(onRename)}><PencilIcon /> Rename</button>}
+          <button type="button" role="menuitem" onClick={pick(() => void dl.save("pdf"))}><PdfIcon size={20} /> Download PDF Document (.pdf)</button>
+          <button type="button" role="menuitem" onClick={pick(() => void dl.save("pptx"))}><PptxIcon size={20} /> Download PowerPoint (.pptx)</button>
+          <button type="button" role="menuitem" onClick={pick(onPresent)}><PlayIcon size={20} /> Start slideshow</button>
+          {onNotes && (
+            <button type="button" role="menuitemcheckbox" aria-checked={notes} onClick={pick(onNotes)}>
+              <SpeakerNotesIcon /> {notes ? "Hide speaker notes" : "Show speaker notes"}
+            </button>
+          )}
+          <button type="button" role="menuitem" className="danger" onClick={pick(() => setConfirming(true))}>
+            <TrashIcon size={20} /> Delete
+          </button>
+        </FloatingMenu>
+      )}
+      {confirming && <ConfirmDeleteModal heading="Delete slide deck?" name={deckTitle(artifact)} onCancel={() => setConfirming(false)}
+                                         onConfirm={onDelete} />}
+      {dl.error && <span className="sd-menu-error error-text small" role="alert">{dl.error}</span>}
+    </div>
+  );
+}
+
+function SvgIcon({ children }: { children: ReactNode }) {
+  return (
+    <svg className="icon" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={1.5}
+         strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+      {children}
+    </svg>
+  );
+}
+
+const SpeakerNotesIcon = () => (
+  <SvgIcon>
+    <path d="M5 4h14a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2h-7l-4 3.5V17H5a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2z" />
+    <path d="M7.5 9h9M7.5 12.5h6" />
+  </SvgIcon>
+);
+const PencilIcon = () => (
+  <SvgIcon>
+    <path d="M4 20h4L19 9a2.8 2.8 0 0 0-4-4L4 16v4zM13.5 6.5l4 4" />
+  </SvgIcon>
+);
+
+/** The deck in a popup: its actions along the top (present, a larger preview, download, more) and every slide below,
+ * one after another. A click on a slide presents from it. */
+export function SlideDeckViewer({ artifact, onClose, onDelete }: {
+  artifact: Artifact;
+  onClose: () => void;
+  onDelete: () => Promise<void>;
+}) {
+  const { pages, slides } = deckOf(artifact);
+  const [big, setBig] = useState(false);
+  const [notes, setNotes] = useState(false);
+  const [presenting, setPresenting] = useState<number | null>(null);
+  const [inView, setInView] = useState(0);
+  const stack = useRef<HTMLOListElement>(null);
+  const c = artifact.content;
+  const theme = SLIDE_THEMES.find((t) => t.id === c.theme)?.name ?? "Dark space";
+
+  // The slide most in view: Present starts there.
+  useEffect(() => {
+    const root = stack.current;
+    if (!root || typeof IntersectionObserver === "undefined") return;
+    const seen = new Map<number, number>();
+    const io = new IntersectionObserver((entries) => {
+      for (const e of entries) seen.set(Number((e.target as HTMLElement).dataset.i), e.intersectionRatio);
+      let best = 0;
+      let ratio = -1;
+      seen.forEach((r, i) => {
+        if (r > ratio) [best, ratio] = [i, r];
+      });
+      setInView(best);
+    }, { root, threshold: [0, 0.25, 0.5, 0.75, 1] });
+    root.querySelectorAll("[data-i]").forEach((el) => io.observe(el));
+    return () => io.disconnect();
+  }, [pages.length, notes]);
+
+  const actions = (
+    <div className="sd-head-actions" role="toolbar" aria-label="Slide deck">
+      <button type="button" className="sd-icon-btn" title="Start slideshow" aria-label="Start slideshow" disabled={!pages.length}
+              onClick={() => setPresenting(inView)}>
+        <PlayIcon size={20} />
+      </button>
+      <button type="button" className="sd-icon-btn" title={big ? "Smaller preview" : "Larger preview"} aria-pressed={big}
+              aria-label={big ? "Smaller preview" : "Larger preview"} onClick={() => setBig((b) => !b)}>
+        {big ? <CollapseIcon size={20} /> : <ExpandIcon size={20} />}
+      </button>
+      {pages.length > 0 && <DownloadMenu artifact={artifact} />}
+      <DeckMenu artifact={artifact} onPresent={() => setPresenting(inView)} onDelete={onDelete}
+                notes={notes} onNotes={() => setNotes((n) => !n)} />
+      <button type="button" className="sd-icon-btn" onClick={onClose} title="Close" aria-label="Close">
+        <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.6" aria-hidden="true">
+          <path d="M6 6l12 12M18 6L6 18" />
+        </svg>
+      </button>
+    </div>
+  );
+
+  return (
+    <Modal title={deckTitle(artifact)} onClose={onClose} wide actions={actions}>
+      <div className={`sd-view${big ? " big" : ""}`}>
+        <p className="muted small sd-meta">
+          {pages.length} slides · {c.format === "presenter" ? "Presenter" : "Detailed"} · {theme}
+          {c.source ? ` · from ${sourceSummary(c.source)}` : ""}
+        </p>
+        {pages.length === 0 ? (
+          <p className="error-text">This deck has no slides to show. Try generating it again.</p>
+        ) : (
+          <ol className="sd-stack" ref={stack} aria-label="Slides">
+            {pages.map((html, k) => {
+              const s = slides[k];
+              const sources = [...new Map((s?.sources ?? []).map((x) => [x.title || x.path, x])).values()];
+              return (
+                <li key={k} data-i={k}>
+                  <button type="button" className="sd-slide" onClick={() => setPresenting(k)}
+                          aria-label={`Present from slide ${k + 1}: ${s?.heading ?? ""}`}>
+                    <SlideFrame html={html} title={`Slide ${k + 1}`} />
+                  </button>
+                  {notes && (
+                    <div className="sd-notes">
+                      <span className="vw-label">Slide {k + 1}</span>
+                      <p>{s?.notes || <span className="muted">No notes for this slide.</span>}</p>
+                      {sources.length > 0 && (
+                        <p className="muted small">
+                          From {sources.map((x) => `${x.title || x.path} (lines ${x.line_start} to ${x.line_end})`).join("; ")}
+                        </p>
+                      )}
+                    </div>
+                  )}
+                </li>
+              );
+            })}
+          </ol>
+        )}
+      </div>
+      {presenting !== null && <SlidePresenter artifact={artifact} start={presenting} onClose={() => setPresenting(null)} />}
+    </Modal>
+  );
+}
+
+/** A deck in the notebook's list, as one quiet row: its icon, its title, "2 sources · 5d ago", and its menu. A click
+ * opens it. While it is being made the row says so and shows the progress. */
+export function SlideDeckRow({ artifact: initial, onRemoved }: { artifact: Artifact; onRemoved: (id: string) => void }) {
+  const [artifact, setArtifact] = useState(initial);
+  const [open, setOpen] = useState(false);
+  const [presenting, setPresenting] = useState(false);
+  const [renaming, setRenaming] = useState(false);
+  const [name, setName] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const job = useJob(artifact.job, () => {
+    artifactsApi.get(artifact.id).then(setArtifact);
+  });
+  const running = job && (job.status === "queued" || job.status === "running");
+  const ready = artifact.status === "ready";
+  const failed = artifact.status === "failed" ? (artifact.content.error as string | undefined) ?? job?.error ?? "Could not make this deck." : null;
+  const title = deckTitle(artifact);
+  const count = (artifact.content.source?.count as number | undefined) ?? 0;
+  const meta = running || !ready
+    ? (failed ? "Slide deck · could not be made" : `Generating slide deck... based on ${count || "your"} source${count === 1 ? "" : "s"}`)
+    : `${count} source${count === 1 ? "" : "s"} · ${ago(artifact.created_at)}`;
+
+  const remove = async () => {
+    await artifactsApi.remove(artifact.id);
+    setOpen(false);
+    onRemoved(artifact.id);
+  };
+  const rename = async () => {
+    const next = name.trim();
+    setRenaming(false);
+    if (!next || next === title) return;
+    setError(null);
+    try {
+      const deck = artifact.content.deck ? { ...artifact.content.deck, title: next } : undefined;
+      setArtifact(await artifactsApi.update(artifact.id, { title: next, ...(deck ? { content: { deck } } : {}) }));
+    } catch (e) {
+      setError(errorMessage(e));
+    }
+  };
+
+  return (
+    <div className={`sd-item${ready ? " is-ready" : ""}${running ? " is-running" : ""}`}>
+      <div className="sd-item-main" role={ready && !renaming ? "button" : undefined} tabIndex={ready && !renaming ? 0 : undefined}
+           aria-label={ready && !renaming ? `Open slide deck: ${title}` : undefined}
+           onClick={() => ready && !renaming && setOpen(true)}
+           onKeyDown={(e) => ready && !renaming && (e.key === "Enter" || e.key === " ") && (e.preventDefault(), setOpen(true))}>
+        <span className="sd-item-icon" aria-hidden="true">
+          {running ? <span className="nbv-send-spinner" /> : <SlidesIcon size={22} />}
+        </span>
+        <span className="sd-item-text">
+          {renaming ? (
+            <input className="input sd-rename" autoFocus value={name} maxLength={140} aria-label="Slide deck name"
+                   onChange={(e) => setName(e.target.value)} onBlur={rename} onClick={(e) => e.stopPropagation()}
+                   onKeyDown={(e) => {
+                     e.stopPropagation();
+                     if (e.key === "Enter") void rename();
+                     if (e.key === "Escape") setRenaming(false);
+                   }} />
+          ) : (
+            <strong title={title}>{running ? "Generating slide deck..." : title}</strong>
+          )}
+          <span className="sd-item-meta">{meta}</span>
+        </span>
+      </div>
+      {ready && (
+        <DeckMenu artifact={artifact} onRename={() => { setName(title); setRenaming(true); }} onPresent={() => setPresenting(true)}
+                  onDelete={remove} />
+      )}
+      {running && job && (
+        <div className="sd-item-progress">
+          <JobProgress job={job} compact />
+        </div>
+      )}
+      {failed && (
+        <div className="sd-item-progress sd-item-failed">
+          <p className="error-text small">{failed}</p>
+          <button type="button" className="link-btn" onClick={async () => {
+            setError(null);
+            try {
+              setArtifact(await artifactsApi.retry(artifact.id));
+            } catch (e) {
+              setError(errorMessage(e));
+            }
+          }}>Retry</button>
+          <button type="button" className="link-btn" onClick={() => void remove()}>Remove</button>
+        </div>
+      )}
+      {error && <p className="error-text small sd-item-progress">{error}</p>}
+      {open && <SlideDeckViewer artifact={artifact} onClose={() => setOpen(false)} onDelete={remove} />}
+      {presenting && <SlidePresenter artifact={artifact} onClose={() => setPresenting(false)} />}
+    </div>
+  );
+}

frontend/src/components/icons/Icons.tsx

@@ -239,6 +239,62 @@ export const InfographicIcon = (p: P) => (
   </Icon>
 );
 
+/** A slide on a stand, a second one behind it: a slide deck. */
+export const SlidesIcon = (p: P) => (
+  <Icon {...p}>
+    <rect x="3" y="4" width="15" height="10.5" rx="1.8" />
+    <path d="M6.5 1.9h12.7A1.8 1.8 0 0 1 21 3.7v8.6" />
+    <path d="M10.5 14.5V19M7 21h7M6.5 8h5M6.5 11h8" />
+  </Icon>
+);
+
+/** A play triangle: present a deck. */
+export const PlayIcon = (p: P) => (
+  <Icon {...p}>
+    <path d="M7.5 5.2v13.6a.8.8 0 0 0 1.2.7l10.6-6.8a.8.8 0 0 0 0-1.4L8.7 4.5a.8.8 0 0 0-1.2.7z" />
+  </Icon>
+);
+
+/** Four corners pointing out: show larger. */
+export const ExpandIcon = (p: P) => (
+  <Icon {...p}>
+    <path d="M4 9V4h5M20 9V4h-5M4 15v5h5M20 15v5h-5" />
+  </Icon>
+);
+
+/** Four corners pointing in: back to the normal size. */
+export const CollapseIcon = (p: P) => (
+  <Icon {...p}>
+    <path d="M9 4v5H4M15 4v5h5M9 20v-5H4M15 20v-5h5" />
+  </Icon>
+);
+
+/** Three dots, stacked: more actions. */
+export const MoreIcon = (p: P) => (
+  <Icon {...p}>
+    <circle cx="12" cy="5.5" r="1.1" fill="currentColor" />
+    <circle cx="12" cy="12" r="1.1" fill="currentColor" />
+    <circle cx="12" cy="18.5" r="1.1" fill="currentColor" />
+  </Icon>
+);
+
+/** A framed PDF mark: a PDF file. */
+export const PdfIcon = (p: P) => (
+  <Icon {...p}>
+    <rect x="3" y="4" width="18" height="16" rx="2.5" />
+    <text x="12" y="15" textAnchor="middle" fontSize="6.4" fontWeight="700" fill="currentColor" stroke="none"
+          fontFamily="Inter, sans-serif">PDF</text>
+  </Icon>
+);
+
+/** A framed P: a PowerPoint file. */
+export const PptxIcon = (p: P) => (
+  <Icon {...p}>
+    <rect x="3" y="4" width="18" height="16" rx="2.5" />
+    <path d="M10 16V8h2.8a2.3 2.3 0 0 1 0 4.6H10" />
+  </Icon>
+);
+
 /** A question mark in a circle: the quiz. */
 export const QuizIcon = (p: P) => (
   <Icon {...p}>

frontend/src/components/ui.tsx

@@ -171,6 +171,44 @@ export function CopyButton({ text, label = "Copy" }: { text: string; label?: str
 }
 
 /** Two step destructive button: first click arms it, second confirms. No browser dialogs. */
+/** "Delete this?": deletes only on confirm, shows what went wrong if it fails, and closes once it is gone. */
+export function ConfirmDeleteModal({ heading, name, onCancel, onConfirm }: {
+  heading: string;
+  name: string;
+  onCancel: () => void;
+  onConfirm: () => Promise<void>;
+}) {
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const confirm = async () => {
+    setBusy(true);
+    setError(null);
+    try {
+      await onConfirm();
+      onCancel(); // gone: close the warning
+    } catch (e) {
+      setError(errorMessage(e));
+      setBusy(false);
+    }
+  };
+  return (
+    <Modal title={heading} onClose={busy ? () => undefined : onCancel}>
+      <div className="stack sd-confirm">
+        <p>
+          <strong>{name}</strong> will be deleted for good. This cannot be undone.
+        </p>
+        {error && <p className="error-text" role="alert">{error}</p>}
+        <div className="row sd-confirm-actions">
+          <button type="button" className="btn" onClick={onCancel} disabled={busy}>Cancel</button>
+          <button type="button" className="btn btn-danger" onClick={confirm} disabled={busy} autoFocus>
+            {busy ? (<><span className="nbv-send-spinner" aria-hidden="true" /> Deleting...</>) : "Delete"}
+          </button>
+        </div>
+      </div>
+    </Modal>
+  );
+}
+
 export function ConfirmButton({
   onConfirm,
   children,

frontend/src/pages/NotebookView.tsx

@@ -1,20 +1,22 @@
 import { useCallback, useEffect, useRef, useState, type FormEvent } from "react";
 import { Link, useParams, useSearchParams } from "react-router-dom";
-import { artifactsApi, notebooksApi, videoVoicesApi, type GenerateBody } from "../api/endpoints";
+import { artifactsApi, notebooksApi } from "../api/endpoints";
 import { streamSSE } from "../api/stream";
-import type { AnswerFeedback as Feedback, Artifact, ChatSummary, Citation, MemoryChange, Notebook, VideoSavedVoice } from "../api/types";
+import type { AnswerFeedback as Feedback, Artifact, ChatSummary, Citation, MemoryChange, Notebook } from "../api/types";
 import { AnswerFeedback } from "../components/AnswerFeedback";
 import { ArtifactCard, CitationList } from "../components/ArtifactCard";
 import { Markdown } from "../components/Markdown";
 import { DocPicker } from "../components/DocPicker";
-import { Dropdown } from "../components/Dropdown";
-import { ChevronIcon, FlashcardsIcon, HeadphonesIcon, InfographicIcon, QuizIcon, ReportIcon, TelescopeIcon, VideoIcon } from "../components/icons/Icons";
+import { FlashcardsIcon, HeadphonesIcon, InfographicIcon, QuizIcon, ReportIcon, SlidesIcon, TelescopeIcon, VideoIcon } from "../components/icons/Icons";
 import { MindMapDialog, MindMapExplorer, MindMapRow } from "../components/MindMap";
 import { FlashcardsDialog, type FlashcardsRequest } from "../components/Flashcards";
 import { InfographicDialog, type InfographicRequest } from "../components/Infographic";
+import { SlideDeckDialog, SlideDeckRow, type SlideDeckRequest } from "../components/SlideDeck";
+import { AudioOverviewCard, AudioOverviewDialog, prefetchVoices, type AudioOverviewRequest } from "../components/AudioOverview";
 import { QuizDialog, type QuizRequest } from "../components/Quiz";
 import { MAX_STUDY_POSTS, prefetchFocus } from "../components/SourceFocusFields";
 import { ReportDialog, type ReportRequest } from "../components/ReportDialog";
+import { PaneResizer, usePaneWidths } from "../components/PaneResizer";
 import { Reader } from "../components/Reader";
 import { seedDocs } from "../components/video/sourceCache";
 import { ConfirmButton, errorMessage, formatDate, Loading, Modal } from "../components/ui";
@@ -45,7 +47,7 @@ function readChatRailOpen(): boolean {
 }
 
 /** Create: one click per format with sensible defaults, options folded away; then what was made from this notebook. */
-function StudioPanel({ notebookId, notebookTitle, docs, chats, currentChatId, disabled, quizOpen, onQuizClose, onCreateQuiz, cardsOpen, onCardsClose, onCreateCards, infographicOpen, onInfographicClose, onCreateInfographic, reportOpen, onReportClose, onCreateReport, onCreateVideo }: {
+function StudioPanel({ notebookId, notebookTitle, docs, chats, currentChatId, disabled, quizOpen, onQuizClose, onCreateQuiz, cardsOpen, onCardsClose, onCreateCards, infographicOpen, onInfographicClose, onCreateInfographic, audioOpen, onAudioClose, onCreateAudio, slidesOpen, onSlidesClose, onCreateSlides, reportOpen, onReportClose, onCreateReport, onCreateVideo }: {
   notebookId: string;
   notebookTitle: string;
   docs: { id: string; title: string; locked?: boolean }[];
@@ -61,67 +63,41 @@ function StudioPanel({ notebookId, notebookTitle, docs, chats, currentChatId, di
   infographicOpen: boolean;
   onInfographicClose: () => void;
   onCreateInfographic: () => void;
+  audioOpen: boolean;
+  onAudioClose: () => void;
+  onCreateAudio: () => void;
+  slidesOpen: boolean;
+  onSlidesClose: () => void;
+  onCreateSlides: () => void;
   reportOpen: boolean;
   onReportClose: () => void;
   onCreateReport: () => void;
   onCreateVideo: () => void;
 }) {
   const [artifacts, setArtifacts] = useState<Artifact[] | null>(null);
-  const [format, setFormat] = useState<"deep_dive" | "brief" | "debate">("deep_dive");
-  const [minutes, setMinutes] = useState(6);
   const [error, setError] = useState<string | null>(null);
-  const [busy, setBusy] = useState(false);
   const [reading, setReading] = useState<{ id: string; start: number; end: number } | null>(null);
-  const [audioOpen, setAudioOpen] = useState(false); // the Audio overview tile is opened to its options
-  // The two hosts' voices, picked from the workspace's voices (loaded when the options first open).
-  const [hostVoices, setHostVoices] = useState<VideoSavedVoice[] | null>(null);
-  const [hosts, setHosts] = useState<[string, string]>(["", ""]);
   const [mapDialog, setMapDialog] = useState(false);
   const [waitingMap, setWaitingMap] = useState<string | null>(null); // a map the user just asked for: open it when ready
   const [exploring, setExploring] = useState<Artifact | null>(null);
 
   const load = useCallback(() => notebooksApi.artifacts(notebookId).then(setArtifacts), [notebookId]);
 
-  useEffect(() => {
-    if (!audioOpen || hostVoices) return;
-    videoVoicesApi.list().then((r) => {
-      setHostVoices(r.saved);
-      // The first two voices by default; with just one, it reads both parts.
-      setHosts([r.saved[0]?.voice_id ?? "", (r.saved[1] ?? r.saved[0])?.voice_id ?? ""]);
-    }).catch(() => setHostVoices([])); // none to pick: the server's default voices
-  }, [audioOpen, hostVoices]);
-
-  /** Pick a host's voice; the other host moves off it, so the two never share one (when there are two to pick). */
-  const pickHost = (i: 0 | 1, voiceId: string) =>
-    setHosts((cur) => {
-      const next: [string, string] = [...cur];
-      next[i] = voiceId;
-      const other = i === 0 ? 1 : 0;
-      if (next[other] === voiceId) next[other] = hostVoices?.find((v) => v.voice_id !== voiceId)?.voice_id ?? voiceId;
-      return next;
-    });
   useEffect(() => {
     load();
   }, [load]);
 
+  // The voices for the audio overview settings take a few seconds to list: ask now so they are ready when it opens.
+  useEffect(() => {
+    prefetchVoices().catch(() => undefined);
+  }, []);
+
   // The focus suggestions the study dialogs show, made now so they are waiting when a dialog opens.
   const startIds = docs.filter((d) => !d.locked).slice(0, MAX_STUDY_POSTS).map((d) => d.id).join(",");
   useEffect(() => {
     if (startIds) prefetchFocus(notebookId, startIds.split(","));
   }, [notebookId, startIds]);
 
-  const make = async (body: Omit<GenerateBody, "notebook_id">) => {
-    setBusy(true);
-    setError(null);
-    try {
-      const a = await artifactsApi.generate({ ...body, notebook_id: notebookId });
-      setArtifacts((list) => [a, ...(list ?? [])]);
-    } catch (e) {
-      setError(errorMessage(e));
-    } finally {
-      setBusy(false);
-    }
-  };
 
   // Every "make" from a dialog works the same way: the dialog closes at once, a card in the panel says it is starting, the
   // artifact replaces it as soon as the server has it (and shows its own progress), and a failure is shown in the panel.
@@ -156,6 +132,10 @@ function StudioPanel({ notebookId, notebookTitle, docs, chats, currentChatId, di
     launch("report", onReportClose, () => artifactsApi.generate({ notebook_id: notebookId, ...body, type: "report" }));
   const makeInfographic = (body: InfographicRequest) =>
     launch("infographic", onInfographicClose, () => artifactsApi.generate({ notebook_id: notebookId, ...body, type: "infographic" }));
+  const makeAudio = (body: AudioOverviewRequest) =>
+    launch("audio overview", onAudioClose, () => artifactsApi.generate({ notebook_id: notebookId, ...body, type: "audio_overview" }));
+  const makeSlides = (body: SlideDeckRequest) =>
+    launch("slide deck", onSlidesClose, () => artifactsApi.generate({ notebook_id: notebookId, ...body, type: "slide_deck" }));
   const makeCards = (body: FlashcardsRequest) =>
     launch("flashcards", onCardsClose, () => artifactsApi.generate({ notebook_id: notebookId, ...body, type: "flashcards" }));
 
@@ -163,7 +143,7 @@ function StudioPanel({ notebookId, notebookTitle, docs, chats, currentChatId, di
   const others = artifacts?.filter((a) => a.type !== "mind_map");
 
   const cite = (c: Citation) => c.document_id && setReading({ id: c.document_id, start: c.line_start, end: c.line_end });
-  const off = disabled || busy;
+  const off = disabled;
 
   return (
     <div className="stack">
@@ -183,61 +163,26 @@ function StudioPanel({ notebookId, notebookTitle, docs, chats, currentChatId, di
             <circle cx="58" cy="18" r="2" fill="currentColor" />
           </svg>
         </button>
-        {/* Opens its options (format, length) right under it; the audio is made from there */}
-        <button className={`nbv-make-main${audioOpen ? " open" : ""}`} disabled={off} aria-expanded={audioOpen}
-                onClick={() => setAudioOpen(!audioOpen)}>
-          <span className="nbv-make-label"><HeadphonesIcon size={18} /> Audio overview</span>
-          <span className="nbv-make-meta">
-            <ChevronIcon size={16} className={`chevron${audioOpen ? " open" : ""}`} />
-          </span>
+        <button className="nbv-make-audio" disabled={off} onClick={onCreateAudio}>
+          <HeadphonesIcon size={18} /> <span className="nbv-make-text">Audio overview</span>
+        </button>
+        <button className="nbv-make-slides" disabled={off} onClick={onCreateSlides}>
+          <SlidesIcon size={18} /> <span className="nbv-make-text">Slide deck</span>
         </button>
-        {audioOpen && (
-          <div className="nbv-audio-opts">
-            <div className="nbv-audio-row">
-              <div className="field">
-                <span className="small muted">Format</span>
-                <Dropdown<typeof format> label="Audio format" value={format} onChange={setFormat}
-                  options={[
-                    { value: "deep_dive", label: "Deep dive" },
-                    { value: "brief", label: "Brief" },
-                    { value: "debate", label: "Debate" },
-                  ]} />
-              </div>
-              <div className="field">
-                <span className="small muted">Length</span>
-                <Dropdown<string> label="Length" value={String(minutes)} onChange={(v) => setMinutes(Number(v))}
-                  options={[3, 6, 10, 15].map((m) => ({ value: String(m), label: `${m} min` }))} />
-              </div>
-              {hostVoices && hostVoices.length > 0 && ([0, 1] as const).map((i) => (
-                <div key={i} className="field">
-                  <span className="small muted">Host {i + 1}</span>
-                  <Dropdown<string> label={`Host ${i + 1} voice`} value={hosts[i]} onChange={(v) => pickHost(i, v)}
-                    options={hostVoices.map((v) => ({ value: v.voice_id, label: v.name }))} />
-                </div>
-              ))}
-            </div>
-            <button className="btn btn-primary btn-small" disabled={off || (audioOpen && hostVoices === null)}
-                    onClick={() => make({ type: "audio_overview", format, minutes,
-                                          ...(hosts[0] ? { host_a: hosts[0], host_b: hosts[1] || hosts[0] } : {}) })
-                      .then(() => setAudioOpen(false))}>
-              {busy ? "Starting..." : "Create audio overview"}
-            </button>
-          </div>
-        )}
         <button disabled={off} onClick={onCreateVideo}>
-          <VideoIcon size={18} /> Video
+          <VideoIcon size={18} /> <span className="nbv-make-text">Video</span>
         </button>
         <button disabled={off} onClick={onCreateReport}>
-          <ReportIcon size={18} /> Report
+          <ReportIcon size={18} /> <span className="nbv-make-text">Report</span>
         </button>
         <button disabled={off} onClick={onCreateInfographic}>
-          <InfographicIcon size={18} /> Infographic
+          <InfographicIcon size={18} /> <span className="nbv-make-text">Infographic</span>
         </button>
         <button disabled={off} onClick={onCreateQuiz}>
-          <QuizIcon size={18} /> Quiz
+          <QuizIcon size={18} /> <span className="nbv-make-text">Quiz</span>
         </button>
         <button className="nbv-make-wide" disabled={off} onClick={onCreateCards}>
-          <FlashcardsIcon size={18} /> Flashcards
+          <FlashcardsIcon size={18} /> <span className="nbv-make-text">Flashcards</span>
         </button>
       </div>
       {disabled && <p className="muted small">Add posts to this notebook to start creating.</p>}
@@ -274,19 +219,17 @@ function StudioPanel({ notebookId, notebookTitle, docs, chats, currentChatId, di
             </span>
           </div>
         ))}
-        {others?.map((a) => (
+        {others?.map((a) => a.type === "slide_deck" ? (
+          <SlideDeckRow key={a.id} artifact={a} onRemoved={(id) => setArtifacts((list) => (list ?? []).filter((x) => x.id !== id))} />
+        ) : a.type === "audio_overview" ? (
+          <AudioOverviewCard key={a.id} artifact={a} onRemoved={(id) => setArtifacts((list) => (list ?? []).filter((x) => x.id !== id))} />
+        ) : (
           <ArtifactCard
             key={a.id}
             artifact={a}
             onCite={cite}
             onRemoved={(id) => setArtifacts((list) => (list ?? []).filter((x) => x.id !== id))}
-            actions={(art) => canPost(art) ? <PostButton artifactId={art.id} /> :
-              art.type === "audio_overview" && art.status === "ready" ? (
-                <button className="btn btn-small" onClick={() => make({ type: "video", style: "audiogram", audio_artifact_id: art.id })}>
-                  Audiogram
-                </button>
-              ) : null
-            }
+            actions={(art) => canPost(art) ? <PostButton artifactId={art.id} /> : null}
           />
         ))}
       </div>}
@@ -297,6 +240,10 @@ function StudioPanel({ notebookId, notebookTitle, docs, chats, currentChatId, di
                                    error={null} onClose={onReportClose} onCreate={makeReport} />}
       {infographicOpen && <InfographicDialog notebookId={notebookId} notebookTitle={notebookTitle} chats={chats} currentChatId={currentChatId}
                                              busy={false} error={null} onClose={onInfographicClose} onCreate={makeInfographic} />}
+      {audioOpen && <AudioOverviewDialog notebookId={notebookId} notebookTitle={notebookTitle} chats={chats} currentChatId={currentChatId}
+                                         onClose={onAudioClose} onCreate={makeAudio} />}
+      {slidesOpen && <SlideDeckDialog notebookId={notebookId} notebookTitle={notebookTitle} chats={chats} currentChatId={currentChatId}
+                                      onClose={onSlidesClose} onCreate={makeSlides} />}
       {cardsOpen && <FlashcardsDialog notebookId={notebookId} notebookTitle={notebookTitle} chats={chats} currentChatId={currentChatId} busy={false}
                                       error={null} onClose={onCardsClose} onCreate={makeCards} />}
       {mapDialog && <MindMapDialog docs={docs} busy={false} error={null} onClose={() => setMapDialog(false)} onCreate={makeMap} />}
@@ -319,6 +266,8 @@ export default function NotebookView() {
   const [makingQuiz, setMakingQuiz] = useState(false); // the quiz settings are open in a modal
   const [makingInfographic, setMakingInfographic] = useState(false); // the infographic settings are open in a modal
   const [makingCards, setMakingCards] = useState(false); // the flashcard settings are open in a modal
+  const [makingSlides, setMakingSlides] = useState(false); // the slide deck settings are open in a modal
+  const [makingAudio, setMakingAudio] = useState(false); // the audio overview settings are open in a modal
   const [makingReport, setMakingReport] = useState(false); // the report dialog is open in a modal
   const [toAdd, setToAdd] = useState<string[]>([]);
   const [addError, setAddError] = useState<string | null>(null);
@@ -335,6 +284,8 @@ export default function NotebookView() {
   const chatLoad = useRef(0);
   const asked = useRef(false);
   const bottom = useRef<HTMLDivElement>(null);
+  const layout = useRef<HTMLDivElement>(null);
+  const panes = usePaneWidths(layout, { leftOpen: historyOpen }); // the side panels' dragged widths
 
   // Auto-save the title shortly after the user stops typing.
   useEffect(() => {
@@ -527,6 +478,16 @@ export default function NotebookView() {
     setMakingInfographic(true);
   };
 
+  const openAudio = () => {
+    seedDocs(nb.id, nb.documents);
+    setMakingAudio(true);
+  };
+
+  const openSlides = () => {
+    seedDocs(nb.id, nb.documents);
+    setMakingSlides(true);
+  };
+
   const openCards = () => {
     seedDocs(nb.id, nb.documents);
     setMakingCards(true);
@@ -544,7 +505,9 @@ export default function NotebookView() {
   };
 
   return (
-    <div className={`nbv${historyOpen ? "" : " nbv-history-closed"}`}>
+    <div ref={layout} className={`nbv${historyOpen ? "" : " nbv-history-closed"}`} style={panes.style}>
+      <PaneResizer side="left" panes={panes} container={layout} label="Resize the chats panel" />
+      <PaneResizer side="right" panes={panes} container={layout} label="Resize the create panel" />
       {historyOpen && <aside className="nbv-pane nbv-history" aria-label="Notebook chats">
         <Link to="/app/notebooks" className="nbv-history-back">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.7" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
@@ -753,6 +716,8 @@ export default function NotebookView() {
                      onQuizClose={() => setMakingQuiz(false)} onCreateQuiz={openQuiz}
                      reportOpen={makingReport} onReportClose={() => setMakingReport(false)} onCreateReport={openReport}
                      infographicOpen={makingInfographic} onInfographicClose={() => setMakingInfographic(false)} onCreateInfographic={openInfographic}
+                     audioOpen={makingAudio} onAudioClose={() => setMakingAudio(false)} onCreateAudio={openAudio}
+                     slidesOpen={makingSlides} onSlidesClose={() => setMakingSlides(false)} onCreateSlides={openSlides}
                      cardsOpen={makingCards} onCardsClose={() => setMakingCards(false)} onCreateCards={openCards}
                      disabled={nb.documents.length === 0}
                      onCreateVideo={() => {

frontend/src/styles/pages.css

@@ -3415,7 +3415,8 @@ select.input,
   }
 
   .nbv {
-    grid-template-columns: clamp(16rem, 20vw, 20rem) minmax(0, 1fr);
+    position: relative; /* the resize handles are placed over the boundaries */
+    grid-template-columns: var(--nbv-left, clamp(16rem, 20vw, 20rem)) minmax(0, 1fr);
     grid-template-areas:
       "history chat"
       "history side";
@@ -3483,12 +3484,12 @@ select.input,
   }
 
   .nbv {
-    grid-template-columns: clamp(16rem, 20vw, 20rem) minmax(0, 1fr) clamp(18rem, 24vw, 24rem);
+    grid-template-columns: var(--nbv-left, clamp(16rem, 20vw, 20rem)) minmax(0, 1fr) var(--nbv-right, clamp(18rem, 24vw, 24rem));
     grid-template-areas: "history chat side";
   }
 
   .nbv.nbv-history-closed {
-    grid-template-columns: minmax(0, 1fr) clamp(18rem, 24vw, 24rem);
+    grid-template-columns: minmax(0, 1fr) var(--nbv-right, clamp(18rem, 24vw, 24rem));
     grid-template-areas: "chat side";
   }
 
@@ -4612,52 +4613,6 @@ details.map-legend[open] summary {
   border-color: var(--blue);
 }
 
-.nbv-audio-opts {
-  display: grid;
-  gap: 12px;
-  padding: 14px;
-  border: 1px solid var(--blue-35);
-  border-radius: var(--radius-sm);
-  background: var(--blue-05);
-}
-
-.nbv-audio-row {
-  display: grid;
-  grid-template-columns: minmax(0, 1.25fr) minmax(0, 1fr); /* Format needs a little more room than Length */
-  gap: 10px;
-}
-
-/* Each dropdown fills its column and can shrink, instead of spilling into its neighbour */
-.nbv-audio-row > .field {
-  min-width: 0;
-}
-
-.nbv-audio-row > .field > * {
-  width: 100%;
-  min-width: 0;
-}
-
-.nbv-audio-opts .dropdown-btn {
-  padding: 0 12px;
-  font-size: 0.9rem;
-}
-
-.nbv-audio-opts .dropdown-btn {
-  height: 40px;
-  border-radius: 12px;
-}
-
-.nbv-audio-opts > .btn {
-  justify-self: end;
-}
-
-.nbv-audio-opts .dropdown-value {
-  min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
-
 /* ---------- Mind map: the right-rail tile and list, the dialog, and the galaxy explorer ---------- */
 .nbv-make .nbv-make-map {
   grid-column: 1 / -1;
@@ -7559,13 +7514,12 @@ details.map-legend[open] summary {
   border-top-color: var(--black);
 }
 
-/* Create buttons: two to a row. Audio overview (with its options) and Mind Constellation take a whole row. */
+/* Create buttons: two to a row. Audio overview shares its row with Slide deck; its options and Mind Constellation take
+   a whole row. */
 .nbv-make {
   grid-template-columns: repeat(2, minmax(0, 1fr));
 }
 
-.nbv-make .nbv-make-main,
-.nbv-make .nbv-audio-opts,
 .nbv-make .nbv-make-stars {
   grid-column: 1 / -1;
 }
@@ -8221,3 +8175,954 @@ details.map-legend[open] summary {
 .nbv-starting-text strong {
   font: 500 0.92rem var(--font-body);
 }
+
+
+/* ---- Slide decks ------------------------------------------------------------------------------------------------ */
+
+.sd-dialog {
+  gap: 22px;
+}
+
+/* The settings: the two styles across one row, then format, length and language side by side */
+.sd-themes {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 220px));
+  justify-content: center;
+  gap: 16px;
+}
+
+.sd-theme {
+  display: grid;
+  gap: 6px;
+  padding: 5px 5px 8px;
+  text-align: left;
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  background: transparent;
+  color: inherit;
+  cursor: pointer;
+  transition: border-color 0.15s, box-shadow 0.15s;
+}
+
+.sd-theme:hover {
+  border-color: var(--line-strong);
+}
+
+.sd-theme.on {
+  border-color: var(--blue);
+  box-shadow: 0 0 0 1px var(--blue), var(--glow-sm);
+}
+
+.sd-theme-img {
+  position: relative;
+  display: block;
+}
+
+.sd-theme-img img {
+  display: block;
+  width: 100%;
+  aspect-ratio: 16 / 9; /* the whole slide, small */
+  object-fit: cover;
+  border-radius: 8px;
+}
+
+.sd-check {
+  position: absolute;
+  top: 6px;
+  right: 6px;
+  display: grid;
+  place-items: center;
+  width: 22px;
+  height: 22px;
+  border-radius: 50%;
+  background: var(--black);
+  color: var(--white);
+  box-shadow: 0 0 0 2px var(--blue);
+}
+
+.sd-theme-name {
+  padding: 0 4px;
+  text-align: center;
+  font-size: 0.85rem;
+  font-weight: 600;
+}
+
+.sd-opts {
+  display: grid;
+  grid-template-columns: auto minmax(210px, 1fr) minmax(140px, 0.7fr); /* format as wide as its pills */
+  column-gap: 28px;
+  row-gap: 14px;
+  align-items: start;
+}
+
+.sd-opts .field {
+  gap: 8px;
+  min-width: 0;
+}
+
+/* The dropdowns stay inside their column: a long value shortens with an ellipsis */
+.sd-opts .dropdown,
+.sd-opts .dropdown-btn {
+  min-width: 0;
+  max-width: 100%;
+}
+
+.sd-opts .dropdown-value {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* The length's slide range, inside its dropdown: the same small grey text as the hints under the other fields */
+.sd-opts .dropdown-value .muted {
+  font-size: 0.83em;
+}
+
+.sd-opts .dropdown-btn {
+  padding-left: 16px;
+  padding-right: 14px;
+}
+
+/* Format pills look exactly like the dropdowns beside them: same height, text, border and fill */
+.sd-opts .vw-chips {
+  flex-wrap: nowrap;
+  gap: 8px;
+}
+
+.sd-opts .vw-chip {
+  display: inline-flex;
+  align-items: center;
+  height: 48px;
+  padding: 0 18px;
+  border: 1px solid var(--line-strong);
+  border-radius: 999px;
+  background: rgba(0, 0, 0, 0.6);
+  color: var(--text);
+  font: 500 1rem var(--font-body);
+  white-space: nowrap;
+}
+
+.sd-opts .vw-chip.on {
+  border-color: var(--blue);
+  background: var(--blue);
+  color: var(--white);
+}
+
+.sd-opts .vw-chip:hover:not(.on) {
+  border-color: var(--blue-60);
+}
+
+/* The format's description wraps under the pills instead of widening their column */
+.sd-opts > .field:first-child > small {
+  display: block;
+  width: 0;
+  min-width: 100%;
+}
+
+/* A little more room than other dialogs, for the three settings side by side */
+.modal.modal-wide:has(.sd-dialog) {
+  width: min(840px, calc(100vw - 32px));
+}
+
+.sd-prompt {
+  width: 100%;
+  min-height: 92px;
+  padding: 14px 18px;
+  border-radius: 14px;
+  line-height: 1.55;
+  resize: vertical;
+}
+
+/* One 1920 x 1080 slide, scaled into whatever box it is given. */
+.sd-frame {
+  position: relative;
+  width: 100%;
+  overflow: hidden;
+  background: #000;
+}
+
+.sd-frame-width {
+  aspect-ratio: 16 / 9;
+}
+
+.sd-frame-contain {
+  position: absolute;
+  inset: 0;
+  background: transparent;
+}
+
+.sd-frame iframe {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  border: 0;
+  transform-origin: center center;
+  pointer-events: none;
+}
+
+/* A deck in the notebook's list: a quiet row (icon, title, "2 sources · 5d ago", menu), highlighted on hover */
+.sd-item {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  column-gap: 4px;
+  padding: 4px 4px 4px 0;
+  border-radius: 16px;
+  transition: background 0.15s;
+}
+
+.sd-item.is-ready:hover,
+.sd-item:focus-within {
+  background: var(--surface-2);
+}
+
+.sd-item-main {
+  display: grid;
+  grid-template-columns: 40px minmax(0, 1fr);
+  align-items: center;
+  gap: 10px;
+  min-width: 0;
+  padding: 8px 4px 8px 10px;
+  border-radius: 16px;
+  outline: none;
+}
+
+.sd-item.is-ready .sd-item-main {
+  cursor: pointer;
+}
+
+.sd-item-main:focus-visible {
+  box-shadow: 0 0 0 2px var(--blue);
+}
+
+.sd-item-icon {
+  display: grid;
+  place-items: center;
+  width: 40px;
+  height: 40px;
+  color: var(--blue);
+}
+
+.sd-item-text {
+  display: grid;
+  gap: 2px;
+  min-width: 0;
+}
+
+.sd-item-text strong {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-weight: 500;
+  font-size: 0.95rem;
+  color: var(--text);
+}
+
+.sd-item-meta {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 0.82rem;
+  color: var(--text-3);
+}
+
+.sd-item .sd-menu-wrap .sd-icon-btn {
+  color: var(--text-2);
+}
+
+.sd-item-progress {
+  grid-column: 1 / -1;
+  padding: 0 12px 8px 60px;
+}
+
+.sd-item-failed {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.sd-item-failed p {
+  flex: 1;
+  margin: 0;
+}
+
+.sd-rename {
+  width: 100%;
+  padding: 4px 10px;
+  font-size: 0.95rem;
+}
+
+/* The deck's popup: actions along the top, every slide below it */
+.modal.modal-wide:has(.sd-view) {
+  width: min(980px, calc(100vw - 32px));
+  max-height: calc(100vh - 32px);
+  display: flex;
+  flex-direction: column;
+  transition: width 0.2s ease;
+}
+
+.modal.modal-wide:has(.sd-view.big) {
+  width: calc(100vw - 32px);
+  height: calc(100vh - 32px);
+}
+
+.modal:has(.sd-view) .modal-head {
+  gap: 12px;
+}
+
+.modal:has(.sd-view) .modal-head h2 {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.sd-head-actions {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  flex: none;
+}
+
+.sd-icon-btn {
+  display: grid;
+  place-items: center;
+  width: 38px;
+  height: 38px;
+  padding: 0;
+  border: 0;
+  border-radius: 50%;
+  background: transparent;
+  color: var(--text);
+  cursor: pointer;
+  transition: background 0.15s, color 0.15s;
+}
+
+.sd-icon-btn:hover:not(:disabled),
+.sd-icon-btn[aria-expanded="true"],
+.sd-icon-btn[aria-pressed="true"] {
+  background: var(--surface-2);
+  color: var(--white);
+}
+
+.sd-icon-btn:focus-visible {
+  outline: 2px solid var(--blue);
+  outline-offset: 1px;
+}
+
+.sd-icon-btn:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+.sd-menu-wrap {
+  position: relative;
+}
+
+/* In <body>, above popups (z-index over the modal's backdrop) */
+.sd-menu.sd-menu-floating {
+  position: fixed;
+  top: auto;
+  right: auto;
+  z-index: 2100;
+}
+
+.sd-menu {
+  position: absolute;
+  top: calc(100% + 6px);
+  right: 0;
+  z-index: 20;
+  display: grid;
+  min-width: 270px;
+  padding: 6px;
+  border: 1px solid var(--line-strong);
+  border-radius: var(--radius-sm);
+  background: var(--black);
+  box-shadow: var(--glow-lg);
+}
+
+.sd-menu button {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 10px 12px;
+  border: 0;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--white);
+  font: 500 0.92rem var(--font-body);
+  text-align: left;
+  white-space: nowrap;
+  cursor: pointer;
+}
+
+.sd-menu button:hover,
+.sd-menu button:focus-visible {
+  background: var(--surface-2);
+}
+
+.sd-menu button.danger {
+  color: #ff8a8a;
+}
+
+.sd-confirm p {
+  margin: 0;
+  line-height: 1.6;
+}
+
+.sd-confirm-actions {
+  justify-content: flex-end;
+  gap: 10px;
+}
+
+.sd-menu .error-text {
+  margin: 4px 8px;
+}
+
+.sd-menu-error {
+  position: absolute;
+  top: calc(100% + 6px);
+  right: 0;
+  width: 240px;
+  text-align: right;
+}
+
+.sd-view {
+  display: grid;
+  gap: 12px;
+  min-height: 0;
+  flex: 1;
+}
+
+.sd-meta {
+  margin: 0;
+}
+
+.sd-stack {
+  display: grid;
+  gap: 16px;
+  max-height: calc(100vh - 190px);
+  margin: 0;
+  padding: 0 6px 6px 0;
+  overflow-y: auto;
+  list-style: none;
+}
+
+.sd-view.big .sd-stack {
+  max-height: calc(100vh - 160px);
+  justify-items: center;
+}
+
+.sd-view.big .sd-stack > li {
+  width: min(100%, calc((100vh - 190px) * 16 / 9));
+}
+
+.sd-slide {
+  display: block;
+  width: 100%;
+  padding: 0;
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  overflow: hidden;
+  background: none;
+  cursor: pointer;
+  transition: border-color 0.15s, box-shadow 0.15s;
+}
+
+.sd-slide:hover,
+.sd-slide:focus-visible {
+  border-color: var(--blue-60);
+  box-shadow: var(--glow-sm);
+}
+
+.sd-notes {
+  display: grid;
+  gap: 6px;
+  margin-top: 8px;
+  padding: 14px 18px;
+  border: 1px solid var(--line);
+  border-radius: var(--radius-sm);
+  background: var(--surface);
+  line-height: 1.6;
+}
+
+.sd-notes p {
+  margin: 0;
+}
+
+/* Presenting: the slide fills the screen, letterboxed in its own sky colour; the controls fade when the mouse rests. */
+.sd-present {
+  position: fixed;
+  inset: 0;
+  z-index: 1000;
+  background: #000;
+  cursor: pointer;
+}
+
+.sd-present.light {
+  background: #e9eef9;
+}
+
+.sd-present-stage {
+  position: absolute;
+  inset: 0;
+}
+
+.sd-present-bar {
+  position: absolute;
+  left: 50%;
+  bottom: 22px;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 8px 12px;
+  transform: translateX(-50%);
+  border: 1px solid var(--line-strong);
+  border-radius: 999px;
+  background: rgba(0, 0, 0, 0.72);
+  color: var(--white);
+  cursor: default;
+  transition: opacity 0.3s;
+}
+
+.sd-present.idle {
+  cursor: none;
+}
+
+.sd-present.idle .sd-present-bar {
+  opacity: 0;
+}
+
+.sd-count {
+  min-width: 64px;
+  text-align: center;
+  font: 500 0.85rem var(--font-mono, monospace);
+}
+
+@media (max-width: 760px) {
+  .sd-opts {
+    grid-template-columns: 1fr;
+  }
+
+  .sd-opts .vw-chips {
+    flex-wrap: wrap;
+  }
+
+  .modal:has(.sd-view) .modal-head {
+    flex-wrap: wrap;
+  }
+
+  .sd-icon-btn {
+    width: 34px;
+    height: 34px;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .sd-present-bar,
+  .sd-item,
+  .sd-slide,
+  .sd-icon-btn,
+  .modal.modal-wide:has(.sd-view),
+  .sd-theme {
+    transition: none;
+  }
+}
+
+
+/* ---- Notebook: side panels resized by dragging the line between a panel and the chat (components/PaneResizer) ---- */
+
+.nbv-resizer {
+  display: none;
+}
+
+@media (min-width: 900px) {
+  .nbv-resizer {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    z-index: 6;
+    display: block;
+    width: 12px;
+    margin-left: -6px;
+    cursor: col-resize;
+    touch-action: none;
+  }
+
+  .nbv-resizer::after {
+    content: "";
+    position: absolute;
+    top: 14px;
+    bottom: 14px;
+    left: 5px;
+    width: 2px;
+    border-radius: 2px;
+    background: transparent;
+    transition: background 0.15s, box-shadow 0.15s;
+  }
+
+  .nbv-resizer:hover::after,
+  .nbv-resizer.dragging::after,
+  .nbv-resizer:focus-visible::after {
+    background: var(--blue);
+    box-shadow: 0 0 10px var(--blue-60);
+  }
+
+  .nbv-resizer:focus-visible {
+    outline: none;
+  }
+}
+
+/* While dragging: no text selection, the resize cursor everywhere, and frames (slides, infographics) let the pointer
+   through so the drag is never lost over them. */
+body.nbv-resizing,
+body.nbv-resizing * {
+  cursor: col-resize !important;
+  user-select: none;
+}
+
+body.nbv-resizing iframe {
+  pointer-events: none;
+}
+
+/* The panels' contents follow the panels' own widths, not the window's. */
+.nbv-side,
+.nbv-history,
+.nbv-chat {
+  container-type: inline-size;
+}
+
+/* Create tiles never wrap a word: the label shortens with an ellipsis, the icon stays. */
+.nbv-make > button,
+.nbv-make .nbv-make-label {
+  min-width: 0;
+  overflow: hidden;
+}
+
+.nbv-make .nbv-make-label {
+  flex: 1;
+}
+
+.nbv-make-text {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Tiles per row by the panel's width: one when narrow, two by default, three or four when the panel is wide. */
+@container (max-width: 299px) {
+  .nbv-make {
+    grid-template-columns: minmax(0, 1fr);
+  }
+}
+
+@container (min-width: 560px) {
+  .nbv-make {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+
+  .nbv-make .nbv-make-wide {
+    grid-column: auto;
+  }
+}
+
+@container (min-width: 760px) {
+  .nbv-make {
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .nbv-resizer::after {
+    transition: none;
+  }
+}
+
+
+/* ---- Audio overview settings (components/AudioOverview) ---- */
+
+.ao-dialog {
+  gap: 20px;
+}
+
+.ao-styles {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.ao-style {
+  display: grid;
+  align-content: start;
+  gap: 8px;
+  min-height: 132px;
+  padding: 14px 14px 16px;
+  text-align: left;
+  border: 1px solid var(--line-strong);
+  border-radius: 18px;
+  background: rgba(0, 0, 0, 0.6);
+  color: var(--text);
+  cursor: pointer;
+  transition: border-color 0.15s, background 0.15s;
+}
+
+.ao-style:hover:not(:disabled):not(.on) {
+  border-color: var(--blue-60);
+}
+
+.ao-style.on {
+  border-color: var(--blue);
+  background: var(--blue-20);
+}
+
+.ao-style:disabled {
+  opacity: 0.45;
+  cursor: not-allowed;
+}
+
+.ao-style-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.ao-style-head strong {
+  font-weight: 600;
+}
+
+.ao-radio {
+  display: grid;
+  place-items: center;
+  flex: none;
+  width: 22px;
+  height: 22px;
+  border-radius: 50%;
+  border: 1px solid var(--line-strong);
+}
+
+.ao-style.on .ao-radio {
+  border-color: var(--blue);
+  background: var(--black);
+}
+
+.ao-style-blurb {
+  font-size: 0.85rem;
+  line-height: 1.45;
+  color: var(--text-2);
+}
+
+/* Hosts pills share the slide deck's pill look (.sd-opts); the two voice pickers sit side by side */
+.ao-voices {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 14px;
+}
+
+.ao-voices > p {
+  grid-column: 1 / -1;
+  margin: 0;
+}
+
+@media (max-width: 760px) {
+  .ao-styles {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .ao-voices {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ao-style {
+    transition: none;
+  }
+}
+
+.modal.modal-wide:has(.ao-dialog) {
+  width: min(880px, calc(100vw - 32px));
+}
+
+/* ---- Audio overview in the notebook's list (components/AudioOverview: AudioOverviewCard) ---- */
+
+.ao-card {
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  background: var(--surface);
+  transition: border-color 0.15s;
+}
+
+.ao-card.open {
+  border-color: var(--line-strong);
+}
+
+.ao-card-head {
+  display: grid;
+  grid-template-columns: 40px minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 10px;
+  padding: 10px 10px 10px 8px;
+  border-radius: var(--radius);
+  outline: none;
+}
+
+.ao-card-head[role="button"] {
+  cursor: pointer;
+}
+
+.ao-card-head[role="button"]:hover {
+  background: var(--surface-2);
+}
+
+.ao-card-head:focus-visible {
+  box-shadow: 0 0 0 2px var(--blue);
+}
+
+.ao-card-icon {
+  display: grid;
+  place-items: center;
+  width: 40px;
+  height: 40px;
+  color: var(--blue);
+}
+
+.ao-card-text {
+  display: grid;
+  gap: 2px;
+  min-width: 0;
+}
+
+.ao-card-text strong {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-weight: 500;
+  font-size: 0.95rem;
+}
+
+.ao-card-meta {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  font-size: 0.82rem;
+  color: var(--text-3);
+}
+
+.ao-chevron {
+  display: grid;
+  place-items: center;
+  width: 32px;
+  height: 32px;
+  color: var(--text-2);
+}
+
+.ao-card-progress {
+  padding: 0 12px 10px 58px;
+}
+
+.ao-card-body {
+  display: grid;
+  gap: 12px;
+  padding: 4px 14px 14px;
+}
+
+/* The player: play, time, a seek bar and the speed, in one pill */
+.ao-player {
+  display: grid;
+  grid-template-columns: auto auto minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 12px;
+  padding: 6px 8px 6px 6px;
+  border-radius: 999px;
+  background: var(--surface-2);
+}
+
+.ao-play {
+  display: grid;
+  place-items: center;
+  width: 38px;
+  height: 38px;
+  border: 0;
+  border-radius: 50%;
+  background: var(--blue);
+  color: var(--white);
+  cursor: pointer;
+}
+
+.ao-play:focus-visible,
+.ao-speed:focus-visible {
+  outline: 2px solid var(--blue);
+  outline-offset: 2px;
+}
+
+.ao-time {
+  font-size: 0.8rem;
+  color: var(--text-2);
+  white-space: nowrap;
+}
+
+.ao-seek {
+  width: 100%;
+  height: 4px;
+  margin: 0;
+  border-radius: 2px;
+  background: linear-gradient(to right, var(--blue) var(--ao-fill, 0%), var(--line-strong) var(--ao-fill, 0%));
+  appearance: none;
+  cursor: pointer;
+}
+
+.ao-seek::-webkit-slider-thumb {
+  width: 14px;
+  height: 14px;
+  border-radius: 50%;
+  background: var(--white);
+  appearance: none;
+}
+
+.ao-seek::-moz-range-thumb {
+  width: 14px;
+  height: 14px;
+  border: 0;
+  border-radius: 50%;
+  background: var(--white);
+}
+
+.ao-speed {
+  min-width: 52px;
+  height: 30px;
+  padding: 0 10px;
+  border: 1px solid var(--line-strong);
+  border-radius: 999px;
+  background: transparent;
+  color: var(--text);
+  font-size: 0.8rem;
+  cursor: pointer;
+}
+
+.ao-speed:hover {
+  border-color: var(--blue-60);
+}
+
+.ao-transcript-toggle {
+  justify-self: start;
+}
+
+.ao-card-actions {
+  gap: 8px;
+}
+
+/* Delete reads as a normal button (not dimmed), red when pointed at */
+.ao-delete:hover,
+.ao-delete:focus-visible {
+  border-color: #ef4444;
+  color: #ff8a8a;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ao-card {
+    transition: none;
+  }
+}