Merge pull request #6 from FireBird-Technologies/feat/slide-deck

backend/app/db.py

@@ -11,8 +11,13 @@ class Base(DeclarativeBase):
 
 
 _sqlite = settings.database_url.startswith("sqlite")
-_connect_args = {"check_same_thread": False, "timeout": 30} if _sqlite else {}
-engine = create_engine(settings.database_url, pool_pre_ping=True, connect_args=_connect_args)
+# Postgres: a connection that dies silently (laptop sleep, network change, Neon dropping it) otherwise leaves a query
+# waiting on the socket forever, and the worker loop with it. Keepalives notice a dead peer within about a minute
+# and the query fails instead; connect_timeout does the same for a connect that never completes.
+_pg_connect_args = {"connect_timeout": 10, "keepalives": 1, "keepalives_idle": 30, "keepalives_interval": 10,
+                    "keepalives_count": 3}
+_connect_args = {"check_same_thread": False, "timeout": 30} if _sqlite else _pg_connect_args
+engine = create_engine(settings.database_url, pool_pre_ping=True, pool_recycle=300, connect_args=_connect_args)
 
 if _sqlite:
     # Local dev: the API and the worker share one file. WAL lets reads run during a write, the busy

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,21 @@ 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 BadEdit, restructure
+from app.slides.build import slots as slide_slots
+from app.slides.build import stored as stored_deck
+from app.slides.build import view as slide_pages
+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 +46,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 +69,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 +163,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 +199,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 +282,63 @@ 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}"'})
+
+
+class DeckIn(BaseModel):
+    # The deck's slides as the editor has them, in the stored shape (app.slides.content.empty_slide); coerced on arrival
+    slides: list[dict] = Field(min_length=1, max_length=60)
+
+
+def _editable_deck(ctx: Ctx, artifact_id: uuid.UUID) -> Artifact:
+    a = get_artifact_or_404(ctx, artifact_id)
+    if a.type != "slide_deck" or a.status != "ready":
+        raise HTTPException(400, "Only a finished slide deck can be edited.")
+    return a
+
+
+@router.post("/{artifact_id}/deck-preview")
+def preview_deck(artifact_id: uuid.UUID, body: DeckIn, ctx: Ctx = Depends(get_ctx)):
+    """The editor's slides drawn, without saving: after a slide is added, removed, moved or changed to another layout,
+    or a text box is added or removed. Returns the slides as they will be kept (variants given, text fitted)."""
+    a = _editable_deck(ctx, artifact_id)
+    try:
+        deck = restructure(a.content_json or {}, body.slides, final=False)
+    except BadEdit as exc:
+        raise HTTPException(400, str(exc)) from exc
+    content = {**(a.content_json or {}), "deck": deck}
+    return {"slides": deck["slides"], "slides_html": slide_pages(content), "slide_slots": slide_slots(content)}
+
+
+@router.put("/{artifact_id}/deck")
+def save_deck(artifact_id: uuid.UUID, body: DeckIn, ctx: Ctx = Depends(get_ctx)):
+    """The editor's slides kept: text, speaker notes, and which slides there are, in what order and layout. The deck is
+    fitted again (with the Chrome check), so the slides, the PDF and the PowerPoint all show it."""
+    a = _editable_deck(ctx, artifact_id)
+    try:
+        deck = restructure(a.content_json or {}, body.slides, final=True)
+    except BadEdit as exc:
+        raise HTTPException(400, str(exc)) from exc
+    a.content_json = {**(a.content_json or {}), "deck": deck}
+    ctx.db.commit()
+    return serialize_artifact(a, latest_jobs(ctx.db, [a.id]).get(a.id))
+
+
 @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/routers/launchpad.py

@@ -21,11 +21,21 @@ from app.config import settings
 from app.db import get_db
 from app.models import Artifact, CalendarItem, Document, EngagementEvent, SocialAccount, TrackedLink, Upload
 from app.services import launchpad as lp
-from app.services.artifacts import TYPE_LABELS
+from app.services.artifacts import TYPE_LABELS, download_name
 from app.services.crypto import decrypt, encrypt
 from app.services.social import AUTO_POST, LIMITS, PLATFORM_LABELS, SocialError, bluesky, linkedin, x
 from app.services.social.health import pause_account_posts, resume_account_posts
-from app.services.social.media import MB, SIZE_LIMITS, UPLOAD_TYPES, check_postable, duration, is_blog2video, media_count, upload_kind
+from app.services.social.media import (
+    MB,
+    SIZE_LIMITS,
+    UPLOAD_TYPES,
+    carries_media,
+    check_postable,
+    duration,
+    is_blog2video,
+    media_count,
+    upload_kind,
+)
 from app.services.storage import storage
 
 router = APIRouter(prefix="/api", tags=["launchpad"])
@@ -61,7 +71,7 @@ class When(BaseModel):
 
 class ItemIn(When):
     platform: Platform
-    content: str = Field(min_length=1, max_length=10000)
+    content: str = Field("", max_length=10000)  # may be empty when the post carries images or a video
     thread: list[str] = Field(default_factory=list, max_length=25)
     artifact_id: uuid.UUID | None = None  # the attachment (a video, quote card, carousel...), never a Launch Kit
     kit_id: uuid.UUID | None = None  # the Launch Kit the post was written from (tracked, not attached)
@@ -69,11 +79,13 @@ class ItemIn(When):
     social_account_id: uuid.UUID | None = None
     remind_by_email: bool = False
     draft: bool = False
+    # Post now: published (or, by email, reminded) in this request, never left scheduled; no time needed
+    publish_now: bool = False
 
 
 class ItemPatch(When):
     artifact_id: uuid.UUID | None = None  # set or (null) clear what the post carries
-    content: str | None = Field(None, min_length=1, max_length=10000)
+    content: str | None = Field(None, max_length=10000)
     thread: list[str] | None = None
     social_account_id: uuid.UUID | None = None
     remind_by_email: bool | None = None
@@ -85,7 +97,9 @@ def _aware(dt: datetime) -> datetime:
 
 
 # audio can't be posted; "upload" is a file the user brought from their computer
-POSTABLE = ("video", "quote_card", "carousel", "summary", "launch_kit", "mind_map", "upload")
+POSTABLE = ("video", "quote_card", "carousel", "summary", "launch_kit", "mind_map", "upload", "slide_deck")
+# Listed on the Launchpad too, but only to download: X and LinkedIn take no audio files (check_postable refuses it)
+LISTED = (*POSTABLE, "audio_overview")
 
 
 def _cite_free(text: str) -> str:
@@ -107,22 +121,38 @@ def _prefill(a: Artifact) -> dict:
         "quote_card": f'"{c.get("quote")}"' + (f" ({c['source']})" if c.get("source") else "") if c.get("quote")
                       else title,
         "carousel": ((c.get("slides") or [{}])[0].get("heading") or title),
+        "slide_deck": _deck_prefill(c) or title,
     }.get(a.type, title)
     return {"x": [text], "linkedin": text}
 
 
+def _deck_prefill(c: dict) -> str:
+    """A slide deck's post: its title, its subtitle, and the takeaways of its closing slide."""
+    deck = c.get("deck") or {}
+    slides = deck.get("slides") or []
+    closing = next((s for s in reversed(slides) if s.get("layout") == "closing"), {})
+    head = "\n\n".join(x for x in (deck.get("title"), deck.get("subtitle")) if x)
+    takeaways = "\n".join(f"- {t}" for t in closing.get("takeaways") or [])
+    return "\n\n".join(x for x in (head, takeaways) if x)
+
+
 def artifact_brief(a: Artifact) -> dict:
     """What the composer and the calendar show of the attached artifact."""
     c = a.content_json or {}
     thumb = (a.storage_key if a.type == "quote_card" or upload_kind(a) == "image"
              else (c.get("slide_keys") or [a.storage_key])[0] if a.type == "carousel" else None)
     return {"id": str(a.id), "type": a.type, "type_label": TYPE_LABELS.get(a.type, a.type),
-            "title": c.get("title") or TYPE_LABELS.get(a.type, a.type),
-            "media": upload_kind(a) or ("video" if a.type == "video" else "image" if media_count(a) else "text"),
+            # A deck's title starts "Slide deck: ", which its tag already says
+            "title": (c.get("title") or TYPE_LABELS.get(a.type, a.type)).removeprefix("Slide deck: " if a.type == "slide_deck" else ""),
+            "media": upload_kind(a) or ("video" if a.type == "video" else "audio" if a.type == "audio_overview"
+                                        else "image" if media_count(a) else "text"),
             "media_count": media_count(a), "duration_s": duration(a),
             "thumb_url": storage.presign_get(thumb) if thumb else None,
             # The user's own file, to preview before posting it.
             "view_url": storage.presign_get(a.storage_key) if a.type == "upload" and a.storage_key else None,
+            # An audio overview can't be posted: it is offered to download instead.
+            "download_url": (storage.presign_get(a.storage_key, download_name=download_name(a))
+                             if a.type == "audio_overview" and a.storage_key else None),
             # A blog2video video with scenes but no MP4 yet: listed, but it has to be rendered before it can go out.
             # Made by the video service (blog2video): it opens in the video editor.
             "editable_video": is_blog2video(a),
@@ -197,6 +227,12 @@ def _require_connected(platform: str, account: SocialAccount | None, artifact: A
         raise HTTPException(409, {"code": "reconnect", "message": f"Reconnect {label} to post images and videos."})
 
 
+def _require_words(posts: list[str], artifact: Artifact | None) -> None:
+    """A post needs words, unless it carries images or a video (those can go out without a caption)."""
+    if not any(p.strip() for p in posts) and not carries_media(artifact):
+        raise HTTPException(422, {"code": "no_text", "message": "Write something to post, or attach an image or video."})
+
+
 def _validate_lengths(platform: str, posts: list[str]) -> None:
     limit = LIMITS.get(platform)
     if platform in ("x", "bluesky") and limit:
@@ -251,12 +287,13 @@ def list_items(ctx: Ctx = Depends(get_ctx), start: datetime | None = None, end:
 
 @router.post("/calendar")
 def create_item(body: ItemIn, ctx: Ctx = Depends(get_ctx)):
-    when = body.utc()
+    when = datetime.now(UTC) if body.publish_now else body.utc()
     if when is None:
         raise HTTPException(422, {"code": "no_time", "message": "Pick when it goes out."})
     account = _account(ctx, body.social_account_id, body.platform)
     _validate_lengths(body.platform, [body.content, *body.thread])
     artifact = _postable(ctx, body.artifact_id, body.platform) if body.artifact_id else None
+    _require_words([body.content, *body.thread], artifact)
     kit = _kit(ctx, body.kit_id) if body.kit_id else None
     _require_connected(body.platform, account, artifact)
     if body.document_id and not ctx.db.scalar(select(Document.id).where(Document.id == body.document_id,
@@ -268,13 +305,24 @@ def create_item(body: ItemIn, ctx: Ctx = Depends(get_ctx)):
         kit_id=kit.id if kit else None,
         document_id=body.document_id, social_account_id=account.id if account else None,
         remind_by_email=body.remind_by_email or body.platform not in AUTO_POST or not account,
-        status="draft" if body.draft else "scheduled",
+        status="draft" if body.draft else "publishing" if body.publish_now else "scheduled",
     )
     ctx.db.add(item)
     ctx.db.commit()
+    if body.publish_now:
+        _go_now(ctx, item)
     return _enrich(ctx, [item])[0]
 
 
+def _go_now(ctx: Ctx, item: CalendarItem) -> None:
+    """Publish an item claimed for it ("publishing") now: with images or a video through a job (uploading takes a
+    while; the page follows its status), anything else right here."""
+    if lp.has_media(ctx.db, item):
+        lp.queue_publish(ctx.db, item)
+    else:
+        lp.publish_item(ctx.db, item)
+
+
 @router.patch("/calendar/{item_id}")
 def update_item(item_id: uuid.UUID, body: ItemPatch, ctx: Ctx = Depends(get_ctx)):
     item = _item(ctx, item_id)
@@ -301,15 +349,17 @@ def update_item(item_id: uuid.UUID, body: ItemPatch, ctx: Ctx = Depends(get_ctx)
     if body.status == "paused":
         item.status = "paused"  # held by hand: never attempted until resumed
     elif body.status is not None or item.status in ("failed", "reminded", "paused"):
-        # Going out (again): only through a live connection, and only at a time still ahead.
+        # Going out (again), rescheduled: only through a live connection, and only at a time still ahead (a failed or
+        # reminded post's old time has passed, and it would otherwise go out at the very next run).
         _require_connected(item.platform, account, artifact)
-        if item.status == "paused" and _aware(item.scheduled_at) <= datetime.now(UTC):
+        if (body.status or "scheduled") == "scheduled" and _aware(item.scheduled_at) <= datetime.now(UTC):
             raise HTTPException(409, {"code": "missed", "message": "Pick a time that is still ahead."})
         item.status = body.status or "scheduled"
     elif item.platform in CONNECTED_ONLY and body.model_fields_set & {"social_account_id", "artifact_id"}:
         _require_connected(item.platform, account, artifact)
     item.error = None
     item.attempts = 0
+    _require_words([item.content or "", *(item.thread or [])], artifact)  # e.g. the caption emptied, or the video removed
     _validate_lengths(item.platform, [item.content, *(item.thread or [])])
     ctx.db.commit()
     return _enrich(ctx, [item])[0]
@@ -324,17 +374,16 @@ def delete_item(item_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
 
 
 @router.post("/calendar/{item_id}/publish")
-async def publish_now(item_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
+def publish_now(item_id: uuid.UUID, ctx: Ctx = Depends(get_ctx)):
+    """Publish a scheduled post now. A plain (threadpool) endpoint: its database calls and an inline publish must
+    never hold up the event loop, and with it every other request."""
     item = _item(ctx, item_id)
     if item.status in ("posted", "publishing"):
         raise HTTPException(409, "This post already went out.")
     item.status = "publishing"
     item.attempts = 0
     ctx.db.commit()
-    if lp.has_media(ctx.db, item):
-        lp.queue_publish(ctx.db, item)  # uploading takes a while: a job does it, the page follows the status
-    else:
-        await run_in_threadpool(lp.publish_item, ctx.db, item)
+    _go_now(ctx, item)
     return _enrich(ctx, [item])[0]
 
 
@@ -373,11 +422,12 @@ def register_upload(body: UploadIn, ctx: Ctx = Depends(get_ctx)):
 
 @router.get("/launchpad/postable")
 def postable(ctx: Ctx = Depends(get_ctx), q: str = "", limit: int = 60):
-    """What can be attached to a post: finished videos, quote cards, carousels, summaries, launch kits, mind maps
-    (not audio), newest first. Videos made but not rendered yet are listed too, flagged needs_render (they can only be
-    posted once rendered), and so are videos being rendered, flagged rendering."""
+    """What can be attached to a post: finished videos, quote cards, carousels, summaries, launch kits, mind maps,
+    slide decks, newest first, and audio overviews (listed to download: they can't be posted). Videos made but not
+    rendered yet are listed too, flagged needs_render (they can only be posted once rendered), and so are videos being
+    rendered, flagged rendering."""
     rows = ctx.db.scalars(select(Artifact).where(Artifact.workspace_id == ctx.workspace.id,
-                                                 Artifact.type.in_(POSTABLE))
+                                                 Artifact.type.in_(LISTED))
                           .order_by(Artifact.created_at.desc()).limit(400))
     needle = q.strip().lower()
     out = []
@@ -391,6 +441,18 @@ def postable(ctx: Ctx = Depends(get_ctx), q: str = "", limit: int = 60):
             out.append(artifact_brief(a))
         if len(out) >= min(limit, 200):
             break
+    # What each one already has coming up (scheduled, still ahead), soonest first: the list offers to reschedule it
+    upcoming = ctx.db.scalars(select(CalendarItem).where(
+        CalendarItem.workspace_id == ctx.workspace.id, CalendarItem.status == "scheduled",
+        CalendarItem.scheduled_at > datetime.now(UTC),
+        CalendarItem.artifact_id.in_([uuid.UUID(b["id"]) for b in out])).order_by(CalendarItem.scheduled_at))
+    by_artifact: dict[str, list[dict]] = {}
+    for it in upcoming:
+        by_artifact.setdefault(str(it.artifact_id), []).append(
+            {"id": str(it.id), "scheduled_at": _aware(it.scheduled_at).isoformat(),
+             "platform_label": PLATFORM_LABELS.get(it.platform, it.platform)})
+    for b in out:
+        b["scheduled"] = by_artifact.get(b["id"], [])
     return out
 
 

backend/app/services/artifacts.py

@@ -9,6 +9,8 @@ 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 slots as slide_slots
+from app.slides.build import view as slide_pages
 
 TYPE_LABELS = {
     "summary": "Summary",
@@ -22,6 +24,7 @@ TYPE_LABELS = {
     "flashcards": "Flashcards",
     "report": "Report",
     "infographic": "Infographic",
+    "slide_deck": "Slide deck",
     "upload": "Upload",
 }
 
@@ -84,6 +87,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), "slide_slots": slide_slots(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 []
@@ -99,7 +104,7 @@ def serialize_artifact(a: Artifact, job: Job | None = None) -> dict:
         "storage_key": a.storage_key,
         # blog2video videos live on blog2video's storage (video_url once rendered)
         "url": storage.presign_get(a.storage_key) if a.storage_key else content.get("video_url"),
-        "download_url": (storage.presign_get(a.storage_key, download_name=_download_name(a)) if a.storage_key
+        "download_url": (storage.presign_get(a.storage_key, download_name=download_name(a)) if a.storage_key
                          else content.get("video_url")),
         "provider": content.get("provider"),
         "slide_urls": [storage.presign_get(k) for k in slides],
@@ -108,7 +113,8 @@ def serialize_artifact(a: Artifact, job: Job | None = None) -> dict:
     }
 
 
-def _download_name(a: Artifact) -> str:
+def download_name(a: Artifact) -> str:
+    """The file name a download is saved under: the artifact's title and its file's extension."""
     title = (a.content_json or {}).get("title") or a.type
     ext = (a.storage_key or "").rsplit(".", 1)[-1]
     return f"{title[:60]}.{ext}"

backend/app/services/launchpad.py

@@ -21,7 +21,7 @@ from app.services.email import email_service
 from app.services.jobs import create_job
 from app.services.social import AUTO_POST, PLATFORM_LABELS, SocialError, module
 from app.services.social.health import mark_down
-from app.services.social.media import media_count, media_for
+from app.services.social.media import carries_media, media_count, media_for
 
 log = logging.getLogger("notestack.launchpad")
 _URL = re.compile(r"https?://[^\s)\]>]+")
@@ -60,6 +60,8 @@ def owner_email(db: Session, workspace_id) -> str | None:
 def publish_item(db: Session, item: CalendarItem) -> CalendarItem:
     """Publish or remind now. Leaves the item posted, reminded, failed, or scheduled again for a retry."""
     posts = [p for p in [item.content, *(item.thread or [])] if p and p.strip()]
+    if not posts and carries_media(db.get(Artifact, item.artifact_id) if item.artifact_id else None):
+        posts = [""]  # a video or images on their own: the post goes out without a caption
     if not posts:
         item.status, item.error = "failed", "Nothing to post."
         db.commit()

backend/app/services/social/media.py

@@ -1,4 +1,5 @@
-"""What a scheduled post carries from the artifact it was made from: images (quote cards, carousel slides) or one
+"""What a scheduled post carries from the artifact it was made from: images (quote cards, carousel slides, a slide
+deck's slides, drawn when the post goes out) or one
 video (an audiogram, or a blog2video video), or a file the user uploaded from their computer (an `upload`: one image or
 one MP4). Summaries, launch kits and mind maps post as text; audio overviews can't
 be posted (X and LinkedIn take no audio files).
@@ -69,11 +70,18 @@ def media_count(a: Artifact) -> int:
         return 1
     if a.type == "carousel":
         return len((a.content_json or {}).get("slide_keys") or ([a.storage_key] if a.storage_key else []))
+    if a.type == "slide_deck":
+        return len(((a.content_json or {}).get("deck") or {}).get("slides") or [])
     if a.type in ("video", "upload"):
         return 1
     return 0
 
 
+def carries_media(a: Artifact | None) -> bool:
+    """Whether a post of this artifact carries images or a video: such a post may go out without a caption."""
+    return a is not None and a.type not in TEXT_ONLY and media_count(a) > 0
+
+
 def upload_kind(a: Artifact) -> str | None:
     """An uploaded file's kind: image | video."""
     return (a.content_json or {}).get("media") if a.type == "upload" else None
@@ -91,13 +99,16 @@ def check_postable(a: Artifact, platform: str) -> None:
         raise HTTPException(400, "Audio can't be posted: X and LinkedIn don't take audio files.")
     if a.type == "launch_kit":  # a post is written from a kit (kit_id); the kit itself is never an attachment
         raise HTTPException(400, "A launch kit can't be attached. Attach a video, quote card or carousel instead.")
-    if a.type not in TEXT_ONLY and a.type not in ("quote_card", "carousel", "video", "upload"):
+    if a.type not in TEXT_ONLY and a.type not in ("quote_card", "carousel", "video", "upload", "slide_deck"):
         raise HTTPException(400, "This can't be posted.")
     if a.type in TEXT_ONLY:
         return
     if platform not in MEDIA_PLATFORMS:
         raise HTTPException(400, "Images and videos can only be posted to X and LinkedIn.")
-    if a.type == "video" and is_blog2video(a):
+    if a.type == "slide_deck":  # drawn from the deck when the post goes out: nothing stored to wait for
+        if a.status != "ready" or not media_count(a):
+            raise HTTPException(400, "This slide deck isn't ready yet. Post it once it has finished.")
+    elif a.type == "video" and is_blog2video(a):
         if not (a.content_json or {}).get("video_url"):
             raise HTTPException(400, "This video isn't finished yet. Post it once it has rendered.")
     elif a.status != "ready" or not a.storage_key:
@@ -134,6 +145,9 @@ def media_for(a: Artifact | None, platform: str) -> Iterator[list[Media]]:
                 keys = (a.content_json or {}).get("slide_keys") or [a.storage_key]
                 out = [Media("image", f"slide-{i + 1}.png", "image/png", data=storage.get_bytes(k))
                        for i, k in enumerate(keys[:MAX_IMAGES[platform]])]
+            elif a.type == "slide_deck":
+                out = [Media("image", f"slide-{i + 1}.png", "image/png", data=png)
+                       for i, png in enumerate(_slide_images(a, MAX_IMAGES[platform]))]
             elif a.type == "upload" and upload_kind(a) == "image":
                 c = a.content_json or {}
                 out = [Media("image", c.get("filename") or "image", c.get("content_type") or "image/png",
@@ -160,6 +174,21 @@ def media_for(a: Artifact | None, platform: str) -> Iterator[list[Media]]:
                 os.unlink(path)
 
 
+def _slide_images(a: Artifact, limit: int) -> list[bytes]:
+    """A slide deck's first `limit` slides as PNGs, exactly as the deck shows them."""
+    from app.infographics.image import ImageUnavailable
+    from app.slides import export
+    from app.slides.build import stored
+
+    got = stored(a.content_json or {})
+    if not got:
+        raise SocialError("This slide deck has no slides to post.", permanent=True)
+    try:
+        return export.render_slide_pngs(*got, limit=limit)
+    except ImageUnavailable as exc:  # no Chrome on this worker right now: worth another try
+        raise SocialError(f"The slides could not be drawn: {exc}") from exc
+
+
 def _temp_file(temps: list[str]) -> str:
     fd, path = tempfile.mkstemp(prefix="notestack-post-", suffix=".mp4")
     os.close(fd)

backend/app/services/social/x.py

@@ -157,7 +157,7 @@ def publish(db: Session, account: SocialAccount, posts: list[str], media: list |
         media_ids = [(_upload_video if m.kind == "video" else _upload_image)(headers, m) for m in media]
     first_id, reply_to = None, None
     for text in posts:
-        body: dict = {"text": text}
+        body: dict = {"text": text} if text else {}  # X takes a post with media and no text, but not an empty text
         if reply_to:
             body["reply"] = {"in_reply_to_tweet_id": reply_to}
         elif media_ids:

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,151 @@
+"""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. `restructure` takes a deck back from the editor and fits it again.
+`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
+import random
+from collections import Counter
+
+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 GEOMETRY, SCALES, VARIANTS, assign_variants, compose, fits_variant, 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, then refit. 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)
+    return refit(deck, theme, fmt, seed)
+
+
+def refit(deck: dict, theme: str, fmt: str, seed: int) -> dict:
+    """Fitted text and a Chrome check that no text box overflows (slides that do are drawn a step smaller and fitted
+    again), keeping each slide's variant. Raises ValueError when a slide cannot be drawn at all."""
+    theme = theme_id(theme)
+    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
+
+
+class BadEdit(ValueError):
+    """A deck sent back from the editor that cannot be kept (no slides, or too many)."""
+
+
+MAX_SLIDES = 30
+
+
+def fill_variants(slides: list[dict], theme: str, seed: int) -> None:
+    """Give a variant, in place, to each slide that has none or whose variant no longer suits it (a new slide, a changed
+    layout, a card row now with five points). Every other slide keeps its own, so editing one slide never redraws the
+    rest. The choice follows assign_variants: suited to the content, not the same as a neighbour, unused ones first."""
+    theme = theme_id(theme)
+    def ok(i: int) -> bool:
+        s = slides[i]
+        return s["variant"] in VARIANTS[s["layout"]] and fits_variant(s, theme, s["variant"])
+    keep = [ok(i) for i in range(len(slides))]
+    for i, s in enumerate(slides):
+        before = (slides[i - 1]["layout"], slides[i - 1]["variant"]) if i else None
+        if keep[i] and (s["layout"], s["variant"]) != before:
+            continue
+        after = (slides[i + 1]["layout"], slides[i + 1]["variant"]) if i + 1 < len(slides) and keep[i + 1] else None
+        options = [v for v in VARIANTS[s["layout"]] if fits_variant(s, theme, v)] or list(VARIANTS[s["layout"]])
+        fresh = [v for v in options if (s["layout"], v) not in (before, after)] or options
+        used = Counter((x["layout"], x["variant"]) for j, x in enumerate(slides) if j != i)
+        rnd = random.Random(seed + i)
+        s["variant"] = min(fresh, key=lambda v: (used[(s["layout"], v)], rnd.random()))
+        keep[i] = True
+
+
+def restructure(content: dict, slides: object, final: bool) -> dict:
+    """The stored deck with the slides the editor sent (text edited, slides added, removed, moved, or changed to another
+    layout). They are coerced like model output (clamp_deck: plain text, the format's limits, valid layouts), slides
+    that need one get a variant, and the deck is fitted: quickly for a preview, with the Chrome check when `final`."""
+    got = stored(content)
+    if not got:
+        raise BadEdit("This deck has no slides to edit.")
+    deck, theme, fmt, seed = got
+    if not isinstance(slides, list) or not slides:
+        raise BadEdit("A deck needs at least one slide.")
+    if len(slides) > MAX_SLIDES:
+        raise BadEdit(f"A deck can have at most {MAX_SLIDES} slides.")
+    new = clamp_deck({"title": deck["title"], "subtitle": deck["subtitle"], "slides": slides}, fmt)
+    if not new:
+        raise BadEdit("A deck needs at least one slide with a heading.")
+    for s in new["slides"]:
+        s["shrink"] = 0  # text changed: fitted afresh, so shorter text can be drawn larger again
+    fill_variants(new["slides"], theme, seed)
+    return refit(new, theme, fmt, seed) if final else fit(new, theme, fmt, seed)
+
+
+def slots(content: dict) -> list[list[str]]:
+    """For each slide, the parts its variant has a place for (kicker, lead, body, by, closing...): what the editor
+    can offer to add."""
+    got = stored(content)
+    if not got:
+        return []
+    deck, theme, _fmt, _seed = got
+    out = []
+    for s in deck["slides"]:
+        variants = GEOMETRY[theme][s["layout"]]
+        out.append(sorted(k for k, v in (variants.get(s["variant"]) or next(iter(variants.values()))).items() if v))
+    return out
+
+
+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,204 @@
+"""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}
+
+
+_LIMIT_KEY = {"kicker": "kicker", "heading": "heading", "lead": "lead", "closing": "closing", "stat.value": "value",
+              "stat.label": "stat_label", "quote.text": "quote", "quote.by": "by", "left.label": "label",
+              "right.label": "label", "left.items": "item", "right.items": "item", "points.term": "term",
+              "points.text": "text", "takeaways": "takeaway"}
+
+
+def field_limit(layout: str, field: str, fmt: str) -> int:
+    """How many characters `field` may hold on a slide of this layout: what clamp_slide cuts it to."""
+    lim = LIMITS[fmt if fmt in FORMATS else "detailed"]
+    key = re.sub(r"\.\d+", "", field)  # "points.2.text" -> "points.text"
+    if layout == "title" and key in ("heading", "lead"):
+        return lim["title" if key == "heading" else "subtitle"]
+    if layout == "agenda" and key == "points.text":
+        return lim["agenda"]
+    return lim[_LIMIT_KEY[key]]
+
+
+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,185 @@
+"""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 | band | 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)
+    # ring, band: only this part of the path, in degrees round it (0 to 180 is the half nearer the viewer, below the
+    # centre before the tilt). None: all of it.
+    arc: tuple[float, float] | None = None
+    inner: float = 0  # band: the inner edge, as a share of rx and ry (the band fills from there out to the ring)
+
+
+@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 on_ring(ring: Shape, degrees: float) -> tuple[float, float]:
+    """The point at `degrees` round a ring's path, after its tilt: where a planet sits so it is on the drawn line.
+    Same maths as the renderers (SVG rotate(rot cx cy), the PowerPoint's polyline)."""
+    a, rot = math.radians(degrees), math.radians(ring.rot)
+    x, y = ring.rx * math.cos(a), ring.ry * math.sin(a)
+    return ring.cx + x * math.cos(rot) - y * math.sin(rot), ring.cy + x * math.sin(rot) + y * math.cos(rot)
+
+
+def ring_path(s: Shape, scale: float = 1.0, steps: int = 180) -> list[tuple[float, float]]:
+    """Points along a ring's (scaled) path, over its arc, for the renderers to draw."""
+    a0, a1 = s.arc or (0, 360)
+    scaled = Shape("ring", s.cx, s.cy, rx=s.rx * scale, ry=s.ry * scale, rot=s.rot)
+    return [on_ring(scaled, a0 + (a1 - a0) * k / steps) for k in range(steps + 1)]
+
+
+# A ringed planet's band, from the inside out: (inner, outer, opacity) as shares of the ring. A brighter inner ring
+# and a fainter outer one with a dark gap between, as Saturn's are.
+BANDS = ((0.72, 0.86, 0.34), (0.89, 1.0, 0.22))
+NEAR, FAR = (0, 180), (180, 360)
+
+
+def ringed_planet(cx: float, cy: float, r: float, rx: float, ry: float, rot: float, opacity: float = 1.0) -> list[Shape]:
+    """A planet inside its rings: the far half of the rings goes behind the planet and the near half in front, so the
+    rings wrap round it instead of lying flat over its face. The far half is a little dimmer, being further away."""
+    def half(arc: tuple[float, float], op: float) -> list[Shape]:
+        out = [Shape("band", cx, cy, rx=rx * hi, ry=ry * hi, rot=rot, color="accent", opacity=o * op, arc=arc, inner=lo / hi)
+               for lo, hi, o in BANDS]
+        out.append(Shape("ring", cx, cy, rx=rx, ry=ry, rot=rot, color="accent", opacity=0.8 * op, width=2, arc=arc))
+        return out
+    return [*half(FAR, 0.6 * opacity), Shape("planet", cx, cy, r), *half(NEAR, opacity)]
+
+
+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),
+                       *ringed_planet(cx, cy, 230 + j(25), rx=395, ry=82, rot=-18 + j(6))]
+        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),
+                           *ringed_planet(cx, cy, r, rx=r * 1.8, ry=r * 0.38, rot=-16 + j(10), opacity=0.9)]
+    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)
+            orbit = ring(cx, cy, 540, 0.24)
+            shapes += [ring(cx, cy, 360), orbit, ring(cx, cy, 740, 0.18), Shape("planet", *on_ring(orbit, 200 + j(20)), 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)
+            rot = -10 + j(4)  # one tilt for both, so the rings stay concentric
+            orbit = Shape("ring", 960, 520, rx=900, ry=330, rot=rot, color="accent2", opacity=0.28, width=2.5)
+            shapes += [orbit, Shape("ring", 960, 520, rx=1040, ry=400, rot=rot, color="accent2", opacity=0.14, width=2),
+                       Shape("planet", *on_ring(orbit, rnd.choice((20, 160, 200, 340)) + j(10)), 30)]
+        elif key in (("section", "a"), ("section", "b")):
+            cx, toward = (1960, 180) if variant == "a" else (-40, 0)  # the planet sits on the side facing the text
+            orbit = ring(cx, 560, 460, 0.22)
+            shapes += [ring(cx, 560, 300), orbit, ring(cx, 560, 640, 0.15), Shape("planet", *on_ring(orbit, toward + j(10)), 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,356 @@
+"""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, ring_path
+from app.slides.layout import El, compose
+from app.slides.render import SHADE, color, deck_print_html, planet_colors, ring_shade, slides_html
+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)
+
+
+PNG_BATCH = 8  # slides per Chrome run: one tall screenshot cut into slides (one launch per slide was the slow part)
+
+
+def render_slide_pngs(deck: dict, theme: str, fmt: str, seed: int, limit: int) -> list[bytes]:
+    """The first `limit` slides as PNG images at the slide's own size (1920 x 1080), as a post carries them. A batch
+    of slides is drawn stacked on one page and the screenshot is cut at each slide."""
+    theme = theme_id(theme)
+    n = min(limit, len(deck["slides"]))
+    out: list[bytes] = []
+    for start in range(0, n, PNG_BATCH):
+        count = min(PNG_BATCH, n - start)
+        html = slides_html(deck, theme, fmt, seed, start, start + count)
+        shot, _ = _run_chrome(html, [f"--window-size={W},{H * count}", "--screenshot={out}"], "slides.png")
+        sheet = Image.open(io.BytesIO(shot)).convert("RGB")
+        for i in range(count):
+            buf = io.BytesIO()
+            sheet.crop((0, i * H, W, (i + 1) * H)).save(buf, "PNG", optimize=True)
+            out.append(buf.getvalue())
+    return out
+
+
+# --- 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:
+        if s.kind in ("glow", "planet", "band"):  # pasted straight onto the sky: put down the lines drawn so far
+            sky.alpha_composite(layer)  # first, so the order is the page's (a ring's far half behind its planet)
+            layer = Image.new("RGBA", (W, H), (0, 0, 0, 0))
+            draw = ImageDraw.Draw(layer)
+        _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 == "band":
+        sky.alpha_composite(_band(s, c))
+    elif s.kind == "ring" and s.arc:
+        draw.line(ring_path(s), fill=c + (int(255 * s.opacity),), width=max(1, round(s.width)), joint="curve")
+    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 _band(s: Shape, c: tuple[int, int, int]) -> Image.Image:
+    """A ringed planet's band as a slide-sized layer: the shape filled, faded left to right as the page's SHADE."""
+    shape = Image.new("L", (W, H), 0)
+    ImageDraw.Draw(shape).polygon(ring_path(s) + ring_path(s, s.inner)[::-1], fill=255)
+    lo, hi = ring_shade(s)
+    ramp = []
+    for x in range(W):
+        t = min(1.0, max(0.0, (x - lo) / (hi - lo))) if hi > lo else 0.0
+        (o0, a0), (o1, a1) = next((SHADE[k], SHADE[k + 1]) for k in range(len(SHADE) - 1) if t <= SHADE[k + 1][0])
+        ramp.append(int(255 * s.opacity * (a0 + (a1 - a0) * (t - o0) / (o1 - o0))))
+    fade = Image.new("L", (W, 1))
+    fade.putdata(ramp)
+    alpha = Image.new("L", (W, H), 0)
+    alpha.paste(fade.resize((W, H)), mask=shape)
+    out = Image.new("RGBA", (W, H), c + (0,))
+    out.putalpha(alpha)
+    return out
+
+
+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,734 @@
+"""Where everything on a slide goes. Each theme has its own composition for every layout variant (GEOMETRY), the
+variant of each slide is picked by code (assign_variants), and compose() turns one slide into placed elements: boxes
+in pixels on the 1920 x 1080 canvas, each with its text and font size. The HTML and the PowerPoint both draw these
+same elements, so the two always match.
+
+Text is measured here before it is placed: every text box gets the largest font size at which its text fits, and
+text that cannot fit even at the smallest size is shortened. Nothing is ever drawn outside its box."""
+
+import copy
+import math
+import random
+import re
+from dataclasses import dataclass, field
+
+from app.slides.content import LIMITS, clip
+from app.slides.metrics import WIDTHS
+from app.slides.themes import theme_id
+
+# --- geometry -------------------------------------------------------------------------------------------------------
+# A block is (x, y, w, h[, align[, valign[, kind]]]). `kind` says how a body, a column or the closing line is drawn.
+# Night stellar (dark-space): cinematic, centred openers and closers, asymmetric splits. Moon light (light-space):
+# editorial, left aligned, top anchored, mirrored splits.
+
+GEOMETRY: dict[str, dict[str, dict[str, dict[str, tuple]]]] = {
+    "dark-space": {
+        "title": {
+            "a": {"kicker": (360, 258, 1200, 40, "center"), "heading": (160, 312, 1600, 300, "center", "middle"),
+                  "lead": (360, 636, 1200, 130, "center")},
+            "b": {"kicker": (140, 512, 1100, 40), "heading": (140, 562, 1150, 290, "left", "bottom"),
+                  "lead": (140, 872, 1000, 120)},
+            "c": {"kicker": (140, 286, 860, 40), "heading": (140, 340, 880, 400, "left", "middle"),
+                  "lead": (140, 762, 860, 150)},
+        },
+        "agenda": {
+            "a": {"kicker": (140, 160, 700, 40), "heading": (140, 212, 700, 420),
+                  "body": (960, 140, 820, 820, "left", "middle", "agenda_list")},
+            "b": {"kicker": (360, 110, 1200, 40, "center"), "heading": (260, 160, 1400, 130, "center", "middle"),
+                  "body": (220, 340, 1480, 620, "left", "top", "agenda_grid")},
+        },
+        "section": {
+            "a": {"kicker": (360, 368, 1200, 40, "center"), "heading": (210, 420, 1500, 240, "center", "middle"),
+                  "lead": (410, 684, 1100, 150, "center")},
+            "b": {"kicker": (140, 552, 1100, 40), "heading": (140, 604, 1300, 240, "left", "bottom"),
+                  "lead": (140, 864, 1100, 120)},
+        },
+        "points": {
+            "a": {"kicker": (140, 100, 1300, 40), "heading": (140, 150, 1360, 150), "lead": (140, 314, 1300, 110),
+                  "body": (140, 446, 1300, 534, "left", "top", "list")},
+            "b": {"kicker": (140, 160, 640, 40), "heading": (140, 212, 640, 500), "lead": (140, 730, 640, 240),
+                  "body": (880, 130, 900, 840, "left", "middle", "list")},
+            "c": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
+                  "body": (140, 432, 1640, 548, "left", "top", "cards")},
+            "d": {"kicker": (140, 160, 700, 40), "heading": (140, 212, 700, 430), "lead": (140, 662, 700, 300),
+                  "body": (930, 110, 850, 860, "left", "middle", "timeline_v")},
+        },
+        "two_column": {
+            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
+                  "left": (140, 432, 790, 548, "left", "top", "col"), "right": (990, 432, 790, 548, "left", "top", "col")},
+            "b": {"kicker": (360, 90, 1200, 40, "center"), "heading": (210, 140, 1500, 130, "center", "middle"),
+                  "lead": (360, 282, 1200, 90, "center"),
+                  "left": (140, 410, 780, 570, "left", "top", "panel"), "right": (1000, 410, 780, 570, "left", "top", "panel")},
+        },
+        "stat": {
+            "a": {"kicker": (360, 120, 1200, 40, "center"), "heading": (260, 170, 1400, 130, "center", "middle"),
+                  "value": (160, 318, 1600, 300, "center", "middle"), "label": (360, 630, 1200, 120, "center"),
+                  "lead": (410, 776, 1100, 180, "center")},
+            "b": {"kicker": (140, 150, 820, 40), "value": (140, 206, 820, 420, "left", "middle"),
+                  "label": (140, 650, 820, 300), "heading": (1060, 160, 720, 290, "left", "bottom"),
+                  "lead": (1060, 480, 720, 480)},
+        },
+        "quote": {
+            "a": {"kicker": (360, 150, 1200, 40, "center"), "quote": (210, 214, 1500, 500, "center", "middle"),
+                  "by": (360, 740, 1200, 60, "center"), "heading": (360, 846, 1200, 110, "center")},
+            "b": {"kicker": (140, 150, 640, 40), "heading": (140, 202, 640, 400), "lead": (140, 630, 640, 320),
+                  "quote": (900, 160, 880, 640, "left", "middle"), "by": (900, 820, 880, 60)},
+        },
+        "closing": {
+            "a": {"kicker": (360, 90, 1200, 40, "center"), "heading": (210, 140, 1500, 120, "center", "middle"),
+                  "body": (140, 300, 1640, 430, "center", "top", "take_arc"),
+                  "closing": (260, 760, 1400, 190, "center", "middle", "line")},
+            "b": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 120),
+                  "body": (140, 308, 1640, 450, "left", "top", "take_cols"),
+                  "closing": (140, 800, 1640, 170, "left", "middle", "band")},
+            "c": {"kicker": (140, 190, 820, 40), "closing": (140, 244, 820, 600, "left", "middle", "big"),
+                  "heading": (1060, 150, 720, 110), "body": (1060, 290, 720, 680, "left", "top", "take_stack")},
+        },
+    },
+    "light-space": {
+        "title": {
+            "a": {"kicker": (140, 318, 1150, 40), "heading": (140, 368, 1150, 350), "lead": (140, 738, 1000, 150)},
+            "b": {"kicker": (140, 120, 1640, 40), "heading": (140, 174, 1640, 430, "left", "bottom"), "lead": (140, 640, 1150, 170)},
+            "c": {"kicker": (360, 326, 1200, 40, "center"), "heading": (300, 378, 1320, 270, "center", "middle"),
+                  "lead": (410, 670, 1100, 130, "center")},
+        },
+        "agenda": {
+            "a": {"kicker": (140, 110, 1640, 40), "heading": (140, 160, 1640, 130),
+                  "body": (140, 336, 1640, 630, "left", "top", "agenda_grid")},
+            "b": {"kicker": (140, 376, 640, 40), "heading": (140, 428, 640, 320),
+                  "body": (900, 130, 880, 840, "left", "middle", "agenda_list")},
+        },
+        "section": {
+            "a": {"kicker": (140, 408, 1300, 40), "heading": (140, 460, 1300, 240), "lead": (140, 716, 1100, 150)},
+            "b": {"kicker": (620, 408, 1160, 40, "right"), "heading": (480, 460, 1300, 240, "right"),
+                  "lead": (680, 716, 1100, 150, "right")},
+        },
+        "points": {
+            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1500, 100),
+                  "body": (140, 432, 1640, 548, "left", "top", "list2")},
+            "b": {"kicker": (1180, 160, 600, 40), "heading": (1180, 212, 600, 500), "lead": (1180, 730, 600, 240),
+                  "body": (140, 130, 940, 840, "left", "middle", "list")},
+            "c": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
+                  "body": (140, 432, 1640, 548, "left", "top", "cards")},
+            "d": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
+                  "body": (140, 440, 1640, 540, "left", "top", "timeline_h")},
+        },
+        "two_column": {
+            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140), "lead": (140, 302, 1640, 100),
+                  "left": (140, 432, 790, 548, "left", "top", "panel"), "right": (990, 432, 790, 548, "left", "top", "panel")},
+            "b": {"kicker": (140, 160, 560, 40), "heading": (140, 212, 560, 420), "lead": (140, 650, 560, 320),
+                  "left": (780, 130, 1000, 400, "left", "top", "col"), "right": (780, 566, 1000, 400, "left", "top", "col")},
+        },
+        "stat": {
+            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 140),
+                  "value": (140, 330, 900, 360, "left", "middle"), "label": (140, 700, 900, 260),
+                  "lead": (1120, 360, 660, 600)},
+            "b": {"kicker": (360, 130, 1200, 40, "center"), "value": (260, 186, 1400, 320, "center", "middle"),
+                  "label": (360, 526, 1200, 120, "center"), "heading": (260, 690, 1400, 110, "center", "middle"),
+                  "lead": (410, 820, 1100, 150, "center")},
+        },
+        "quote": {
+            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 110),
+                  "quote": (250, 300, 1430, 470, "left", "middle"), "by": (250, 796, 1430, 60)},
+            "b": {"kicker": (620, 130, 1160, 40, "right"), "heading": (620, 180, 1160, 110, "right"),
+                  "quote": (420, 330, 1360, 450, "right", "middle"), "by": (620, 806, 1160, 60, "right")},
+        },
+        "closing": {
+            "a": {"kicker": (140, 100, 1640, 40), "heading": (140, 150, 1640, 120),
+                  "body": (140, 318, 1640, 440, "left", "top", "take_cols"),
+                  "closing": (140, 800, 1640, 170, "left", "middle", "band")},
+            "b": {"kicker": (140, 110, 1640, 40), "closing": (140, 160, 1500, 390, "left", "top", "big"),
+                  "heading": (140, 590, 1640, 80), "body": (140, 690, 1640, 290, "left", "top", "take_row")},
+            "c": {"kicker": (360, 130, 1200, 40, "center"), "heading": (260, 180, 1400, 110, "center", "middle"),
+                  "body": (410, 330, 1100, 410, "left", "top", "take_stack"),
+                  "closing": (260, 772, 1400, 180, "center", "middle", "line")},
+        },
+    },
+}
+
+VARIANTS = {layout: tuple(GEOMETRY["dark-space"][layout]) for layout in GEOMETRY["dark-space"]}
+
+
+def block(theme: str, layout: str, variant: str, name: str) -> tuple | None:
+    g = GEOMETRY[theme_id(theme)][layout].get(variant) or next(iter(GEOMETRY[theme_id(theme)][layout].values()))
+    b = g.get(name)
+    if not b:
+        return None
+    x, y, w, h, *rest = b
+    return (x, y, w, h, rest[0] if rest else "left", rest[1] if len(rest) > 1 else "top", rest[2] if len(rest) > 2 else "")
+
+
+# --- picking variants -----------------------------------------------------------------------------------------------
+
+def fits_variant(slide: dict, theme: str, variant: str) -> bool:
+    """Whether a variant suits this slide's content (a card row needs 3 or 4 points, a timeline 3 to 5)."""
+    layout = slide["layout"]
+    n = len(slide["points"])
+    kind = (block(theme, layout, variant, "body") or (0, 0, 0, 0, "", "", ""))[6]
+    if kind == "cards":
+        return 3 <= n <= 4
+    if kind in ("timeline_v", "timeline_h"):
+        return 3 <= n <= 5
+    if kind == "list2":
+        return n >= 3
+    if kind == "agenda_list":
+        return n <= 7
+    return True
+
+
+def assign_variants(slides: list[dict], theme: str, seed: int, previous: list[tuple[str, str]] | None = None) -> None:
+    """Give every slide a variant, in place. Only variants that suit the slide are considered; the previous slide's
+    layout and variant is never repeated; variants not used yet in this deck come first; and the variant the last deck
+    in the notebook had at the same position is avoided. Ties are broken by `seed` (the deck's own id), so every new
+    deck differs while one deck always draws the same."""
+    theme = theme_id(theme)
+    rnd = random.Random(seed)
+    used: dict[tuple[str, str], int] = {}
+    before: tuple[str, str] | None = None
+    previous = previous or []
+    for i, s in enumerate(slides):
+        options = [v for v in VARIANTS[s["layout"]] if fits_variant(s, theme, v)] or list(VARIANTS[s["layout"]])
+        fresh = [v for v in options if (s["layout"], v) != before]
+        if not fresh:  # the only variant that suits it was just used: any other one draws it too, so never repeat
+            fresh = [v for v in VARIANTS[s["layout"]] if (s["layout"], v) != before] or options
+        last_time = previous[i] if i < len(previous) else None
+
+        scores = {v: (used.get((s["layout"], v), 0), 1 if last_time == (s["layout"], v) else 0, rnd.random())
+                  for v in fresh}
+        choice = min(fresh, key=scores.__getitem__)
+        s["variant"] = choice
+        used[(s["layout"], choice)] = used.get((s["layout"], choice), 0) + 1
+        before = (s["layout"], choice)
+
+
+# --- measuring text -------------------------------------------------------------------------------------------------
+
+def _char_w(c: str, font: str, bold: bool) -> float:
+    """Advance of one character in em, from the fonts' measured widths, padded a little so real text is never wider."""
+    if font == "mono":
+        return 0.62
+    table = WIDTHS["display_bold" if font == "display" else "body_bold" if bold else "body"]
+    w = table.get(c)
+    if w is None:
+        w = 1.0 if ord(c) >= 0x2E80 else 0.64  # full width scripts, and anything else not measured
+    return w * 1.03
+
+
+@dataclass
+class Run:
+    text: str
+    bold: bool = False
+    color: str = "ink"
+    field: str = ""  # where the text lives in the slide ("heading", "points.2.text"), so the page can edit it; "" is ours
+
+
+def _lines(runs: list[Run], width: float, size: float, font: str, upper: bool, track: float) -> int:
+    """Lines a paragraph wraps to in `width` pixels."""
+    words: list[tuple[str, bool]] = []
+    for r in runs:
+        t = r.text.upper() if upper else r.text
+        words += [(w, r.bold) for w in t.split(" ") if w]
+    if not words:
+        return 0
+    space = (_char_w(" ", font, False) + track) * size
+    lines, x = 1, 0.0
+    for word, bold in words:
+        ww = sum((_char_w(c, font, bold) + track) * size for c in word)
+        if ww > width:  # a word longer than the line breaks anywhere
+            extra = x + (space if x else 0) + ww
+            lines += int(extra // width)
+            x = extra % width
+            continue
+        need = ww if x == 0 else x + space + ww
+        if need <= width:
+            x = need
+        else:
+            lines += 1
+            x = ww
+    return lines
+
+
+# --- placed elements ------------------------------------------------------------------------------------------------
+
+@dataclass
+class El:
+    kind: str  # text | rect | circle | line
+    role: str
+    x: float
+    y: float
+    w: float
+    h: float
+    paras: list[list[Run]] = field(default_factory=list)
+    size: float = 0
+    lh: float = 1.3
+    font: str = "body"  # display | body | mono
+    align: str = "left"
+    valign: str = "top"
+    upper: bool = False
+    track: float = 0.0  # letter spacing in em
+    gap: float = 0.0  # space between paragraphs, in px
+    fill: str | None = None  # palette key
+    stroke: str | None = None
+    stroke_w: float = 0
+    radius: float = 0
+    opacity: float = 1.0
+
+    def text_height(self) -> float:
+        return text_height(self.paras, self.w, self.size, self.lh, self.font, self.upper, self.track, self.gap)
+
+
+def text_height(paras: list[list[Run]], width: float, size: float, lh: float, font: str, upper: bool = False,
+                track: float = 0.0, gap: float = 0.0) -> float:
+    n = [_lines(p, width, size, font, upper, track) for p in paras]
+    used = [k for k in n if k]
+    return sum(k * size * lh for k in used) + max(len(used) - 1, 0) * gap
+
+
+SCALES = (1.0, 0.92, 0.85, 0.78, 0.72, 0.66, 0.6, 0.55)
+GROW = (1.4, 1.28, 1.18, 1.08)  # sparse content is drawn larger, so a slide with little on it is not half empty
+
+
+def _scales(start: int, grow: bool = False) -> tuple[float, ...]:
+    """Scales to try, largest first: from `start` down, with the growing ones first when allowed and not shrunk."""
+    return (GROW + SCALES) if grow and start == 0 else SCALES[start:]
+
+# Base font sizes in px, by format (both themes). Presenter slides carry fewer words, so they are drawn larger.
+TYPE = {
+    "detailed": {"kicker": 24, "heading": 66, "title": 110, "section": 88, "lead": 33, "title_lead": 37, "point": 31,
+                 "card_term": 33, "card_text": 28, "value": 242, "label": 37, "quote": 57, "by": 26, "take": 31,
+                 "closing": 51, "closing_big": 73, "agenda": 35, "col_label": 31, "col_item": 30, "num": 24,
+                 "footer": 20},
+    "presenter": {"kicker": 26, "heading": 79, "title": 123, "section": 101, "lead": 40, "title_lead": 42,
+                  "point": 44, "card_term": 37, "card_text": 37, "value": 286, "label": 44, "quote": 66, "by": 29,
+                  "take": 40, "closing": 62, "closing_big": 86, "agenda": 40, "col_label": 33, "col_item": 40,
+                  "num": 26, "footer": 20},
+}
+
+
+def _fit_size(paras: list[list[Run]], width: float, height: float, base: float, lh: float, font: str,
+              start: int, upper: bool = False, track: float = 0.0, gap_em: float = 0.0, grow: bool = False) -> float | None:
+    """The largest size (base times a scale, from `start` down) at which the paragraphs fit the box, or None."""
+    for scale in _scales(start, grow):
+        size = round(base * scale, 1)
+        if text_height(paras, width, size, lh, font, upper, track, size * gap_em) <= height:
+            return size
+    return None
+
+
+class NoFit(Exception):
+    """Text that does not fit even at the smallest size: the caller shortens it and tries again."""
+
+    def __init__(self, field_name: str, index: int | None = None):
+        super().__init__(field_name)
+        self.field_name = field_name
+        self.index = index
+
+
+@dataclass
+class Composed:
+    slide: dict  # the slide as drawn (text shortened when it had to be)
+    elements: list[El]
+    seed: int
+
+
+def _text(role: str, rect: tuple, paras: list[list[Run]], base: float, start: int, *, font: str = "body",
+          lh: float = 1.35, upper: bool = False, track: float = 0.0, gap_em: float = 0.0, field_name: str = "",
+          index: int | None = None, grow: bool = False) -> El:
+    x, y, w, h, align, valign = rect[:6]
+    size = _fit_size(paras, w, h, base, lh, font, start, upper, track, gap_em, grow)
+    if size is None:
+        raise NoFit(field_name or role, index)
+    return El("text", role, x, y, w, h, paras=paras, size=size, lh=lh, font=font, align=align, valign=valign,
+              upper=upper, track=track, gap=size * gap_em)
+
+
+def _point_runs(p: dict, i: int, fmt: str) -> list[Run]:
+    if p["term"] and fmt == "detailed":
+        return [Run(p["term"], True, "ink", f"points.{i}.term"), Run(". ", True, "ink"),
+                Run(p["text"], False, "mute", f"points.{i}.text")]
+    return [Run(p["text"], False, "ink", f"points.{i}.text")]
+
+
+def _body(els: list[El], s: dict, rect: tuple, kind: str, fmt: str, t: dict, start: int, dark: bool) -> None:
+    """The slide's main content: points, agenda items or takeaways, drawn as `kind`."""
+    x, y, w, h, _align, valign, _ = rect
+    pts = s["points"]
+
+    if kind in ("list", "list2", "agenda_list", "agenda_grid", "take_stack"):
+        if kind in ("agenda_list", "agenda_grid"):
+            items = [[Run(p["text"], False, "ink", f"points.{i}.text")] for i, p in enumerate(pts)]
+            base, numbered = t["agenda"], True
+        elif kind == "take_stack":
+            items = [[Run(tx, False, "ink", f"takeaways.{i}")] for i, tx in enumerate(s["takeaways"])]
+            base, numbered = t["take"], True
+        else:
+            items = [_point_runs(p, i, fmt) for i, p in enumerate(pts)]
+            base, numbered = t["point"], False
+        cols = 2 if kind in ("list2", "agenda_grid") and len(items) >= 3 else 1
+        per = math.ceil(len(items) / cols)
+        col_gap = 70
+        cw = (w - col_gap * (cols - 1)) / cols
+        indent = 78 if numbered else 44
+        tw = cw - indent
+        # One size for every item: the largest at which the tallest column fits with breathing room between items.
+        size = None
+        for scale in _scales(start, True):
+            sz = round(base * scale, 1)
+            gap = sz * 0.9
+            heights = [text_height([it], tw, sz, 1.38, "body") for it in items]
+            tallest = max(sum(heights[c * per:(c + 1) * per]) + gap * (len(heights[c * per:(c + 1) * per]) - 1)
+                          for c in range(cols))
+            if tallest <= h:
+                size = sz
+                break
+        if size is None:
+            raise NoFit("takeaways" if kind == "take_stack" else "points")
+        heights = [text_height([it], tw, size, 1.38, "body") for it in items]
+        for c in range(cols):
+            chunk = list(range(c * per, min((c + 1) * per, len(items))))
+            total = sum(heights[i] for i in chunk)
+            free = h - total
+            gap = min(free / max(len(chunk) - 1, 1), size * 2.2) if len(chunk) > 1 else 0
+            block_h = total + gap * max(len(chunk) - 1, 0)
+            cy = y + (h - block_h) / 2 if valign == "middle" else y
+            cx = x + c * (cw + col_gap)
+            for i in chunk:
+                ih = heights[i]
+                if numbered:
+                    els.append(El("text", "num", cx, cy + size * 0.12, 64, size * 1.3, paras=[[Run(f"{i + 1:02d}", True, "accent")]],
+                                  size=round(size * 0.82, 1), lh=1.2, font="mono"))
+                else:
+                    d = size * 0.34
+                    els.append(El("circle", "dot", cx + 4, cy + size * 0.69 - d / 2, d, d, fill="accent"))
+                els.append(El("text", "item", cx + indent, cy, tw, ih + 2, paras=[items[i]], size=size, lh=1.38))
+                if numbered and kind != "take_stack" and i != chunk[-1]:
+                    els.append(El("line", "rule", cx + indent, cy + ih + gap / 2, tw, 0, stroke="line", stroke_w=1.5))
+                cy += ih + gap
+        return
+
+    if kind in ("cards", "take_cols", "take_row", "take_arc"):
+        if kind == "cards":
+            cells = [(p["term"] if fmt == "detailed" else "", p["text"]) for p in pts]
+        else:
+            cells = [("", tx) for tx in s["takeaways"]]
+        n = max(len(cells), 1)
+        gap = 36 if kind != "take_row" else 60
+        cw = (w - gap * (n - 1)) / n
+        boxed = kind in ("cards", "take_cols")
+        pad = 40 if boxed else 0
+        top = 0.0
+        if kind == "take_arc":
+            top = 120  # the glowing marker above each takeaway
+        elif kind == "take_row":
+            top = 70
+        else:
+            top = 64  # number row inside the card
+        inner_w = cw - 2 * pad
+        inner_h = h - 2 * pad - top
+        term_base = t["card_term"]
+        text_base = t["card_text"] if kind == "cards" else t["take"]
+        size = None
+        for scale in _scales(start, True):
+            ts, xs = round(term_base * scale, 1), round(text_base * scale, 1)
+            ok = True
+            for term, text in cells:
+                hh = (text_height([[Run(term, True)]], inner_w, ts, 1.15, "display") + ts * 0.5 if term else 0)
+                hh += text_height([[Run(text)]], inner_w, xs, 1.4, "body")
+                if hh > inner_h:
+                    ok = False
+                    break
+            if ok:
+                size = (ts, xs)
+                break
+        if size is None:
+            raise NoFit("takeaways" if kind != "cards" else "points")
+        ts, xs = size
+        # Cards as tall as the tallest content (not the whole box), so short text does not float in a tall card.
+        tallest = max((text_height([[Run(term, True)]], inner_w, ts, 1.15, "display") + ts * 0.5 if term else 0)
+                      + text_height([[Run(text)]], inner_w, xs, 1.4, "body") for term, text in cells)
+        h = min(h, tallest + 2 * pad + top + 12)
+        for i, (term, text) in enumerate(cells):
+            cx = x + i * (cw + gap)
+            if boxed:
+                els.append(El("rect", "card", cx, y, cw, h, fill="card", stroke="cardline", stroke_w=2, radius=22))
+            if kind == "take_arc":
+                r = 46
+                els.append(El("circle", "halo", cx + cw / 2 - r * 1.5, y + 2 - r * 0.5, r * 3, r * 3, fill="accent2", opacity=0.18))
+                els.append(El("circle", "marker", cx + cw / 2 - r, y + 2, r * 2, r * 2, fill="accent2"))
+                els.append(El("text", "num", cx + cw / 2 - r, y + 2, r * 2, r * 2, paras=[[Run(f"{i + 1}", True, "white")]],
+                              size=34, lh=1.0, font="display", align="center", valign="middle"))
+            elif kind == "take_row":
+                els.append(El("rect", "bar", cx, y, cw, 5, fill="accent"))
+                els.append(El("text", "num", cx, y + 20, cw, 34, paras=[[Run(f"{i + 1:02d}", True, "accent")]],
+                              size=24, lh=1.2, font="mono"))
+            else:
+                els.append(El("text", "num", cx + pad, y + pad, inner_w, 34, paras=[[Run(f"{i + 1:02d}", True, "accent")]],
+                              size=t["num"], lh=1.2, font="mono"))
+            cy = y + pad + top
+            align = "center" if kind == "take_arc" else "left"
+            if term:
+                th = text_height([[Run(term, True)]], inner_w, ts, 1.15, "display")
+                els.append(El("text", "term", cx + pad, cy, inner_w, th + 2, paras=[[Run(term, True, "ink", f"points.{i}.term")]], size=ts,
+                              lh=1.15, font="display", align=align))
+                cy += th + ts * 0.5
+            where = f"points.{i}.text" if kind == "cards" else f"takeaways.{i}"
+            els.append(El("text", "item", cx + pad, cy, inner_w, y + h - pad - cy,
+                          paras=[[Run(text, False, "mute" if term else "ink", where)]], size=xs, lh=1.4, align=align))
+        return
+
+    if kind in ("timeline_v", "timeline_h"):
+        items = [_point_runs(p, i, fmt) for i, p in enumerate(pts)]
+        n = len(items)
+        r = 28
+        if kind == "timeline_v":
+            tw = w - 96
+            size = None
+            for scale in _scales(start, True):
+                sz = round(t["point"] * scale, 1)
+                heights = [max(text_height([it], tw, sz, 1.38, "body"), r * 2) for it in items]
+                if sum(heights) + sz * 1.2 * (n - 1) <= h:
+                    size = sz
+                    break
+            if size is None:
+                raise NoFit("points")
+            heights = [max(text_height([it], tw, size, 1.38, "body"), r * 2) for it in items]
+            gap = min((h - sum(heights)) / max(n - 1, 1), size * 2.4)
+            total = sum(heights) + gap * (n - 1)
+            cy = y + (h - total) / 2 if valign == "middle" else y
+            els.append(El("line", "spine", x + r, cy + r, 0, total - 2 * r if total > 2 * r else 0, stroke="line", stroke_w=3))
+            for i, it in enumerate(items):
+                els.append(El("circle", "marker", x, cy, r * 2, r * 2, fill="card", stroke="accent", stroke_w=3))
+                els.append(El("text", "num", x, cy, r * 2, r * 2, paras=[[Run(str(i + 1), True, "accent")]], size=24, lh=1.0,
+                              font="display", align="center", valign="middle"))
+                els.append(El("text", "item", x + 96, cy + max((r * 2 - size * 1.38) / 2, 0) if heights[i] <= r * 2 else cy,
+                              tw, heights[i] + 2, paras=[it], size=size, lh=1.38))
+                cy += heights[i] + gap
+        else:
+            gap = 40
+            cw = (w - gap * (n - 1)) / n
+            th = h - r * 2 - 40
+            size = _fit_all([[it] for it in items], cw, th, t["point"] * 0.9, 1.38, start)
+            if size is None:
+                raise NoFit("points")
+            els.append(El("line", "spine", x + r, y + r, w - 2 * r, 0, stroke="line", stroke_w=3))
+            for i, it in enumerate(items):
+                cx = x + i * (cw + gap)
+                els.append(El("circle", "marker", cx, y, r * 2, r * 2, fill="card", stroke="accent", stroke_w=3))
+                els.append(El("text", "num", cx, y, r * 2, r * 2, paras=[[Run(str(i + 1), True, "accent")]], size=24, lh=1.0,
+                              font="display", align="center", valign="middle"))
+                els.append(El("text", "item", cx, y + r * 2 + 40, cw, th, paras=[it], size=size, lh=1.38))
+        return
+    raise ValueError(f"unknown body kind {kind}")
+
+
+def _fit_all(blocks: list[list[list[Run]]], width: float, height: float, base: float, lh: float, start: int) -> float | None:
+    for scale in _scales(start, True):
+        size = round(base * scale, 1)
+        if all(text_height(b, width, size, lh, "body") <= height for b in blocks):
+            return size
+    return None
+
+
+def _columns(els: list[El], s: dict, rects: tuple[tuple, tuple], t: dict, start: int) -> None:
+    """The two sides of a comparison, at one font size, each panel as tall as the taller side's content."""
+    kind = rects[0][6]
+    pad = 44 if kind == "panel" else 0
+    top = 0 if kind == "panel" else 28
+    sides = [s["left"], s["right"]]
+
+    def measure(col: dict, iw: float, ls: float, xs: float) -> tuple[float, list[float]]:
+        label = [[Run(col["label"], True, "accent")]] if col["label"] else []
+        lab = text_height(label, iw, ls, 1.2, "display") + (xs * 0.9 if label else 0)
+        heights = [text_height([[Run(i)]], iw - 40, xs, 1.38, "body") for i in col["items"]]
+        return lab + sum(heights) + xs * 0.75 * (len(heights) - 1), heights
+
+    for scale in _scales(start, True):
+        ls, xs = round(t["col_label"] * scale, 1), round(t["col_item"] * scale, 1)
+        need = [measure(col, r[2] - 2 * pad, ls, xs)[0] for col, r in zip(sides, rects, strict=True)]
+        bad = [i for i, (n, r) in enumerate(zip(need, rects, strict=True)) if n > r[3] - 2 * pad - top]
+        if not bad:
+            break
+    else:
+        raise NoFit(("left", "right")[bad[0]] + "_items")
+    panel_h = max(need) + 2 * pad + top + 8
+    for side, col, (x, y, w, h, *_) in zip(("left", "right"), sides, rects, strict=True):
+        if kind == "panel":
+            els.append(El("rect", "panel", x, y, w, min(h, panel_h), fill="card", stroke="cardline", stroke_w=2, radius=22))
+        else:
+            els.append(El("rect", "bar", x, y, 72, 5, fill="accent"))
+        ix, iw = x + pad, w - 2 * pad
+        cy = y + pad + top
+        _, heights = measure(col, iw, ls, xs)
+        if col["label"]:
+            lab_h = text_height([[Run(col["label"], True)]], iw, ls, 1.2, "display")
+            els.append(El("text", "col_label", ix, cy, iw, lab_h + 2, paras=[[Run(col["label"], True, "accent", f"{side}.label")]],
+                          size=ls, lh=1.2, font="display"))
+            cy += lab_h + xs * 0.9
+        for n, (item, hh) in enumerate(zip(col["items"], heights, strict=True)):
+            d = xs * 0.32
+            els.append(El("circle", "dot", ix + 2, cy + xs * 0.69 - d / 2, d, d, fill="accent"))
+            els.append(El("text", "item", ix + 40, cy, iw - 40, hh + 2, paras=[[Run(item, False, "ink", f"{side}.items.{n}")]],
+                          size=xs, lh=1.38))
+            cy += hh + xs * 0.75
+
+
+def _compose_once(s: dict, deck: dict, index: int, theme: str, fmt: str, start: int) -> list[El]:
+    from app.slides.themes import THEMES
+
+    t = TYPE[fmt]
+    dark = THEMES[theme].dark
+    layout, v = s["layout"], s["variant"]
+    els: list[El] = []
+
+    lead_slot = block(theme, layout, v, "lead")
+
+    def rect(name: str) -> tuple | None:
+        r = block(theme, layout, v, name)
+        # No lead: what sits right under the lead's slot (in the same column) moves up into it.
+        if r and name in ("body", "left", "right") and lead_slot and not s["lead"]:
+            lx, ly, lw, lh_ = lead_slot[:4]
+            if r[1] >= ly + lh_ - 2 and r[1] - (ly + lh_) < 80 and r[0] < lx + lw and lx < r[0] + r[2]:
+                return (r[0], ly, r[2], r[3] + r[1] - ly, *r[4:])
+        return r
+
+    k = rect("kicker")
+    if k and s["kicker"]:
+        x, y, w, h, align, *_ = k
+        bar_x = x + (w - 64) / 2 if align == "center" else (x + w - 64 if align == "right" else x)
+        els.append(El("rect", "bar", bar_x, y - 18, 64, 5, fill="accent"))
+        els.append(_text("kicker", k, [[Run(s["kicker"], True, "accent", "kicker")]], t["kicker"], 0, font="mono", lh=1.2,
+                         upper=True, track=0.16, field_name="kicker"))
+
+    heading_base = {"title": t["title"], "section": t["section"]}.get(layout, t["heading"])
+    hr = rect("heading")
+    if hr and s["heading"]:
+        els.append(_text("heading", hr, [[Run(s["heading"], True, "ink", "heading")]], heading_base, start, font="display",
+                         lh=1.08, field_name="heading"))
+
+    lr = rect("lead")
+    if lr and s["lead"]:
+        base = t["title_lead"] if layout == "title" else t["lead"]
+        head = next((e for e in els if e.role == "heading"), None)
+        if head and head.valign == "top" and abs(head.x - lr[0]) < 1 and head.y < lr[1]:
+            # Under a top aligned heading in the same column: follow the heading instead of waiting at the box's top.
+            top = head.y + head.text_height() + head.size * 0.55
+            lr = (lr[0], top, lr[2], lr[1] + lr[3] - top, *lr[4:])
+        els.append(_text("lead", lr, [[Run(s["lead"], False, "mute", "lead")]], base, start, lh=1.4, field_name="lead"))
+
+    if layout == "stat":
+        els.append(_text("value", rect("value"), [[Run(s["stat"]["value"], True, "accent", "stat.value")]], t["value"], start,
+                         font="display", lh=1.0, field_name="stat_value"))
+        els.append(_text("label", rect("label"), [[Run(s["stat"]["label"], False, "ink", "stat.label")]], t["label"], start, lh=1.35,
+                         field_name="stat_label", grow=True))
+    if layout == "quote":
+        q = rect("quote")
+        els.append(_text("quote", q, [[Run("“", True, "accent"), Run(s["quote"]["text"], False, "ink", "quote.text"),
+                                       Run("”", True, "accent")]], t["quote"], start, font="display", lh=1.22,
+                         field_name="quote", grow=True))
+        if s["quote"]["by"] and (b := rect("by")):
+            els.append(_text("by", b, [[Run(s["quote"]["by"], False, "mute", "quote.by")]], t["by"], 0, font="mono", lh=1.3,
+                             upper=True, track=0.08, field_name="by"))
+    if layout == "two_column":
+        _columns(els, s, (rect("left"), rect("right")), t, start)
+    br = rect("body")
+    if br:
+        _body(els, s, br, br[6], fmt, t, start, dark)
+    cr = rect("closing")
+    if cr and s["closing"]:
+        kind = cr[6]
+        if kind == "band":
+            x, y, w, h, *_ = cr
+            els.append(El("rect", "band", x, y, w, h, fill="band", radius=24))
+            inner = (x + 60, y, w - 120, h, "left", "middle")
+            els.append(_text("closing", inner, [[Run(s["closing"], True, "bandink", "closing")]], t["closing"], start,
+                             font="display", lh=1.15, field_name="closing"))
+        else:
+            base = t["closing_big"] if kind == "big" else t["closing"]
+            els.append(_text("closing", cr, [[Run(s["closing"], True, "ink", "closing")]], base, start, font="display", lh=1.12,
+                             field_name="closing", grow=kind == "big"))
+
+    if layout != "title":
+        total = len(deck["slides"])
+        foot = [[Run(clip(deck.get("title"), 70), False, "mute")]]
+        els.append(El("text", "footer", 140, 1018, 1200, 30, paras=foot, size=t["footer"], lh=1.2, font="mono"))
+        els.append(El("text", "footer", 1480, 1018, 300, 30, paras=[[Run(f"{index + 1:02d} / {total:02d}", False, "mute")]],
+                      size=t["footer"], lh=1.2, font="mono", align="right"))
+    return els
+
+
+def _shorten(s: dict, err: NoFit, fmt: str) -> bool:
+    """Make the text that did not fit shorter (or drop a point). False when there is nothing left to shorten."""
+    lo = LIMITS[fmt]["points"][0]
+    name = err.field_name
+
+    def cut(text: str) -> str:
+        return clip(text, max(int(len(text) * 0.82), 12)) if len(text) > 14 else text
+
+    if name == "points":
+        pts = s["points"]
+        if s["layout"] == "agenda" or len(pts) > max(lo, 3):
+            if len(pts) > 2:
+                pts.pop()
+                return True
+        longest = max(range(len(pts)), key=lambda i: len(pts[i]["text"]) + len(pts[i]["term"]), default=None)
+        if longest is None or len(pts[longest]["text"]) <= 14:
+            return False
+        pts[longest]["text"] = cut(pts[longest]["text"])
+        return True
+    if name == "takeaways":
+        tk = s["takeaways"]
+        i = max(range(len(tk)), key=lambda j: len(tk[j]), default=None)
+        if i is None or len(tk[i]) <= 14:
+            return False
+        tk[i] = cut(tk[i])
+        return True
+    if name in ("left_items", "right_items"):
+        col = s[name.split("_")[0]]
+        if len(col["items"]) > 2:
+            col["items"].pop()
+            return True
+        i = max(range(len(col["items"])), key=lambda j: len(col["items"][j]), default=None)
+        if i is None or len(col["items"][i]) <= 14:
+            return False
+        col["items"][i] = cut(col["items"][i])
+        return True
+    path = {"stat_value": ("stat", "value"), "stat_label": ("stat", "label"), "quote": ("quote", "text"),
+            "by": ("quote", "by")}.get(name)
+    if path:
+        holder, key = s[path[0]], path[1]
+    elif name in s and isinstance(s[name], str):
+        holder, key = s, name
+    else:
+        return False
+    if len(holder[key]) <= 14:
+        if name in ("lead", "by", "kicker"):
+            holder[key] = ""
+            return True
+        return False
+    holder[key] = cut(holder[key])
+    return True
+
+
+def compose(deck: dict, index: int, theme: str, fmt: str, seed: int = 0) -> Composed:
+    """Slide `index` of a clamped deck, placed. Text that does not fit is shortened until it does; a slide that
+    still cannot be drawn becomes a plain section slide with its heading."""
+    theme, fmt = theme_id(theme), fmt if fmt in TYPE else "detailed"
+    s = copy.deepcopy(deck["slides"][index])
+    if s["variant"] not in VARIANTS[s["layout"]]:
+        s["variant"] = VARIANTS[s["layout"]][0]
+    start = min(int(s.get("shrink") or 0), len(SCALES) - 1)
+    for _ in range(60):
+        try:
+            return Composed(s, _compose_once(s, deck, index, theme, fmt, start), seed)
+        except NoFit as err:
+            if not _shorten(s, err, fmt):
+                break
+    plain = {**copy.deepcopy(s), "layout": "section", "variant": VARIANTS["section"][0], "lead": "", "points": [],
+             "heading": clip(s["heading"] or deck.get("title"), 60)}
+    return Composed(plain, _compose_once(plain, deck, index, theme, fmt, 0), seed)
+
+
+def seed_of(value: object) -> int:
+    """A stable integer seed from a deck id."""
+    digits = re.sub(r"[^0-9a-f]", "", str(value or "").lower())
+    return int(digits[:12] or "0", 16)

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,184 @@
+"""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."""
+
+import math
+
+from markupsafe import escape
+
+from app.slides.content import field_limit
+from app.slides.decor import Decor, Shape, build, ring_path
+from app.slides.layout import Composed, El, Run, 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,.14)}}
+.light .r-band{{box-shadow:0 18px 44px rgba(11,26,58,.26)}}
+"""
+
+
+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, fmt: 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{_editable(r, layout, fmt)} style="color:{color(pal, r.color)}{";font-weight:700" if r.bold else ""}">'
+                f'{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 _editable(r: Run, layout: str, fmt: str) -> str:
+    """Where a run's text lives and how long it may be, for the page's editor (none on our own text: numbers, footers)."""
+    return f' data-f="{r.field}" data-max="{field_limit(layout, r.field, fmt)}"' if r.field else ""
+
+
+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 == "band":
+        lo, hi = ring_shade(s)
+        defs.append(f'<linearGradient id="{gid}" gradientUnits="userSpaceOnUse" x1="{lo:.0f}" y1="0" x2="{hi:.0f}" y2="0">'
+                    + "".join(f'<stop offset="{o}" stop-color="{c}" stop-opacity="{a * s.opacity:.3f}"/>' for o, a in SHADE)
+                    + "</linearGradient>")
+        pts = ring_path(s) + ring_path(s, s.inner)[::-1]
+        return f'<path d="M{_pts(pts)}Z" fill="url(#{gid})"/>'
+    if s.kind == "ring" and s.arc:
+        return (f'<path d="M{_pts(ring_path(s))}" fill="none" stroke="{c}" stroke-width="{s.width}" '
+                f'stroke-linecap="round" opacity="{s.opacity}"/>')
+    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 ""
+
+
+# How brightly a ringed planet's band shows across its width, left to right: lit from the upper left, as the planet is.
+SHADE = ((0, 1.0), (0.45, 0.8), (1, 0.3))
+
+
+def ring_shade(s: Shape) -> tuple[float, float]:
+    """The band's left and right extent on the slide, which SHADE runs across."""
+    half = math.hypot(s.rx * math.cos(math.radians(s.rot)), s.ry * math.sin(math.radians(s.rot)))
+    return s.cx - half, s.cx + half
+
+
+def _pts(pts: list[tuple[float, float]]) -> str:
+    return "L".join(f"{x:.1f} {y:.1f}" for x, y in pts)
+
+
+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, fmt: 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"], fmt) 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, fmt),
+                 f"body{{background:{THEMES[theme].pal.bg1}}}")
+
+
+def slides_html(deck: dict, theme: str, fmt: str, seed: int, start: int, end: int) -> str:
+    """Slides start..end-1 of the deck stacked on one page, each as it is in the deck (its number, its sky)."""
+    theme = theme_id(theme)
+    body = "".join(slide_body(compose(deck, i, theme, fmt, seed), deck, i, theme, fmt) for i in range(start, end))
+    return _page(body, 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, fmt) 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", "Night stellar", 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", "Moon light", False, Palette(
+        bg1="#c3cddf", bg2="#dfe5ef", ink="#0b1a3a", mute="#36435f", accent="#1858c4", accent2="#0b3d91",
+        card="#e9eef6", cardline="#b3bfd5", line="#a7b4cc", 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}]},
@@ -754,13 +754,14 @@ def _schedule(client, auth, artifact, platform, account=None):
 def test_postable_lists_what_can_be_posted(client, auth, db_session):
     ws = db_session.query(Workspace).first()
     quote = _made(db_session, ws, "quote_card", key="ws/q/quotecard.png", quote="Ship it", source="Ada")
-    _made(db_session, ws, "audio_overview", key="ws/a/audio.mp3")
+    audio = _made(db_session, ws, "audio_overview", key="ws/a/audio.mp3")
     _made(db_session, ws, "video", status="processing", provider="blog2video")  # not rendered yet
     done = _made(db_session, ws, "video", status="processing", provider="blog2video", video_url="https://v/x.mp4")
     unrendered = _made(db_session, ws, "video", status="ready", provider="blog2video", b2v_status="generated")
     _made(db_session, ws, "summary", summary="Raise prices once a year [1].")
     got = {a["id"]: a for a in client.get("/api/launchpad/postable", headers=auth).json()}
-    assert {a["type"] for a in got.values()} == {"quote_card", "video", "summary"}  # no audio, no unfinished video
+    assert {a["type"] for a in got.values()} == {"quote_card", "video", "summary", "audio_overview"}  # no unfinished video
+    assert got[str(audio.id)]["media"] == "audio" and got[str(audio.id)]["download_url"]  # audio: to download, not post
     assert str(done.id) in got and got[str(quote.id)]["thumb_url"] and got[str(quote.id)]["media"] == "image"
     # Made but not rendered: listed, flagged; the rendered one is not.
     assert got[str(unrendered.id)]["needs_render"] is True and got[str(done.id)]["needs_render"] is False
@@ -1094,8 +1095,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 +1117,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,590 @@
+"""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
+
+
+@pytest.mark.parametrize("key", [("title", "a"), ("title", "c"), ("section", "a"), ("section", "b")])
+def test_light_planets_sit_on_their_ring(key):
+    """A planet beside rings is drawn on one of them, tilt included, whatever the seed."""
+    import math
+
+    from app.slides.decor import build
+
+    for seed in range(40):
+        shapes = build("light-space", *key, seed, 0).shapes
+        rings = [s for s in shapes if s.kind == "ring"]
+        for p in (s for s in shapes if s.kind == "planet"):
+            def off(r, p=p):  # how far the planet's centre is from the ring's line, in units of the ring
+                rot = math.radians(-r.rot)
+                dx, dy = p.cx - r.cx, p.cy - r.cy
+                x, y = dx * math.cos(rot) - dy * math.sin(rot), dx * math.sin(rot) + dy * math.cos(rot)
+                return abs(math.hypot(x / r.rx, y / r.ry) - 1)
+            assert min(off(r) for r in rings) < 1e-6, (key, seed)
+
+
+@pytest.mark.parametrize("key", [("title", "b"), ("points", "a")])
+def test_dark_rings_wrap_round_their_planet(key):
+    """A ringed planet's far half is drawn before the planet (hidden behind it) and the near half after (in front)."""
+    from app.slides.decor import FAR, NEAR, build
+
+    for seed in range(10):
+        shapes = build("dark-space", *key, seed, 0).shapes
+        at = next(i for i, s in enumerate(shapes) if s.kind == "planet")
+        rings = [(i, s) for i, s in enumerate(shapes) if s.kind in ("ring", "band")]
+        assert rings and all(s.arc for _, s in rings)
+        assert all(i < at for i, s in rings if s.arc == FAR) and all(i > at for i, s in rings if s.arc == NEAR)
+        assert all(s.rx * s.inner > shapes[at].r for _, s in rings if s.kind == "band")  # the band clears the planet
+
+
+@pytest.mark.parametrize("theme", ["dark-space", "light-space"])
+def test_every_variant_marks_its_editable_text(theme):
+    """Every piece of a slide's own text is drawn in a span the editor can find, with the field's real limit; numbers
+    and footers are not editable."""
+    from app.slides.content import field_limit
+
+    for fmt in ("detailed", "presenter"):
+        for layout, variants in GEOMETRY[theme].items():
+            for v in variants:
+                deck = clamp_deck({"title": "T", "slides": [{"layout": layout, **FULL[layout]}]}, fmt)
+                deck["slides"][0]["variant"] = v
+                html = slide_html(deck, 0, theme, fmt, 3)
+                found = dict(re.findall(r'data-f="([^"]+)" data-max="(\d+)"', html))
+                assert "heading" in found or layout in ("quote", "closing"), (layout, v)
+                assert all(int(n) == field_limit(layout, f, fmt) for f, n in found.items())
+                s = deck["slides"][0]
+                want = {"points": [f"points.{i}.text" for i in range(len(s["points"]))], "stat": ["stat.value", "stat.label"],
+                        "quote": ["quote.text", "quote.by"], "two_column": ["left.label", "right.items.1"],
+                        "closing": [f"takeaways.{i}" for i in range(len(s["takeaways"]))] + ["closing"]}.get(layout, [])
+                assert set(want) <= set(found), (fmt, layout, v, found)
+                assert not any(f.startswith("footer") for f in found)
+
+
+def _ready_deck(client, auth, run_jobs, monkeypatch, llm):  # noqa: F811
+    pricing, nb = _notebook_with_pricing(client, auth, run_jobs)
+    _fake_many(monkeypatch, pricing["path"], {})
+    llm["OutlineDeck"] = _outline(5)
+    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()
+    return client.get(f"/api/artifacts/{art['id']}", headers=auth).json()
+
+
+def test_edited_deck_is_saved_fitted_and_downloaded(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    done = _ready_deck(client, auth, run_jobs, monkeypatch, llm)
+    slides = copy.deepcopy(done["content"]["deck"]["slides"])
+    assert len(done["content"]["slide_slots"]) == len(slides) and "heading" in done["content"]["slide_slots"][0]
+    pi = next(i for i, s in enumerate(slides) if s["points"] and s["layout"] == "points")
+    slides[0]["heading"] = "A brand new title"
+    slides[0]["notes"] = "Say hello first."
+    slides[pi]["points"][0]["text"] = "Edited point " + "very long " * 60
+    slides[-1]["takeaways"][1] = "  An <b>edited</b> takeaway  "
+    url = f"/api/artifacts/{done['id']}/deck"
+    saved = client.put(url, json={"slides": slides}, headers=auth)
+    assert saved.status_code == 200, saved.text
+    after = saved.json()["content"]
+    s = after["deck"]["slides"]
+    assert s[0]["heading"] == "A brand new title" and s[0]["notes"] == "Say hello first."
+    assert s[pi]["points"][0]["text"].startswith("Edited point") and len(s[pi]["points"][0]["text"]) <= LIMITS["detailed"]["text"]
+    assert s[-1]["takeaways"][1] == "An edited takeaway"  # plain text only
+    before = done["content"]["deck"]["slides"]
+    assert [(x["layout"], x["variant"]) for x in s] == [(x["layout"], x["variant"]) for x in before]  # designs kept
+    assert "A brand new title" in after["slides_html"][0]
+    pptx = client.get(f"/api/artifacts/{done['id']}/slides.pptx", headers=auth)
+    texts = [sh.text_frame.text for sh in Presentation(io.BytesIO(pptx.content)).slides[0].shapes if sh.has_text_frame]
+    assert any("A brand new title" in t for t in texts)
+
+    assert client.put(url, json={"slides": []}, headers=auth).status_code == 422
+    assert client.put(url, json={"slides": [{"layout": "points", "heading": ""}]}, headers=auth).status_code == 400
+    assert client.put(url, json={"slides": [slides[0]] * 31}, headers=auth).status_code == 400
+    kept = client.get(f"/api/artifacts/{done['id']}", headers=auth).json()["content"]["deck"]["slides"]
+    assert kept[0]["heading"] == "A brand new title" and len(kept) == len(slides)  # a refused save changes nothing
+
+
+def test_slides_can_be_added_removed_moved_and_change_layout(client, auth, run_jobs, feed, llm, monkeypatch, no_chrome):  # noqa: F811
+    done = _ready_deck(client, auth, run_jobs, monkeypatch, llm)
+    slides = copy.deepcopy(done["content"]["deck"]["slides"])
+    n = len(slides)
+    pi = next(i for i, s in enumerate(slides) if s["layout"] == "points")
+    edited = copy.deepcopy(slides)
+    edited[pi]["points"].append({"term": "", "text": "A point added by hand"})  # a text box added
+    edited[pi]["lead"] = ""  # and one removed
+    stat = {"layout": "stat", "variant": "", "heading": "A new stat slide", "stat": {"value": "42%", "label": "Readers who stayed"}}
+    edited.insert(1, stat)  # a slide added
+    edited.insert(2, copy.deepcopy(edited[0]) | {"variant": ""})  # a slide duplicated
+    del edited[-2]  # a slide removed
+    edited[-1], edited[-2] = edited[-2], edited[-1]  # two moved
+    url = f"/api/artifacts/{done['id']}"
+    prev = client.post(f"{url}/deck-preview", json={"slides": edited}, headers=auth)
+    assert prev.status_code == 200, prev.text
+    got = prev.json()
+    out = got["slides"]
+    assert len(out) == n + 1 and len(got["slides_html"]) == n + 1 and len(got["slide_slots"]) == n + 1
+    assert out[1]["layout"] == "stat" and out[1]["variant"] and "42%" in got["slides_html"][1]
+    assert "value" in got["slide_slots"][1] and "label" in got["slide_slots"][1]
+    moved = next(s for s in out if s["heading"] == slides[pi]["heading"])
+    assert moved["points"][-1]["text"] == "A point added by hand" and moved["lead"] == ""
+    pairs = [(x["layout"], x["variant"]) for x in out]
+    assert all(a != b for a, b in zip(pairs, pairs[1:], strict=False))  # no two alike in a row
+    assert client.get(url, headers=auth).json()["content"]["deck"]["slides"] == done["content"]["deck"]["slides"]  # preview saves nothing
+
+    # a layout change: the points slide becomes a quote slide
+    q = next(i for i, s in enumerate(edited) if s["layout"] == "points")
+    edited[q] = {**edited[q], "layout": "quote", "variant": "", "quote": {"text": "Price the work like it matters.", "by": "A writer"}}
+    saved = client.put(f"{url}/deck", json={"slides": edited}, headers=auth).json()["content"]
+    assert saved["deck"]["slides"][q]["layout"] == "quote" and saved["deck"]["slides"][q]["variant"]
+    assert len(saved["deck"]["slides"]) == n + 1
+    pptx = client.get(f"{url}/slides.pptx", headers=auth)
+    assert len(Presentation(io.BytesIO(pptx.content)).slides) == n + 1
+
+
+def test_fill_variants_keeps_good_variants_and_fixes_the_rest():
+    from app.slides.build import fill_variants
+
+    deck = clamp_deck({"title": "T", "slides": [{"layout": lay, **FULL[lay]} for lay in ("title", "points", "points", "stat", "closing")]},
+                      "detailed")
+    assign_variants(deck["slides"], "dark-space", seed=3)
+    before = [s["variant"] for s in deck["slides"]]
+    fill_variants(deck["slides"], "dark-space", 3)
+    assert [s["variant"] for s in deck["slides"]] == before  # nothing to fix: nothing changes
+    deck["slides"][3]["variant"] = ""  # new
+    deck["slides"][2]["variant"] = deck["slides"][1]["variant"]  # the same as the slide before it
+    fill_variants(deck["slides"], "dark-space", 3)
+    assert deck["slides"][3]["variant"] in VARIANTS["stat"]
+    assert deck["slides"][2]["variant"] != deck["slides"][1]["variant"]
+    assert [s["variant"] for s in deck["slides"]][:2] == before[:2] and deck["slides"][4]["variant"] == before[4]

backend/tests/test_social_posting.py

@@ -47,8 +47,8 @@ def account(db, ws, platform="x", scopes=None, expires_in=None, refresh=None, ex
     return acct
 
 
-def item(db, ws, acct, minutes=60, status="scheduled", **kw):
-    it = CalendarItem(workspace_id=ws.id, platform=acct.platform, content="Hello", social_account_id=acct.id,
+def item(db, ws, acct, minutes=60, status="scheduled", content="Hello", **kw):
+    it = CalendarItem(workspace_id=ws.id, platform=acct.platform, content=content, social_account_id=acct.id,
                       scheduled_at=datetime.now(UTC) + timedelta(minutes=minutes), status=status, **kw)
     db.add(it)
     db.commit()
@@ -552,3 +552,171 @@ def test_uploaded_files_carry_a_preview_link(client, auth, ws, db_session):
     kit = made(db_session, ws, "launch_kit", post_title="Kit", posts={"linkedin": ["Hi"]})
     listed = {a["id"]: a for a in client.get("/api/launchpad/postable", headers=auth).json()}
     assert listed[str(kit.id)]["view_url"] is None
+
+
+def test_a_slide_deck_is_listed_and_posts_its_slides_as_images(client, auth, ws, db_session, monkeypatch):
+    from app.services.social import media
+    from app.slides import export
+    from app.slides.build import fit
+    from app.slides.content import clamp_deck
+
+    raw = {"title": "Pricing for writers", "subtitle": "What two years taught us.", "slides": [
+        {"layout": "title", "heading": "Pricing for writers", "lead": "What two years taught us."},
+        *[{"layout": "section", "heading": f"Part {i}"} for i in range(5)],
+        {"layout": "closing", "heading": "Key takeaways", "takeaways": ["Charge more.", "Readers take it seriously."]}]}
+    deck = fit(clamp_deck(raw, "detailed"), "dark-space", "detailed", 3)
+    art = Artifact(workspace_id=ws.id, type="slide_deck", status="ready",
+                   content_json={"title": "Slide deck: Pricing for writers", "theme": "dark-space", "format": "detailed",
+                                 "seed": "abc", "deck": deck})
+    db_session.add(art)
+    db_session.commit()
+    listed = {a["id"]: a for a in client.get("/api/launchpad/postable", headers=auth).json()}[str(art.id)]
+    assert listed["type"] == "slide_deck" and listed["media"] == "image" and listed["media_count"] == 7
+    assert listed["title"] == "Pricing for writers"
+    assert listed["prefill"]["linkedin"].startswith("Pricing for writers\n\nWhat two years taught us.")
+    assert "- Charge more." in listed["prefill"]["linkedin"]
+
+    drawn: list[int] = []
+
+    def chrome(html, args, out):  # a screenshot of the size asked for: a batch of slides stacked
+        import io
+
+        from PIL import Image
+
+        w, h = (int(v) for v in next(a for a in args if a.startswith("--window-size=")).split("=")[1].split(","))
+        drawn.append(h // 1080)
+        buf = io.BytesIO()
+        Image.new("RGB", (w, h), "navy").save(buf, "PNG")
+        return buf.getvalue(), ""
+
+    monkeypatch.setattr(export, "_run_chrome", chrome)
+    with media.media_for(art, "x") as files:  # X takes 4 images: one Chrome run draws them
+        assert [f.filename for f in files] == [f"slide-{i}.png" for i in range(1, 5)] and drawn == [4]
+        assert all(f.data.startswith(b"\x89PNG") for f in files)
+    with media.media_for(art, "linkedin") as files:
+        assert len(files) == 7 and all(f.content_type == "image/png" for f in files)
+    acct = account(db_session, ws, "linkedin", scopes=LI_SCOPES)
+    assert schedule(client, auth, "linkedin", acct, artifact_id=str(art.id)).status_code == 200
+    r = schedule(client, auth, "bluesky", artifact_id=str(art.id))
+    assert r.status_code == 400 and "X and LinkedIn" in r.json()["detail"]  # images go to X and LinkedIn only
+
+
+def test_a_slide_deck_that_cannot_be_drawn_is_retried(ws, db_session, monkeypatch):
+    from app.infographics.image import ImageUnavailable
+    from app.services.social import SocialError, media
+    from app.slides import export
+
+    art = Artifact(workspace_id=ws.id, type="slide_deck", status="ready", content_json={
+        "format": "detailed", "deck": {"title": "T", "slides": [{"layout": "section", "heading": "Hello"}]}})
+    db_session.add(art)
+    db_session.commit()
+
+    def no_chrome(*a, **k):
+        raise ImageUnavailable("No Chrome")
+
+    monkeypatch.setattr(export, "_run_chrome", no_chrome)
+    with pytest.raises(SocialError, match="could not be drawn") as err, media.media_for(art, "x"):
+        pass
+    assert not err.value.permanent
+
+
+def test_an_audio_overview_is_listed_to_download_but_never_posted(client, auth, ws, db_session):
+    audio = made(db_session, ws, "audio_overview", key="ws/a/overview.mp3", title="Audio overview: Pricing", duration_s=225)
+    listed = {a["id"]: a for a in client.get("/api/launchpad/postable", headers=auth).json()}[str(audio.id)]
+    assert listed["media"] == "audio" and listed["media_count"] == 0 and listed["duration_s"] == 225
+    assert listed["download_url"]
+    acct = account(db_session, ws, "linkedin", scopes=LI_SCOPES)
+    r = schedule(client, auth, "linkedin", acct, artifact_id=str(audio.id))
+    assert r.status_code == 400 and "Audio can't be posted" in r.json()["detail"]
+
+
+def test_a_video_or_image_can_go_out_without_a_caption(client, auth, ws, db_session, monkeypatch):
+    """An upload starts with no words (they are the writer's to add): a post that carries media may stay that way.
+    Without media, a post still needs words."""
+    from app.services import launchpad
+    from app.services.social import linkedin, x
+
+    li = account(db_session, ws, "linkedin", scopes=LI_SCOPES)
+    upload = made(db_session, ws, "upload", key="ws/u/clip.mp4", data=os.urandom(100_000), media="video",
+                  content_type="video/mp4", filename="clip.mp4")
+    r = schedule(client, auth, "linkedin", li, content="", artifact_id=str(upload.id))
+    assert r.status_code == 200, r.text
+    r = schedule(client, auth, "linkedin", li, content="  ")
+    assert r.status_code == 422 and r.json()["detail"]["message"] == "Write something to post, or attach an image or video."
+    created = schedule(client, auth, "linkedin", li, content="Words", artifact_id=str(upload.id)).json()
+    r = client.patch(f"/api/calendar/{created['id']}", json={"content": "", "artifact_id": None}, headers=auth)
+    assert r.status_code == 422 and r.json()["detail"]["code"] == "no_text"  # emptied and no media left
+
+    # Publishing: LinkedIn gets an empty caption, X a post with the media and no "text" at all.
+    sent: dict = {}
+    monkeypatch.setattr(linkedin, "_upload_video", lambda acct, m: "urn:li:video:1")
+    monkeypatch.setattr(linkedin, "_call", lambda method, url, **kw: sent.setdefault("li", kw["json"]) and httpx.Response(
+        201, headers={"x-restli-id": "urn:li:share:1"}, request=httpx.Request(method, url)))
+    li_item = item(db_session, ws, li, minutes=0, content="", artifact_id=upload.id)
+    launchpad.publish_item(db_session, li_item)
+    assert li_item.status == "posted" and sent["li"]["commentary"] == "" and sent["li"]["content"]["media"]["id"]
+
+    xa = account(db_session, ws, "x", scopes="tweet.write media.write")
+    monkeypatch.setattr(x, "can_post_media", lambda a: True)
+    monkeypatch.setattr(x, "_upload_video", lambda headers, m: "m1")
+    monkeypatch.setattr(x, "_access", lambda db, a: "token")
+    monkeypatch.setattr(x, "_call", lambda method, url, **kw: sent.setdefault("x", kw["json"]) and httpx.Response(
+        201, json={"data": {"id": "t1"}}, request=httpx.Request(method, url)))
+    x_item = item(db_session, ws, xa, minutes=0, content="", artifact_id=upload.id)
+    launchpad.publish_item(db_session, x_item)
+    assert x_item.status == "posted" and sent["x"] == {"media": {"media_ids": ["m1"]}}
+
+    text_only = item(db_session, ws, xa, minutes=0, content="")
+    launchpad.publish_item(db_session, text_only)
+    assert text_only.status == "failed" and text_only.error == "Nothing to post."
+
+
+def test_post_now_publishes_in_the_same_request_and_is_never_left_scheduled(client, auth, ws, db_session, monkeypatch):
+    from app.models import Job
+    from app.services.social import linkedin
+
+    li = account(db_session, ws, "linkedin", scopes=LI_SCOPES)
+    monkeypatch.setattr(linkedin, "publish", lambda db, a, posts, media=None: ("urn:li:share:9", "https://linkedin.com/x"))
+    now = lambda **kw: client.post("/api/calendar", json={  # noqa: E731  (no time sent: the server takes it)
+        "platform": "linkedin", "content": "Hello", "social_account_id": str(li.id), "publish_now": True, **kw}, headers=auth)
+
+    text = now()
+    assert text.status_code == 200, text.text
+    assert text.json()["status"] == "posted" and text.json()["external_url"] == "https://linkedin.com/x"
+
+    video = made(db_session, ws, "video", key="ws/v/now.mp4", data=os.urandom(100_000), duration_s=30)
+    media = now(artifact_id=str(video.id)).json()
+    assert media["status"] == "publishing"  # uploading goes through a job: never "scheduled" in between
+    job = db_session.query(Job).filter(Job.kind == "publish_post").one()
+    assert job.params["item_id"] == media["id"]
+
+
+def test_saving_a_failed_or_draft_post_reschedules_it_at_a_time_still_ahead(client, auth, ws, db_session):
+    li = account(db_session, ws, "linkedin", scopes=LI_SCOPES)
+    year = datetime.now(UTC).year + 1
+    for status in ("failed", "draft", "reminded"):
+        it = item(db_session, ws, li, minutes=-90, status=status)
+        # Its old time has passed: rescheduled there, it would go out at the very next run.
+        r = client.patch(f"/api/calendar/{it.id}", json={"status": "scheduled"}, headers=auth)
+        assert r.status_code == 409 and r.json()["detail"]["code"] == "missed", status
+        r = client.patch(f"/api/calendar/{it.id}", json={"status": "scheduled", "local_time": f"{year}-01-05T10:30",
+                                                         "timezone": "UTC"}, headers=auth)
+        assert r.status_code == 200, r.text
+        got = r.json()
+        assert got["status"] == "scheduled" and got["error"] is None
+        assert datetime.fromisoformat(got["scheduled_at"]) == datetime(year, 1, 5, 10, 30, tzinfo=UTC)
+
+
+def test_the_list_says_what_each_item_already_has_scheduled(client, auth, ws, db_session):
+    li = account(db_session, ws, "linkedin", scopes=LI_SCOPES)
+    deck = made(db_session, ws, "summary", summary="Raise prices once a year.")
+    video = made(db_session, ws, "video", key="ws/v/s.mp4", data=os.urandom(100_000), duration_s=30)
+    later = item(db_session, ws, li, minutes=600, artifact_id=deck.id)
+    sooner = item(db_session, ws, li, minutes=120, artifact_id=deck.id)
+    item(db_session, ws, li, minutes=-60, artifact_id=deck.id)  # its time has passed
+    item(db_session, ws, li, minutes=300, status="posted", artifact_id=deck.id)
+    item(db_session, ws, li, minutes=300, status="failed", artifact_id=deck.id)
+    listed = {a["id"]: a for a in client.get("/api/launchpad/postable", headers=auth).json()}
+    assert [s["id"] for s in listed[str(deck.id)]["scheduled"]] == [str(sooner.id), str(later.id)]
+    assert listed[str(deck.id)]["scheduled"][0]["platform_label"] == "LinkedIn"
+    assert listed[str(video.id)]["scheduled"] == []

frontend/src/App.tsx

@@ -1,4 +1,4 @@
-import { Navigate, Route, Routes, useSearchParams } from "react-router-dom";
+import { Navigate, Route, Routes } from "react-router-dom";
 import AppShell from "./components/AppShell";
 import { PublicFooter, PublicNav } from "./components/PublicChrome";
 import PricingTiers from "./components/PricingTiers";
@@ -8,6 +8,7 @@ import AuthPage from "./pages/AuthPage";
 import { Blog, BlogPostPage } from "./pages/Blog";
 import Landing from "./pages/Landing";
 import Archive from "./pages/Archive";
+import Voices from "./pages/Voices";
 import Launchpad, { ScheduleLaunch } from "./pages/Launchpad";
 import LaunchKitRedirect, { LaunchKitPage, LaunchKits } from "./pages/LaunchKit";
 import MissionControl from "./pages/MissionControl";
@@ -64,7 +65,7 @@ export default function App() {
         <Route path="reports/:id" element={<ReportPage />} />
         <Route path="videos" element={<Navigate to="/app/archive?tab=videos" replace />} />
         <Route path="videos/new" element={<VideoCreate />} />
-        <Route path="videos/voices" element={<Navigate to="/app/archive?tab=voices" replace />} />
+        <Route path="videos/voices" element={<Navigate to="/app/voices" replace />} />
         <Route path="videos/:id" element={<VideoEditor />} />
         <Route path="sources" element={<Sources />} />
         <Route path="map" element={<TopicMap />} />
@@ -76,6 +77,7 @@ export default function App() {
         <Route path="launchpad/kits" element={<LaunchKits />} />
         <Route path="launchpad/kits/:id" element={<LaunchKitPage />} />
         <Route path="archive" element={<Archive />} />
+        <Route path="voices" element={<Voices />} />
         <Route path="resurface" element={<Resurface />} />
         <Route path="settings" element={<Settings />} />
         <Route path="*" element={<MissionControl />} />
@@ -87,9 +89,7 @@ export default function App() {
   );
 }
 
-/** The old Voice page (/app/voice, ?step=writing for the writing voice) is the Library's Voices tab now. */
+/** The old Voice page (/app/voice) is Manage voices (/app/voices) now. */
 function VoiceRedirect() {
-  const [params] = useSearchParams();
-  const writing = params.get("step") === "writing";
-  return <Navigate to={`/app/archive?tab=voices${writing ? "&step=writing" : ""}`} replace />;
+  return <Navigate to="/app/voices" replace />;
 }

frontend/src/api/client.ts

@@ -63,7 +63,12 @@ async function parseError(res: Response): Promise<ApiError> {
     const body = await res.json();
     const detail = body.detail;
     if (typeof detail === "string") message = detail;
-    else if (detail?.message) {
+    else if (Array.isArray(detail) && detail.length) {
+      // A request the server's field checks refused (FastAPI's 422 list): say which field and why, not "Unprocessable Entity".
+      const first = detail[0] as { loc?: (string | number)[]; msg?: string };
+      const field = (first.loc ?? []).filter((p) => p !== "body").join(" ");
+      if (first.msg) message = field ? `${field}: ${first.msg}` : first.msg;
+    } else if (detail?.message) {
       message = detail.message;
       code = detail.code;
       extra = detail;

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,33 @@ 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}`),
+  /** A slide deck's slides as the editor has them, drawn without saving (after a slide or a text box is added,
+   * removed, moved or changed to another layout). Returns them as they will be kept. */
+  previewDeck: (id: string, slides: EditSlide[]) =>
+    post<{ slides: EditSlide[]; slides_html: string[]; slide_slots: string[][] }>(`/api/artifacts/${id}/deck-preview`, { slides }),
+  /** The editor's slides kept: the server fits the deck again and returns it. */
+  saveDeck: (id: string, slides: EditSlide[]) => put<Artifact>(`/api/artifacts/${id}/deck`, { slides }),
+};
+
+/** One slide in the stored shape (backend app/slides/content.py, empty_slide). */
+export type EditSlide = {
+  layout: string;
+  variant: string;
+  kicker: string;
+  heading: string;
+  lead: string;
+  points: { term: string; text: string }[];
+  left: { label: string; items: string[] };
+  right: { label: string; items: string[] };
+  stat: { value: string; label: string };
+  quote: { text: string; by: string };
+  takeaways: string[];
+  closing: string;
+  notes: string;
+  sources: { title?: string; path: string; line_start: number; line_end: number }[];
+  shrink?: number;
 };
 
 export const jobsApi = {
@@ -217,6 +249,8 @@ export type ItemBody = {
   social_account_id?: string | null;
   remind_by_email?: boolean;
   draft?: boolean;
+  /** Post now: published (or reminded) in the same request, never left scheduled. */
+  publish_now?: boolean;
 };
 
 export const launchpadApi = {

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 = {
@@ -320,7 +320,8 @@ export type PostableArtifact = {
   type: ArtifactType;
   type_label: string;
   title: string;
-  media: "image" | "video" | "text";
+  /** "audio": an audio overview, listed to download only (X and LinkedIn take no audio files). */
+  media: "image" | "video" | "audio" | "text";
   media_count: number;
   duration_s: number | null;
   thumb_url: string | null;
@@ -332,6 +333,10 @@ export type PostableArtifact = {
   editable_video: boolean;
   /** An uploaded file's link, to preview it (null for anything else). */
   view_url: string | null;
+  /** An audio overview's file, saved as a download (null for anything else). */
+  download_url?: string | null;
+  /** Its posts still to go out (scheduled, ahead), soonest first: the Schedule a launch list offers to reschedule them. */
+  scheduled?: { id: string; scheduled_at: string; platform_label: string }[];
   created_at: string | null;
   /** A starting text: X as a thread (list of posts), LinkedIn as one post. */
   prefill: { x: string[]; linkedin: string };

frontend/src/components/AppShell.tsx

@@ -9,6 +9,7 @@ import UpgradeModal from "./UpgradeModal";
 import {
   LaunchpadIcon,
   LibraryIcon,
+  MicIcon,
   OrbitIcon,
   PlanetIcon,
   SatelliteDishIcon,
@@ -20,6 +21,7 @@ const NAV: { to: string; label: string; icon: typeof PlanetIcon; end?: boolean;
   { to: "/app/sources", label: "Sources", icon: SatelliteDishIcon, also: ["/app/map"] },
   { to: "/app/archive", label: "Library", icon: LibraryIcon, also: ["/app/videos"] },
   { to: "/app/launchpad", label: "Launchpad", icon: LaunchpadIcon, also: ["/app/resurface", "/app/launch-kit"] },
+  { to: "/app/voices", label: "Manage voices", icon: MicIcon },
 ];
 
 const COLLAPSED_KEY = "ns_sidebar_collapsed";

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/ArtifactRow.tsx

@@ -4,6 +4,7 @@ import { artifactsApi, videosApi } from "../api/endpoints";
 import type { Artifact, Citation } from "../api/types";
 import { useJob } from "../hooks/useJob";
 import { Body } from "./ArtifactCard";
+import { SlideDeckViewer } from "./SlideDeck";
 import { TrashIcon } from "./icons/Icons";
 import { errorMessage, formatDate, formatDuration, JobProgress } from "./ui";
 
@@ -14,7 +15,8 @@ function statusOf(a: Artifact, running: boolean): { label: string; tone: "done"
 }
 
 /** One generated item as a full-width row (like the Videos list): its type, title, status and date. A video opens its
- * editor; anything else expands in place to its player or image. */
+ * editor, a finished slide deck its viewer (to read, edit, present or download it); anything else expands in place
+ * to its player or image. */
 export function ArtifactRow({
   artifact: initial,
   onCite,
@@ -41,6 +43,8 @@ export function ArtifactRow({
   const running = !!job && (job.status === "queued" || job.status === "running");
   const st = statusOf(artifact, running);
   const isEditorVideo = artifact.provider === "blog2video";
+  const isDeck = artifact.type === "slide_deck" && artifact.status === "ready";
+  const [viewing, setViewing] = useState(false);
 
   useEffect(() => {
     if (!armed) return;
@@ -73,7 +77,8 @@ export function ArtifactRow({
     <>
       <span className="vw-list-title">
         <span className={`type-chip ${artifact.type}`}>{artifact.type_label}</span>
-        <strong>{artifact.title}</strong>
+        {/* A deck's title starts "Slide deck: ", which its chip already says */}
+        <strong>{artifact.type === "slide_deck" ? artifact.title.replace(/^Slide deck: /, "") : artifact.title}</strong>
         <span className={`vw-dot ${st.tone}`} aria-hidden="true" />
         <span className="muted">{st.label}</span>
       </span>
@@ -90,12 +95,17 @@ export function ArtifactRow({
       <div className="artifact-row-head">
         {isEditorVideo ? (
           <Link to={`/app/videos/${artifact.id}`} className="vw-list-main">{main}</Link>
+        ) : isDeck ? (
+          <button type="button" className="vw-list-main artifact-row-toggle" onClick={() => setViewing(true)}>
+            {main}
+          </button>
         ) : (
           <button type="button" className="vw-list-main artifact-row-toggle" aria-expanded={openRow}
                   onClick={() => setOpenRow((o) => !o)}>
             {main}
           </button>
         )}
+        {isDeck && actions?.(artifact)}
         {artifact.status === "failed" && (
           <button type="button" className="btn btn-small" onClick={retry}>Retry</button>
         )}
@@ -109,7 +119,17 @@ export function ArtifactRow({
       </div>
       {running && job && <JobProgress job={job} compact />}
       {error && <p className="error-text">{error}</p>}
-      {openRow && !isEditorVideo && (
+      {viewing && (
+        <SlideDeckViewer artifact={artifact} onClose={() => setViewing(false)} onSaved={(a) => {
+          setArtifact(a);
+          onChanged?.(a);
+        }} onDelete={async () => {
+          await artifactsApi.remove(artifact.id);
+          setViewing(false);
+          onRemoved?.(artifact.id);
+        }} />
+      )}
+      {openRow && !isEditorVideo && !isDeck && (
         <div className="artifact-row-body">
           {artifact.status === "failed" && artifact.content.error && <p className="error-text">{artifact.content.error}</p>}
           <Body artifact={artifact} onCite={onCite} />

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/ScheduleModal.tsx

@@ -79,7 +79,8 @@ export function ScheduleModal({
     if (artifactId && !artifact) {
       launchpadApi.postable().then((list) => {
         const found = list.find((a) => a.id === artifactId);
-        if (found && found.type !== "launch_kit") attach(found); // a kit is never an attachment
+        // a kit is never an attachment, and audio can't be posted (X and LinkedIn take no audio files)
+        if (found && found.type !== "launch_kit" && found.media !== "audio") attach(found);
       }, () => undefined);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -151,8 +152,9 @@ export function ScheduleModal({
         const account = meta.auto ? accountFor(p) : null;
         const item = await launchpadApi.create({
           platform: p,
-          // Post now: this instant. Scheduled: the half hour picked, in the user's zone (the backend makes it UTC).
-          ...(now ? { scheduled_at: new Date().toISOString() } : { local_time: when, timezone: userTimeZone() }),
+          // Post now: published by this very request (the server takes the time). Scheduled: the half hour picked, in
+          // the user's zone (the backend makes it UTC).
+          ...(now ? { publish_now: true } : { local_time: when, timezone: userTimeZone() }),
           content: merged[0] ?? "",
           thread: merged.slice(1),
           // Images and videos only go to X and LinkedIn; text attachments go anywhere.
@@ -162,8 +164,7 @@ export function ScheduleModal({
           social_account_id: account?.id ?? null,
           remind_by_email: CONNECTED_ONLY.includes(p) ? false : remind || !account,
         });
-        const out = now && item.auto_post ? await launchpadApi.publishNow(item.id) : item;
-        onScheduled?.(out);
+        onScheduled?.(item);
         done.push(meta.label);
       }
       onClose();

frontend/src/components/SlideDeck.tsx

@@ -0,0 +1,1054 @@
+import { useCallback, useEffect, useLayoutEffect, useRef, useState, type CSSProperties, type ReactNode } from "react";
+import { createPortal } from "react-dom";
+import { artifactsApi, type EditSlide, type GenerateBody } from "../api/endpoints";
+import { addActions, convert, type DeckFmt, LAYOUTS, MAX_SLIDES, newSlide, problem, removable, removeField, setText } from "./slideDeckEdit";
+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";
+
+/** Bumped when the thumbnails are drawn again (backend/scripts/render_slide_thumbnails.py), so browsers fetch the new
+ * images instead of the ones they cached. */
+const THUMBS_VERSION = 2;
+
+/** 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: "Night stellar", blurb: "Night sky, planets and a blue glow" },
+  { id: "light-space", name: "Moon light", blurb: "Moonlit 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?v=${THUMBS_VERSION}`} 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>
+  );
+}
+
+/** The editor that runs inside an editable slide's frame. The frame is sandboxed with allow-scripts but not
+ * allow-same-origin, so this script (and anything else in the slide) can never reach this page: the two only talk by
+ * postMessage. The page says when edit mode is on and which text boxes may be removed ({type: "sd-mode", editing,
+ * removable}); the frame reports each edit ({type: "sd-edit", field, text}), a box's remove button
+ * ({type: "sd-remove", field}) and that it is ready ({type: "sd-ready"}). Self-contained: it is sent as source.
+ *
+ * In edit mode the spans the server marks with data-f (and data-max) are editable, single line, plain text, no longer
+ * than the field holds; every text box is framed (dashed, solid on hover, lit while typing), and a click anywhere in a
+ * box types into it. Sizes are slide pixels: the slide is drawn 1920 wide and scaled down. */
+function slideEditor() {
+  const css = `.sd-box{outline:3px dashed rgba(33,124,255,.8);outline-offset:10px;border-radius:6px;cursor:text;
+background-color:rgba(33,124,255,.07);transition:outline-color .12s,box-shadow .12s}
+.sd-box:hover{outline-style:solid}
+.sd-box:focus-within{outline:4px solid #217cff;box-shadow:0 0 0 14px rgba(33,124,255,.22)}
+[data-f]{outline:none;caret-color:#217cff}
+[data-f]:empty{display:inline-block;min-width:1.2em;min-height:1em;background:rgba(255,93,93,.25)}
+.sd-x{position:absolute;top:-34px;right:-34px;z-index:2;width:48px;height:48px;padding:0;border:3px solid #fff;border-radius:50%;
+background:#e5484d;color:#fff;font:700 30px/1 Inter,system-ui,sans-serif;cursor:pointer;opacity:.45;transition:opacity .12s;
+box-shadow:0 4px 14px rgba(0,0,0,.35)}
+.sd-box:hover .sd-x,.sd-box:focus-within .sd-x{opacity:1}
+.sd-x:hover{background:#c9353a}`;
+  const spans = Array.from(document.querySelectorAll<HTMLElement>("[data-f]"));
+  const boxes = Array.from(new Set(spans.map((el) => el.closest<HTMLElement>(".e")).filter((b): b is HTMLElement => !!b)));
+  const style = document.createElement("style");
+  style.textContent = css;
+  let on = false;
+  const field = (t: EventTarget | null) => {
+    const el = t as HTMLElement | null;
+    return on && el && el.dataset && el.dataset.f ? el : null;
+  };
+  const room = (el: HTMLElement) => {
+    const sel = document.getSelection();
+    const picked = sel && sel.rangeCount && el.contains(sel.anchorNode) ? sel.toString().length : 0;
+    return Number(el.dataset.max || 9999) - ((el.textContent || "").length - picked);
+  };
+  let removers: HTMLElement[] = [];
+  const setMode = (editing: boolean, removable: string[]) => {
+    on = editing;
+    removers.forEach((x) => x.remove());
+    removers = [];
+    for (const el of spans) {
+      if (!editing) {
+        el.removeAttribute("contenteditable");
+        continue;
+      }
+      try {
+        el.contentEditable = "plaintext-only";
+      } catch {
+        el.contentEditable = "true"; // no plaintext-only: paste is made plain below
+      }
+      el.spellcheck = true;
+    }
+    boxes.forEach((b) => b.classList.toggle("sd-box", editing));
+    // One remove button per box that may go: for a point's box, the point itself (its text) before its title.
+    if (editing) {
+      for (const b of boxes) {
+        const fields = Array.from(b.querySelectorAll<HTMLElement>("[data-f]")).map((el) => el.dataset.f || "");
+        const f = fields.find((x) => x.endsWith(".text") && removable.includes(x)) || fields.find((x) => removable.includes(x));
+        if (!f) continue;
+        const x = document.createElement("button");
+        x.className = "sd-x";
+        x.type = "button";
+        x.textContent = "×";
+        x.title = "Remove this text box";
+        x.setAttribute("aria-label", "Remove this text box");
+        x.contentEditable = "false";
+        x.dataset.remove = f;
+        b.appendChild(x);
+        removers.push(x);
+      }
+    }
+    if (editing) document.head.appendChild(style);
+    else {
+      style.remove();
+      const sel = document.getSelection();
+      if (sel) sel.removeAllRanges();
+    }
+  };
+  // A click in a box but not on its text (the box is often larger than the words): type at the end of the nearest text.
+  document.addEventListener("mousedown", (e) => {
+    const t = e.target as HTMLElement | null;
+    if (!on || !t || field(t) || !t.closest) return;
+    const x = t.closest<HTMLElement>(".sd-x");
+    if (x) {
+      e.preventDefault();
+      parent.postMessage({ type: "sd-remove", field: x.dataset.remove }, "*");
+      return;
+    }
+    const box = t.closest<HTMLElement>(".sd-box");
+    if (!box) return;
+    let near: HTMLElement | null = null;
+    let best = Infinity;
+    box.querySelectorAll<HTMLElement>("[data-f]").forEach((el) => {
+      const r = el.getBoundingClientRect();
+      const d = Math.hypot(Math.max(r.left - e.clientX, 0, e.clientX - r.right), Math.max(r.top - e.clientY, 0, e.clientY - r.bottom));
+      if (d < best) [near, best] = [el, d];
+    });
+    if (!near) return;
+    e.preventDefault();
+    const el: HTMLElement = near;
+    el.focus();
+    const range = document.createRange();
+    range.selectNodeContents(el);
+    range.collapse(false);
+    const sel = document.getSelection();
+    if (sel) {
+      sel.removeAllRanges();
+      sel.addRange(range);
+    }
+  });
+  document.addEventListener("beforeinput", (e) => {
+    const el = field(e.target);
+    if (!el) return;
+    if (e.inputType === "insertParagraph" || e.inputType === "insertLineBreak") {
+      e.preventDefault(); // one line: Enter is done
+      el.blur();
+    } else if (e.inputType === "insertText" && e.data && e.data.length > room(el)) {
+      e.preventDefault();
+    }
+  });
+  document.addEventListener("paste", (e) => {
+    const el = field(e.target);
+    if (!el) return;
+    e.preventDefault();
+    const text = ((e.clipboardData && e.clipboardData.getData("text/plain")) || "").replace(/\s+/g, " ").slice(0, Math.max(room(el), 0));
+    if (text) document.execCommand("insertText", false, text);
+  });
+  document.addEventListener("drop", (e) => {
+    if (field(e.target)) e.preventDefault(); // dragged text could bring markup or overflow
+  });
+  document.addEventListener("input", (e) => {
+    const el = field(e.target);
+    if (el) parent.postMessage({ type: "sd-edit", field: el.dataset.f, text: el.textContent || "" }, "*");
+  });
+  document.addEventListener("keydown", (e) => {
+    const el = field(e.target);
+    if (el && e.key === "Escape") el.blur();
+  });
+  window.addEventListener("message", (e) => {
+    if (e.source === parent && e.data && e.data.type === "sd-mode") {
+      setMode(!!e.data.editing, Array.isArray(e.data.removable) ? e.data.removable : []);
+    }
+  });
+  parent.postMessage({ type: "sd-ready" }, "*");
+}
+
+const EDITOR_TAG = `<script>(${slideEditor.toString()})()</script>`;
+
+/** One slide (HTML from our own layout, every word escaped) in a sandboxed frame, scaled to fit the box it is given.
+ * With `onEdit` the frame also runs the slide editor (still isolated from this page: an opaque origin), and while
+ * `editing` its text is edited in place. */
+export function SlideFrame({ html, title, fit = "width", hidden = false, editing = false, onEdit, removable, onRemove }: {
+  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;
+  editing?: boolean;
+  /** Text was edited: where it lives on the slide ("heading", "points.2.text") and what it says now. */
+  onEdit?: (field: string, text: string) => void;
+  /** The text boxes that get a remove button in edit mode, and what a click on one does. */
+  removable?: string[];
+  onRemove?: (field: string) => void;
+}) {
+  const box = useRef<HTMLDivElement>(null);
+  const frame = useRef<HTMLIFrameElement>(null);
+  const [scale, setScale] = useState(0.2);
+  const editRef = useRef(onEdit);
+  editRef.current = onEdit;
+  const editingRef = useRef(editing);
+  editingRef.current = editing;
+  const removeRef = useRef(onRemove);
+  removeRef.current = onRemove;
+  const removableKey = (removable ?? []).join(",");
+  const removableRef = useRef(removable ?? []);
+  removableRef.current = removable ?? [];
+  const withEditor = !!onEdit;
+  const doc = withEditor ? html.replace("</body>", `${EDITOR_TAG}</body>`) : html;
+  const tell = (on: boolean) =>
+    frame.current?.contentWindow?.postMessage({ type: "sd-mode", editing: on, removable: removableRef.current }, "*");
+  useEffect(() => {
+    if (!withEditor) return;
+    const onMessage = (e: MessageEvent) => {
+      if (e.source !== frame.current?.contentWindow || !e.data || typeof e.data !== "object") return;
+      if (e.data.type === "sd-ready") tell(editingRef.current); // loaded (again): in the mode the page is in
+      else if (e.data.type === "sd-edit" && typeof e.data.field === "string" && typeof e.data.text === "string") {
+        if (editingRef.current) editRef.current?.(e.data.field, e.data.text);
+      } else if (e.data.type === "sd-remove" && typeof e.data.field === "string" && removableRef.current.includes(e.data.field)) {
+        if (editingRef.current) removeRef.current?.(e.data.field);
+      }
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [withEditor]);
+  useEffect(() => {
+    if (withEditor) tell(editing);
+  }, [editing, withEditor, removableKey]);
+  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}${editing ? " sd-frame-edit" : ""}`}
+         style={hidden ? { visibility: "hidden" } : undefined} aria-hidden={hidden}>
+      <iframe ref={frame} title={title} srcDoc={doc} sandbox={withEditor ? "allow-scripts" : ""} tabIndex={editing ? undefined : -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. `prepare` runs first
+ * (the viewer saves unsaved edits, so the file has them) and stops the download when it returns false. */
+function useDeckDownload(artifact: Artifact, prepare?: () => Promise<boolean>) {
+  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 {
+      if (prepare && !(await prepare())) return;
+      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, prepare }: { artifact: Artifact; prepare?: () => Promise<boolean> }) {
+  const menu = useMenu();
+  const dl = useDeckDownload(artifact, prepare);
+  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, prepare }: {
+  artifact: Artifact;
+  prepare?: () => Promise<boolean>;
+  onRename?: () => void;
+  onPresent: () => void;
+  onDelete: () => Promise<void>;
+  notes?: boolean;
+  onNotes?: () => void;
+}) {
+  const menu = useMenu();
+  const dl = useDeckDownload(artifact, prepare);
+  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>
+);
+
+const ArrowUpIcon = () => <SvgIcon><path d="M12 19V5M6 11l6-6 6 6" /></SvgIcon>;
+const ArrowDownIcon = () => <SvgIcon><path d="M12 5v14M6 13l6 6 6-6" /></SvgIcon>;
+const DuplicateIcon = () => (
+  <SvgIcon>
+    <rect x="8" y="8" width="12" height="12" rx="2" />
+    <path d="M16 8V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h2" />
+  </SvgIcon>
+);
+
+/** The working copy edit mode changes: the slides as the editor has them, drawn, and what each slide's design has a
+ * place for. Typing changes the slides only (the frame already shows it); anything else is drawn again by the server. */
+type Draft = { slides: EditSlide[]; pages: string[]; slots: string[][] };
+
+function draftOf(artifact: Artifact): Draft {
+  const c = artifact.content;
+  return {
+    slides: JSON.parse(JSON.stringify(Array.isArray(c.deck?.slides) ? c.deck.slides : [])) as EditSlide[],
+    pages: Array.isArray(c.slides_html) ? (c.slides_html as string[]) : [],
+    slots: Array.isArray(c.slide_slots) ? (c.slide_slots as string[][]) : [],
+  };
+}
+
+/** One slide's controls in edit mode: its layout, the text boxes it can gain, and moving, duplicating or deleting it. */
+function SlideTools({ k, count, slide, slots, fmt, busy, onChange, onMove, onDuplicate, onDelete }: {
+  k: number;
+  count: number;
+  slide: EditSlide;
+  slots: string[];
+  fmt: DeckFmt;
+  busy: boolean;
+  onChange: (next: EditSlide) => void;
+  onMove: (by: -1 | 1) => void;
+  onDuplicate: () => void;
+  onDelete: () => void;
+}) {
+  return (
+    <div className="sd-tools" role="toolbar" aria-label={`Slide ${k + 1}`}>
+      <span className="sd-tools-no">Slide {k + 1}</span>
+      <label className="sd-tools-layout">
+        <span className="sr-only">Layout of slide {k + 1}</span>
+        <select className="input" value={slide.layout} disabled={busy} onChange={(e) => onChange(convert(slide, e.target.value, fmt))}>
+          {LAYOUTS.map((l) => <option key={l.id} value={l.id}>{l.name}</option>)}
+        </select>
+      </label>
+      {addActions(slide, slots, fmt).map((a) => (
+        <button key={a.id} type="button" className="sd-tool" disabled={busy} onClick={() => onChange(a.apply(slide))}>+ {a.label}</button>
+      ))}
+      <span className="sd-tools-gap" />
+      <button type="button" className="sd-icon-btn sd-tool-icon" title="Move up" aria-label={`Move slide ${k + 1} up`}
+              disabled={busy || k === 0} onClick={() => onMove(-1)}><ArrowUpIcon /></button>
+      <button type="button" className="sd-icon-btn sd-tool-icon" title="Move down" aria-label={`Move slide ${k + 1} down`}
+              disabled={busy || k === count - 1} onClick={() => onMove(1)}><ArrowDownIcon /></button>
+      <button type="button" className="sd-icon-btn sd-tool-icon" title="Duplicate slide" aria-label={`Duplicate slide ${k + 1}`}
+              disabled={busy || count >= MAX_SLIDES} onClick={onDuplicate}><DuplicateIcon /></button>
+      <button type="button" className="sd-icon-btn sd-tool-icon sd-tool-danger" title="Delete slide" aria-label={`Delete slide ${k + 1}`}
+              disabled={busy || count <= 1} onClick={onDelete}><TrashIcon size={20} /></button>
+    </div>
+  );
+}
+
+/** "+ Add slide" after a slide in edit mode: a new slide of the layout picked. */
+function AddSlide({ after, busy, full, onAdd }: { after: number; busy: boolean; full: boolean; onAdd: (layout: string) => void }) {
+  return (
+    <div className="sd-add-slide">
+      <label>
+        <span className="sr-only">Add a slide after slide {after + 1}</span>
+        <select className="input" value="" disabled={busy || full} onChange={(e) => e.target.value && onAdd(e.target.value)}>
+          <option value="">{full ? `At most ${MAX_SLIDES} slides` : "+ Add slide here"}</option>
+          {LAYOUTS.map((l) => <option key={l.id} value={l.id}>{l.name}</option>)}
+        </select>
+      </label>
+    </div>
+  );
+}
+
+/** The deck in a popup: its actions along the top (edit, present, a larger preview, download, more) and every slide
+ * below, one after another. A click on a slide presents from it. The pencil opens edit mode: every text on the slides
+ * is a framed text box to type in (with a remove button where the slide can do without it), each slide has its
+ * controls (layout, text boxes to add, move, duplicate, delete), slides can be added between them, and the speaker
+ * notes are editable too. Save keeps it all; leaving edit mode or closing with unsaved changes asks first. Presenting
+ * or downloading saves first, so both show the edited deck. */
+export function SlideDeckViewer({ artifact, onClose, onDelete, onSaved }: {
+  artifact: Artifact;
+  onClose: () => void;
+  onDelete: () => Promise<void>;
+  /** The deck as the server has it now (saved, or fetched afresh). */
+  onSaved: (artifact: Artifact) => void;
+}) {
+  const stored = 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 [draft, setDraft] = useState<Draft | null>(null); // edit mode when set
+  const [dirty, setDirty] = useState(false);
+  const [busy, setBusy] = useState(false); // the server is drawing the slides again
+  const [saving, setSaving] = useState(false);
+  const [saveError, setSaveError] = useState<string | null>(null);
+  // Unsaved changes and the viewer is closing, or edit mode is being left: Save, Don't save or Cancel.
+  const [asking, setAsking] = useState<"close" | "done" | null>(null);
+  const [opening, setOpening] = useState(false); // fetching the deck afresh before edit mode
+  const [version, setVersion] = useState(0); // bumped to draw the slides again from the stored deck (changes dropped)
+  const previewSeq = useRef(0);
+  const stack = useRef<HTMLOListElement>(null);
+  const c = artifact.content;
+  const fmt: DeckFmt = c.format === "presenter" ? "presenter" : "detailed";
+  const theme = SLIDE_THEMES.find((t) => t.id === c.theme)?.name ?? "Night stellar";
+  const editing = draft !== null;
+  const pages = draft ? draft.pages : stored.pages;
+  const slides: DeckSlide[] = draft ? draft.slides : stored.slides;
+
+  const save = async (): Promise<boolean> => {
+    if (!draft || !dirty) return true;
+    const wrong = problem(draft.slides);
+    if (wrong) {
+      setSaveError(wrong);
+      return false;
+    }
+    setSaving(true);
+    setSaveError(null);
+    try {
+      const next = await artifactsApi.saveDeck(artifact.id, draft.slides);
+      onSaved(next);
+      setDraft(draftOf(next));
+      setDirty(false);
+      return true;
+    } catch (e) {
+      setSaveError(errorMessage(e));
+      return false;
+    } finally {
+      setSaving(false);
+    }
+  };
+  // A change to the deck's structure (a slide or a text box added, removed, moved, another layout): drawn by the server.
+  const restructure = async (next: EditSlide[]) => {
+    if (!draft) return;
+    setDraft({ ...draft, slides: next });
+    setDirty(true);
+    setBusy(true);
+    setSaveError(null);
+    const seq = ++previewSeq.current;
+    try {
+      const got = await artifactsApi.previewDeck(artifact.id, next);
+      if (seq === previewSeq.current) setDraft({ slides: got.slides, pages: got.slides_html, slots: got.slide_slots });
+    } catch (e) {
+      if (seq === previewSeq.current) setSaveError(errorMessage(e));
+    } finally {
+      if (seq === previewSeq.current) setBusy(false);
+    }
+  };
+  const change = (k: number, slide: EditSlide) => draft && void restructure(draft.slides.map((x, i) => (i === k ? slide : x)));
+  const move = (k: number, by: -1 | 1) => {
+    if (!draft) return;
+    const next = [...draft.slides];
+    [next[k], next[k + by]] = [next[k + by], next[k]];
+    void restructure(next);
+  };
+  const insert = (at: number, slide: EditSlide) => draft && void restructure([...draft.slides.slice(0, at), slide, ...draft.slides.slice(at)]);
+  const typed = (k: number, field: string, text: string) => {
+    setDraft((d) => (d ? { ...d, slides: d.slides.map((x, i) => (i === k ? setText(x, field, text) : x)) } : d));
+    setDirty(true);
+  };
+  const requestClose = () => (dirty ? setAsking("close") : onClose());
+  const leave = () => {
+    setDraft(null);
+    setDirty(false);
+    setBusy(false);
+    setSaveError(null);
+    previewSeq.current++;
+    setVersion((v) => v + 1);
+  };
+  const stopEditing = () => (dirty ? setAsking("done") : leave());
+  // Edit mode works on the deck as the server has it now (a deck loaded before an update has no editable text).
+  const startEditing = async () => {
+    setOpening(true);
+    setSaveError(null);
+    try {
+      const fresh = await artifactsApi.get(artifact.id);
+      onSaved(fresh);
+      if (!deckOf(fresh).pages.some((html) => html.includes("data-f="))) {
+        setSaveError("This deck can't be edited. Generate it again to edit its text.");
+        return;
+      }
+      setDraft(draftOf(fresh));
+    } catch (e) {
+      setSaveError(errorMessage(e));
+    } finally {
+      setOpening(false);
+    }
+  };
+  const present = async (k: number) => {
+    if (await save()) setPresenting(k);
+  };
+
+  // Leaving the page (closing the tab, reloading) with unsaved changes: the browser asks too.
+  useEffect(() => {
+    if (!dirty) return;
+    const warn = (e: BeforeUnloadEvent) => e.preventDefault();
+    window.addEventListener("beforeunload", warn);
+    return () => window.removeEventListener("beforeunload", warn);
+  }, [dirty]);
+
+  // 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, editing]);
+
+  const actions = (
+    <div className="sd-head-actions" role="toolbar" aria-label="Slide deck">
+      {editing ? (
+        <>
+          <button type="button" className="btn btn-primary btn-small sd-save" disabled={saving || busy || !dirty} onClick={() => void save()}>
+            {saving ? (<><span className="nbv-send-spinner" aria-hidden="true" /> Saving...</>) : "Save"}
+          </button>
+          <button type="button" className="btn btn-small sd-save" disabled={saving} onClick={stopEditing}>Done</button>
+        </>
+      ) : (
+        <button type="button" className="sd-icon-btn" title="Edit slides" aria-label="Edit slides" disabled={!pages.length || opening}
+                onClick={() => void startEditing()}>
+          {opening ? <span className="nbv-send-spinner" aria-hidden="true" /> : <PencilIcon />}
+        </button>
+      )}
+      <button type="button" className="sd-icon-btn" title="Start slideshow" aria-label="Start slideshow"
+              disabled={!pages.length || saving || busy} onClick={() => void present(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} prepare={save} />}
+      <DeckMenu artifact={artifact} onPresent={() => void present(inView)} onDelete={onDelete} prepare={save}
+                notes={notes} onNotes={() => setNotes((n) => !n)} />
+      <button type="button" className="sd-icon-btn" onClick={requestClose} 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={requestClose} wide actions={actions}>
+      <div className={`sd-view${big ? " big" : ""}`}>
+        <p className="muted small sd-meta">
+          {pages.length} slides · {fmt === "presenter" ? "Presenter" : "Detailed"} · {theme}
+          {c.source ? ` · from ${sourceSummary(c.source)}` : ""}
+          <span className="sd-edit-hint">
+            {editing ? ` · Editing: click a text box to type${busy ? " · Updating..." : dirty ? " · Unsaved changes" : ""}` : ""}
+          </span>
+        </p>
+        {saveError && !asking && <p className="error-text small sd-edit-error" role="alert">{saveError}</p>}
+        {pages.length === 0 ? (
+          <p className="error-text">This deck has no slides to show. Try generating it again.</p>
+        ) : (
+          <ol className={`sd-stack${busy ? " sd-busy" : ""}`} ref={stack} aria-label="Slides" aria-busy={busy}>
+            {pages.map((html, k) => {
+              const s = slides[k];
+              const sources = [...new Map((s?.sources ?? []).map((x) => [x.title || x.path, x])).values()];
+              const e = draft?.slides[k];
+              return (
+                <li key={k} data-i={k}>
+                  {draft && e && (
+                    <SlideTools k={k} count={draft.slides.length} slide={e} slots={draft.slots[k] ?? []} fmt={fmt} busy={busy || saving}
+                                onChange={(next) => change(k, next)} onMove={(by) => move(k, by)}
+                                onDuplicate={() => insert(k + 1, { ...JSON.parse(JSON.stringify(e)), variant: "" })}
+                                onDelete={() => void restructure(draft.slides.filter((_, i) => i !== k))} />
+                  )}
+                  <div className={`sd-slide${editing ? " sd-slide-editing" : ""}`} role={editing ? undefined : "button"}
+                       tabIndex={editing ? undefined : 0} aria-label={editing ? undefined : `Present from slide ${k + 1}: ${s?.heading ?? ""}`}
+                       onClick={editing ? undefined : () => void present(k)}
+                       onKeyDown={editing ? undefined : (ev) => (ev.key === "Enter" || ev.key === " ") && (ev.preventDefault(), void present(k))}>
+                    <SlideFrame key={version} html={html} title={`Slide ${k + 1}: ${s?.heading ?? ""}`} editing={editing && !busy}
+                                onEdit={(field, text) => typed(k, field, text)}
+                                removable={e ? removable(e) : []} onRemove={(field) => e && change(k, removeField(e, field))} />
+                  </div>
+                  {notes && (
+                    <div className="sd-notes">
+                      {e ? (
+                        <>
+                          <label className="vw-label" htmlFor={`sd-notes-${artifact.id}-${k}`}>Slide {k + 1} notes</label>
+                          <textarea id={`sd-notes-${artifact.id}-${k}`} className="textarea sd-notes-edit" rows={3} maxLength={1500}
+                                    placeholder="No notes for this slide yet." value={e.notes}
+                                    onChange={(ev) => typed(k, "notes", ev.target.value)} />
+                        </>
+                      ) : (
+                        <>
+                          <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>
+                  )}
+                  {draft && (
+                    <AddSlide after={k} busy={busy || saving} full={draft.slides.length >= MAX_SLIDES}
+                              onAdd={(layout) => insert(k + 1, newSlide(layout, fmt))} />
+                  )}
+                </li>
+              );
+            })}
+          </ol>
+        )}
+      </div>
+      {presenting !== null && <SlidePresenter artifact={artifact} start={presenting} onClose={() => setPresenting(null)} />}
+      {asking && (
+        <Modal title="Save changes?" onClose={() => !saving && setAsking(null)}>
+          <div className="stack sd-confirm">
+            <p>You edited this slide deck. Do you want to save your changes{asking === "close" ? " before closing" : ""}?</p>
+            {saveError && <p className="error-text" role="alert">{saveError}</p>}
+            <div className="row sd-confirm-actions">
+              <button type="button" className="btn" onClick={() => setAsking(null)} disabled={saving}>Cancel</button>
+              <button type="button" className="btn" disabled={saving} onClick={() => {
+                if (asking === "close") return onClose();
+                leave();
+                setAsking(null);
+              }}>Don't save</button>
+              <button type="button" className="btn btn-primary" disabled={saving || busy} autoFocus onClick={async () => {
+                if (!(await save())) return;
+                if (asking === "close") return onClose();
+                setAsking(null);
+                leave();
+              }}>
+                {saving ? (<><span className="nbv-send-spinner" aria-hidden="true" /> Saving...</>) : "Save"}
+              </button>
+            </div>
+          </div>
+        </Modal>
+      )}
+    </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} onSaved={setArtifact} />}
+      {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/launchpad/Attachment.tsx

@@ -4,7 +4,7 @@ import { useNavigate } from "react-router-dom";
 import { ApiError } from "../../api/client";
 import { artifactsApi, launchpadApi, videoEditApi, videosApi } from "../../api/endpoints";
 import type { PostableArtifact } from "../../api/types";
-import { ArrowRightIcon, FilmIcon, SparkleIcon, UploadIcon } from "../icons/Icons";
+import { ArrowRightIcon, DownloadIcon, FilmIcon, HeadphonesIcon, SlidesIcon, SparkleIcon, UploadIcon } from "../icons/Icons";
 import { errorMessage, formatDate, Loading, Modal } from "../ui";
 import { finished, jobPercent } from "../video/jobState";
 
@@ -18,9 +18,16 @@ export function mediaLabel(a: PostableArtifact): string {
   if (a.type === "upload") {
     return a.media === "video" ? `Your video${a.duration_s ? ` ${fmtDuration(a.duration_s)}` : ""}` : "Your image";
   }
+  if (a.media === "audio") return `Audio${a.duration_s ? ` ${fmtDuration(a.duration_s)}` : ""} · download only`;
   if (a.media === "video" && a.rendering) return "Rendering: wait for it to finish";
   if (a.media === "video" && a.needs_render) return "Not rendered yet: render it first";
   if (a.media === "video") return a.duration_s ? `Video ${fmtDuration(a.duration_s)}` : "Video";
+  if (a.type === "slide_deck") {
+    // X takes 4 images and LinkedIn 20 (backend app/services/social/media.py MAX_IMAGES): longer decks are cut there.
+    const n = a.media_count;
+    const cut = n > 20 ? " · X posts the first 4, LinkedIn the first 20" : n > 4 ? " · X posts the first 4" : "";
+    return `${n} slide${n === 1 ? "" : "s"} as images${cut}`;
+  }
   if (a.media === "image") return a.media_count === 1 ? "Image" : `${a.media_count} images`;
   return "Text";
 }
@@ -29,7 +36,8 @@ function Thumb({ a }: { a: PostableArtifact }) {
   if (a.thumb_url) return <img className="lp-thumb" src={a.thumb_url} alt="" />;
   return (
     <span className="lp-thumb lp-thumb-icon" aria-hidden="true">
-      {a.media === "video" ? <FilmIcon size={20} /> : <SparkleIcon size={20} />}
+      {a.media === "video" ? <FilmIcon size={20} /> : a.media === "audio" ? <HeadphonesIcon size={20} />
+        : a.type === "slide_deck" ? <SlidesIcon size={20} /> : <SparkleIcon size={20} />}
     </span>
   );
 }
@@ -55,6 +63,32 @@ export function MediaPreviewModal({ a, onClose }: { a: PostableArtifact; onClose
   );
 }
 
+/** An audio overview someone tried to schedule: X and LinkedIn take no audio files, so it is offered to download
+ * instead. Used by the Launchpad's list and the Library. */
+export function AudioOnlyModal({ title, downloadUrl, onClose }: { title: string; downloadUrl: string | null | undefined; onClose: () => void }) {
+  return (
+    <Modal title="Audio can't be posted" onClose={onClose}>
+      <div className="stack lp-audio-only">
+        <span className="lp-audio-only-icon" aria-hidden="true"><HeadphonesIcon size={28} /></span>
+        <p>
+          LinkedIn does not support posting audio files, so <strong>{title}</strong> can't be scheduled. Download it now
+          to use it elsewhere, like a podcast app, your newsletter or a website.
+        </p>
+        <div className="row lp-audio-only-actions">
+          <button type="button" className="btn" onClick={onClose}>Close</button>
+          {downloadUrl ? (
+            <a className="btn btn-primary" href={downloadUrl} download onClick={onClose} autoFocus>
+              <DownloadIcon size={18} /> Download
+            </a>
+          ) : (
+            <span className="muted small">The file isn't available right now. Try again later.</span>
+          )}
+        </div>
+      </div>
+    </Modal>
+  );
+}
+
 /** The attached item: thumbnail, title, what it carries, and Change / Remove. An uploaded file's thumbnail opens its
  * preview. */
 export function AttachmentChip({ a, onChange, onRemove }: {
@@ -307,16 +341,29 @@ function deleteWording(a: PostableArtifact): { title: string; body: string } {
   return { title: "Delete this item?", body: "It's deleted for good. Posts on your calendar that carry it are removed too." };
 }
 
-type Kind = "all" | "kits" | "video" | "uploads";
+type Kind = "all" | "kits" | "video" | "decks" | "audio" | "uploads";
 const KINDS: { id: Kind; label: string }[] = [
   { id: "all", label: "All" },
   { id: "kits", label: "Launch kits" },
   { id: "video", label: "Videos" },
+  { id: "decks", label: "Slide decks" },
+  { id: "audio", label: "Audio" },
   { id: "uploads", label: "Uploads" },
 ];
 /** Which rows a tab shows: Videos is only the ones the video service made (uploaded videos are under Uploads). */
 const matches = (a: PostableArtifact, kind: Kind) =>
-  kind === "all" || (kind === "kits" ? a.type === "launch_kit" : kind === "uploads" ? a.type === "upload" : a.editable_video);
+  kind === "all" || (kind === "kits" ? a.type === "launch_kit" : kind === "uploads" ? a.type === "upload"
+    : kind === "decks" ? a.type === "slide_deck" : kind === "audio" ? a.type === "audio_overview" : a.editable_video);
+
+/** Saves a file from its (presigned, attachment) link. */
+function download(url: string) {
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = "";
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+}
 
 /** What can be uploaded to post, and LinkedIn's size limits for it (checked again by the backend). */
 const UPLOAD_ACCEPT = "image/png,image/jpeg,image/gif,video/mp4";
@@ -366,11 +413,20 @@ export function AttachPicker({ onPick, onCreateKit, onClose }: {
  * searchable; with a link to create a new launch kit when onCreateKit is given. onPickKit, when given, takes the
  * Launch Kits instead of onPick (the Schedule a launch page opens the kit, to schedule its posts from there). A video
  * with no MP4 yet (or one rendering) opens the render pop-up instead. fill: the rows take the screen's height. */
-export function LibraryPicker({ onPick, onPickKit, onCreateKit, fill = false }: {
+export function LibraryPicker({ onPick, onPickKit, onCreateKit, fill = false, onReschedule, onDuplicate, refreshKey = 0, openingId }: {
   onPick: (a: PostableArtifact) => void;
   onPickKit?: (a: PostableArtifact) => void;
   onCreateKit?: () => void;
   fill?: boolean;
+  /** With these (the Schedule a launch page), an item already scheduled says Reschedule and opens that post
+   * (`itemId`), and its menu can schedule it again (a copy of that post). Without them (the composer's picker), every
+   * item is simply picked. */
+  onReschedule?: (a: PostableArtifact, itemId: string) => void;
+  onDuplicate?: (a: PostableArtifact, itemId: string) => void;
+  /** Changed by the page to load the list again (a post was rescheduled, moved or deleted). */
+  refreshKey?: number;
+  /** The item whose scheduled post is being opened: its row shows a spinner and takes no clicks meanwhile. */
+  openingId?: string | null;
 }) {
   const [items, setItems] = useState<PostableArtifact[] | null>(null);
   const [kind, setKind] = useState<Kind>("all");
@@ -382,6 +438,7 @@ export function LibraryPicker({ onPick, onPickKit, onCreateKit, fill = false }:
   const [dragging, setDragging] = useState(false); // a file is held over the drop area
   const [renaming, setRenaming] = useState<{ id: string; title: string; busy?: boolean } | null>(null);
   const [previewing, setPreviewing] = useState<PostableArtifact | null>(null); // the upload being looked at
+  const [audio, setAudio] = useState<PostableArtifact | null>(null); // an audio overview: offered to download, not posted
   const [deleting, setDeleting] = useState<PostableArtifact | null>(null); // the item in the delete pop-up
   const [deleteBusy, setDeleteBusy] = useState(false);
   const [deleteError, setDeleteError] = useState<string | null>(null);
@@ -441,7 +498,7 @@ export function LibraryPicker({ onPick, onPickKit, onCreateKit, fill = false }:
   const load = useCallback(() => launchpadApi.postable(q).then((list) => {
     setItems(list);
     return list;
-  }), [q]);
+  }), [q, refreshKey]); // eslint-disable-line react-hooks/exhaustive-deps
 
   useEffect(() => {
     const t = setTimeout(() => {
@@ -540,12 +597,18 @@ export function LibraryPicker({ onPick, onPickKit, onCreateKit, fill = false }:
         )}
         {items && shown.length === 0 && (
           <p className="muted lp-pick-empty">{kind === "kits" ? "No launch kits yet: create a new one."
-            : kind === "uploads" ? "Nothing uploaded yet." : "Nothing to attach here yet."}</p>
+            : kind === "uploads" ? "Nothing uploaded yet." : kind === "decks" ? "No slide decks yet: make one from a notebook."
+            : kind === "audio" ? "No audio overviews yet: make one from a notebook."
+            : "Nothing to attach here yet."}</p>
         )}
         <ul className={`lk-rows lp-pick-rows${fill ? " lp-pick-rows-fill" : ""}`}>
           {shown.map((a) => {
             const kit = a.type === "launch_kit";
-            const go = () => (a.needs_render || a.rendering ? setRendering(a) : kit && onPickKit ? onPickKit(a) : onPick(a));
+            // Already on the calendar (and this list offers it): open that post rather than start another one.
+            const next = onReschedule && !kit && a.media !== "audio" ? a.scheduled?.[0] : undefined;
+            const opening = openingId === a.id;
+            const go = () => opening ? undefined : (a.media === "audio" ? setAudio(a) : a.needs_render || a.rendering ? setRendering(a)
+              : next ? onReschedule!(a, next.id) : kit && onPickKit ? onPickKit(a) : onPick(a));
             if (renaming?.id === a.id) {
               return (
                 <li key={a.id}>
@@ -570,7 +633,7 @@ export function LibraryPicker({ onPick, onPickKit, onCreateKit, fill = false }:
             }
             return (
               <li key={a.id} className="lp-pick-item">
-                <button type="button" className="lk-row lp-pick-row" onClick={go}
+                <button type="button" className="lk-row lp-pick-row" onClick={go} aria-busy={opening}
                         title={a.rendering ? "Rendering: it can be scheduled once the MP4 is made"
                           : a.needs_render ? "Render it, then post it" : undefined}>
                   <Thumb a={a} />
@@ -578,22 +641,33 @@ export function LibraryPicker({ onPick, onPickKit, onCreateKit, fill = false }:
                     <strong>{a.title}</strong>
                     <span className="muted small">
                       {kit ? "LinkedIn post and hooks ready to schedule" : mediaLabel(a)}
-                      {a.created_at ? ` · ${formatDate(a.created_at)}` : ""}
+                      {next ? ` · Scheduled ${formatDate(next.scheduled_at, true)}${a.scheduled!.length > 1
+                        ? ` +${a.scheduled!.length - 1} more` : ""}` : a.created_at ? ` · ${formatDate(a.created_at)}` : ""}
                     </span>
                   </span>
-                  <span className={`lp-tag${a.media === "video" ? " video" : kit ? " kit" : ""}`}>
-                    {a.type === "upload" ? "Upload" : a.media === "video" ? "Video" : kit ? "Launch Kit" : a.type_label}
+                  <span className={`lp-tag${a.media === "video" ? " video" : kit ? " kit" : a.type === "slide_deck" ? " deck" : ""}`}>
+                    {a.type === "upload" ? "Upload" : a.media === "video" ? "Video" : a.media === "audio" ? "Audio" : kit ? "Launch Kit"
+                      : a.type_label}
                   </span>
                   <span className="lp-pick-go">
-                    {a.rendering ? (
+                    {opening ? (
+                      <><span className="vw-spin small" aria-hidden="true" /> Opening...</>
+                    ) : a.rendering ? (
                       <><span className="vw-spin small" aria-hidden="true" /> Rendering</>
                     ) : (
-                      <>{a.needs_render ? "Render it" : kit && onPickKit ? "Open kit" : "Schedule"} <ArrowRightIcon size={14} /></>
+                      <>{a.needs_render ? "Render it" : kit && onPickKit ? "Open kit" : next ? "Reschedule" : "Schedule"}
+                        {" "}<ArrowRightIcon size={14} /></>
                     )}
                   </span>
                 </button>
                 <RowMenu label={a.title} items={[
                   ...(a.view_url ? [{ label: "Preview", onSelect: () => setPreviewing(a) }] : []),
+                  ...(a.download_url ? [{ label: "Download", onSelect: () => download(a.download_url!) }] : []),
+                  ...(next && onDuplicate ? [{ label: "Duplicate schedule", onSelect: () => onDuplicate(a, next.id) }] : []),
+                  // Several posts of it coming up: each can be opened.
+                  ...(next && a.scheduled!.length > 1 ? a.scheduled!.map((sc) => ({
+                    label: `Edit schedule: ${formatDate(sc.scheduled_at, true)}`, onSelect: () => onReschedule!(a, sc.id),
+                  })) : []),
                   ...(a.type === "upload" ? [{ label: "Rename", onSelect: () => setRenaming({ id: a.id, title: a.title }) }] : []),
                   ...(kit ? [{ label: "Open kit", onSelect: () => (onPickKit ? onPickKit(a) : navigate(`/app/launchpad/kits/${a.id}`)) }]
                     : a.editable_video ? [{ label: "Open", onSelect: () => navigate(`/app/videos/${a.id}`) }] : []),
@@ -608,6 +682,7 @@ export function LibraryPicker({ onPick, onPickKit, onCreateKit, fill = false }:
         </ul>
         {rendering && <RenderVideoModal video={rendering} onClose={() => setRendering(null)} onRendered={rendered} />}
         {previewing && <MediaPreviewModal a={previewing} onClose={() => setPreviewing(null)} />}
+        {audio && <AudioOnlyModal title={audio.title} downloadUrl={audio.download_url} onClose={() => setAudio(null)} />}
         {deleting && (
           <Modal title={deleteWording(deleting).title} onClose={() => !deleteBusy && setDeleting(null)}>
             <div className="stack">

frontend/src/components/launchpad/PostButton.tsx

@@ -2,8 +2,9 @@ import { useState } from "react";
 import type { Artifact } from "../../api/types";
 import { ScheduleModal } from "../ScheduleModal";
 
-/** What can go out on X / LinkedIn: images, videos and text. Not audio (neither platform takes audio files). */
-const POSTABLE = new Set(["video", "quote_card", "carousel", "summary", "launch_kit", "mind_map"]);
+/** What can go out on X / LinkedIn: images (a slide deck's slides too), videos and text. Not audio (neither platform
+ * takes audio files). */
+const POSTABLE = new Set(["video", "quote_card", "carousel", "summary", "launch_kit", "mind_map", "slide_deck"]);
 
 export function canPost(a: Artifact): boolean {
   if (!POSTABLE.has(a.type)) return false;

frontend/src/components/slideDeckEdit.ts

@@ -0,0 +1,173 @@
+/** The slide deck editor's rules: what a slide can gain or lose, how it changes to another layout, and what must not be
+ * left empty. They mirror the server (backend/app/slides/content.py: LIMITS and clamp_slide), which coerces whatever
+ * comes back anyway; these only keep the editor from offering what the server would undo. */
+import type { EditSlide } from "../api/endpoints";
+
+export type DeckFmt = "detailed" | "presenter";
+
+/** The layouts a slide can have, in the order the editor lists them. */
+export const LAYOUTS: { id: string; name: string }[] = [
+  { id: "title", name: "Title" },
+  { id: "section", name: "Section" },
+  { id: "points", name: "Points" },
+  { id: "two_column", name: "Two columns" },
+  { id: "stat", name: "Big number" },
+  { id: "quote", name: "Quote" },
+  { id: "agenda", name: "Agenda" },
+  { id: "closing", name: "Closing" },
+];
+
+export const MAX_SLIDES = 30;
+
+const max = (fmt: DeckFmt) => ({ points: fmt === "presenter" ? 4 : 5, agenda: 14, takeaways: 3, items: 4 });
+
+const clone = (s: EditSlide): EditSlide => JSON.parse(JSON.stringify(s)) as EditSlide;
+
+/** A new slide of `layout`, with placeholder text to type over. */
+export function newSlide(layout: string, fmt: DeckFmt): EditSlide {
+  const blank: EditSlide = {
+    layout: "section", variant: "", kicker: "", heading: "New slide", lead: "", points: [],
+    left: { label: "", items: [] }, right: { label: "", items: [] }, stat: { value: "", label: "" },
+    quote: { text: "", by: "" }, takeaways: [], closing: "", notes: "", sources: [],
+  };
+  return convert(blank, layout, fmt);
+}
+
+/** The slide changed to another layout. Its words carry over (points become a column's items, a closing's
+ * takeaways...); what the new layout needs and the slide lacks is filled with placeholder text. The old layout's
+ * content stays in the slide, so changing back brings it back. */
+export function convert(s: EditSlide, layout: string, fmt: DeckFmt): EditSlide {
+  const out = { ...clone(s), layout, variant: "" };
+  const m = max(fmt);
+  const words = [...s.points.map((p) => p.text), ...s.takeaways, ...s.left.items, ...s.right.items].filter(Boolean);
+  const some = (n: number, fallback: string[]) => (words.length >= 2 ? words : fallback).slice(0, n);
+  if (layout === "points" && out.points.length < 2) {
+    out.points = some(m.points, ["First point", "Second point", "Third point"]).map((text) => ({ term: "", text }));
+  } else if (layout === "agenda" && out.points.length < 2) {
+    out.points = some(m.agenda, ["First topic", "Second topic", "Third topic"]).map((text) => ({ term: "", text }));
+  } else if (layout === "two_column" && !(out.left.items.length && out.right.items.length)) {
+    const items = some(2 * m.items, ["A point on this side", "Another point", "A point on that side", "Another point"]);
+    const half = Math.ceil(items.length / 2);
+    out.left = { label: out.left.label || "One side", items: items.slice(0, half).slice(0, m.items) };
+    out.right = { label: out.right.label || "The other side", items: items.slice(half).slice(0, m.items) };
+  } else if (layout === "stat" && !(out.stat.value && out.stat.label)) {
+    out.stat = { value: out.stat.value || "42%", label: out.stat.label || words[0] || "What this number means" };
+  } else if (layout === "quote" && !out.quote.text) {
+    out.quote = { text: words[0] || out.lead || "A line worth quoting.", by: out.quote.by };
+  } else if (layout === "closing" && !out.takeaways.length && !out.closing) {
+    out.takeaways = some(m.takeaways, ["First takeaway", "Second takeaway", "Third takeaway"]);
+  }
+  return out;
+}
+
+export type AddAction = { id: string; label: string; apply: (s: EditSlide) => EditSlide };
+
+/** The text boxes a slide can gain: only those its design has a place for (`slots`, from the server) and that it
+ * does not have yet, within the format's limits. */
+export function addActions(s: EditSlide, slots: string[], fmt: DeckFmt): AddAction[] {
+  const m = max(fmt);
+  const has = (slot: string) => slots.includes(slot);
+  const act = (id: string, label: string, change: (c: EditSlide) => void): AddAction => ({
+    id, label, apply: (from) => {
+      const c = clone(from);
+      change(c);
+      return c;
+    },
+  });
+  const out: AddAction[] = [];
+  if (has("kicker") && !s.kicker) out.push(act("kicker", "Kicker", (c) => (c.kicker = "Kicker")));
+  if (has("lead") && !s.lead) out.push(act("lead", "Subtitle", (c) => (c.lead = "A sentence that adds context.")));
+  if (s.layout === "points" && has("body") && s.points.length < m.points) {
+    out.push(act("point", "Bullet", (c) => c.points.push({ term: "", text: "New point" })));
+  }
+  if (s.layout === "agenda" && has("body") && s.points.length < m.agenda) {
+    out.push(act("point", "Topic", (c) => c.points.push({ term: "", text: "New topic" })));
+  }
+  if (s.layout === "two_column") {
+    for (const side of ["left", "right"] as const) {
+      const name = side === "left" ? "Left" : "Right";
+      if (!s[side].label) out.push(act(`${side}-label`, `${name} heading`, (c) => (c[side].label = "Heading")));
+      if (s[side].items.length < m.items) out.push(act(`${side}-item`, `${name} item`, (c) => c[side].items.push("New item")));
+    }
+  }
+  if (s.layout === "quote" && has("by") && !s.quote.by) out.push(act("by", "Author", (c) => (c.quote.by = "Name")));
+  if (s.layout === "closing") {
+    if (has("body") && s.takeaways.length < m.takeaways) out.push(act("takeaway", "Takeaway", (c) => c.takeaways.push("New takeaway")));
+    if (has("closing") && !s.closing) out.push(act("closing", "Closing line", (c) => (c.closing = "One line to end on.")));
+  }
+  return out;
+}
+
+/** The text boxes on a slide that can be removed (a point only while the slide keeps enough of them; the heading, a
+ * stat or a quote never: the layout needs them). Each is the `data-f` of the text drawn in that box. */
+export function removable(s: EditSlide): string[] {
+  const out: string[] = [];
+  if (s.kicker) out.push("kicker");
+  if (s.lead) out.push("lead");
+  if (s.quote.by) out.push("quote.by");
+  if (s.closing && s.takeaways.length) out.push("closing");
+  const minPoints = 2;
+  s.points.forEach((p, i) => {
+    if (p.term) out.push(`points.${i}.term`);
+    if (s.points.length > minPoints) out.push(`points.${i}.text`);
+  });
+  if (s.takeaways.length > 1 || s.closing) s.takeaways.forEach((_, i) => out.push(`takeaways.${i}`));
+  for (const side of ["left", "right"] as const) {
+    if (s[side].label) out.push(`${side}.label`);
+    if (s[side].items.length > 1) s[side].items.forEach((_, i) => out.push(`${side}.items.${i}`));
+  }
+  return out;
+}
+
+/** The slide without the text box at `field`: a point, takeaway or column item goes; other text is emptied. */
+export function removeField(s: EditSlide, field: string): EditSlide {
+  const c = clone(s);
+  const [a, b, d] = field.split(".");
+  if (a === "points" && d === "text") c.points.splice(Number(b), 1);
+  else if (a === "points" && d === "term") c.points[Number(b)].term = "";
+  else if (a === "takeaways") c.takeaways.splice(Number(b), 1);
+  else if ((a === "left" || a === "right") && b === "items") c[a].items.splice(Number(d), 1);
+  else if ((a === "left" || a === "right") && b === "label") c[a].label = "";
+  else if (a === "quote" && b === "by") c.quote.by = "";
+  else if (a === "kicker" || a === "lead" || a === "closing") c[a] = "";
+  return c;
+}
+
+/** The slide with the text at `field` ("points.2.text", "left.items.0", "heading") set to `text`. */
+export function setText(s: EditSlide, field: string, text: string): EditSlide {
+  const c = clone(s);
+  const path = field.split(".");
+  let at: Record<string, unknown> | unknown[] = c as unknown as Record<string, unknown>;
+  for (const k of path.slice(0, -1)) at = (at as Record<string, unknown>)[k] as Record<string, unknown>;
+  const last = path[path.length - 1];
+  if (Array.isArray(at)) at[Number(last)] = text;
+  else if (at && typeof at === "object") at[last] = text;
+  return c;
+}
+
+const blank = (t: string) => !t.replace(/\s+/g, "");
+
+/** What stops the deck from being saved as it is ("Slide 3: the heading can't be empty."), or null. */
+export function problem(slides: EditSlide[]): string | null {
+  for (const [i, s] of slides.entries()) {
+    const at = (what: string) => `Slide ${i + 1}: ${what} can't be empty.`;
+    if (blank(s.heading) && s.layout !== "quote" && s.layout !== "closing") return at("the heading");
+    if (s.layout === "points" || s.layout === "agenda") {
+      const n = s.points.findIndex((p) => blank(p.text));
+      if (n >= 0) return at(`${s.layout === "agenda" ? "topic" : "point"} ${n + 1}`);
+    }
+    if (s.layout === "two_column") {
+      for (const side of ["left", "right"] as const) {
+        const n = s[side].items.findIndex(blank);
+        if (n >= 0) return at(`the ${side} column's item ${n + 1}`);
+      }
+    }
+    if (s.layout === "stat" && (blank(s.stat.value) || blank(s.stat.label))) return at(blank(s.stat.value) ? "the number" : "the number's label");
+    if (s.layout === "quote" && blank(s.quote.text)) return at("the quote");
+    if (s.layout === "closing") {
+      const n = s.takeaways.findIndex(blank);
+      if (n >= 0) return at(`takeaway ${n + 1}`);
+    }
+  }
+  return null;
+}

frontend/src/components/ui.tsx

@@ -69,17 +69,21 @@ export function Modal({
   actions?: ReactNode;
 }) {
   const ref = useRef<HTMLDivElement>(null);
+  // The latest onClose, so a parent passing a new function each render neither re-binds Escape nor (worse) pulls focus
+  // back to the dialog, away from whatever is being typed in.
+  const close = useRef(onClose);
+  close.current = onClose;
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
       if (e.key !== "Escape") return;
       // A modal opened from a modal (a picker over the composer): Escape closes only the top one.
       const open = document.querySelectorAll(".modal-backdrop");
-      if (open[open.length - 1] === ref.current?.parentElement) onClose();
+      if (open[open.length - 1] === ref.current?.parentElement) close.current();
     };
     document.addEventListener("keydown", onKey);
-    ref.current?.focus();
+    ref.current?.focus(); // once, on opening
     return () => document.removeEventListener("keydown", onKey);
-  }, [onClose]);
+  }, []);
   // Rendered into <body>: a parent with backdrop-filter or transform (cards have one) would otherwise become the
   // containing block of this fixed backdrop and trap the modal inside that card.
   return createPortal(
@@ -171,6 +175,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/Archive.tsx

@@ -1,17 +1,18 @@
-import { useCallback, useEffect, useState } from "react";
-import { Link, useSearchParams } from "react-router-dom";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Link, Navigate, useSearchParams } from "react-router-dom";
 import { artifactsApi } from "../api/endpoints";
 import type { Artifact } from "../api/types";
 import { ArtifactRow } from "../components/ArtifactRow";
 import { Reader } from "../components/Reader";
 import { EmptyState, Loading, PageHeader, Tabs } from "../components/ui";
 import Videos from "./Videos";
-import VoiceProfile from "./VoiceProfile";
 import { canPost, PostButton } from "../components/launchpad/PostButton";
+import { AudioOnlyModal } from "../components/launchpad/Attachment";
 
-type Filter = "all" | "report" | "summary" | "quiz" | "flashcards" | "mind_map" | "infographic";
-/** The Library's tabs: kinds of things made (a filter on one list), plus your videos and your voices (their own pages). */
-type Tab = Filter | "videos" | "voices";
+type Filter = "all" | "report" | "summary" | "quiz" | "flashcards" | "mind_map" | "infographic" | "slide_deck" | "audio_overview";
+/** The Library's tabs: kinds of things made (a filter on one list), plus your videos (their own page). Voices moved to
+ * the sidebar (Manage voices, /app/voices); an old ?tab=voices link goes there. */
+type Tab = Filter | "videos";
 const TABS: { id: Tab; label: string }[] = [
   { id: "all", label: "All" },
   { id: "report", label: "Reports" },
@@ -20,13 +21,15 @@ const TABS: { id: Tab; label: string }[] = [
   { id: "flashcards", label: "Flashcards" },
   { id: "mind_map", label: "Mind Constellations" },
   { id: "infographic", label: "Infographics" },
+  { id: "slide_deck", label: "Slide decks" },
+  { id: "audio_overview", label: "Audio overviews" },
   { id: "videos", label: "Videos" },
-  { id: "voices", label: "Voices" },
 ];
 const PAGE = 30;
 
 export default function Archive() {
   const [params, setParams] = useSearchParams();
+  if (params.get("tab") === "voices") return <Navigate to="/app/voices" replace />;
   const tab: Tab = TABS.find((t) => t.id === params.get("tab"))?.id ?? "all";
   // The tab lives in the URL (?tab=videos), so the sidebar, redirects and Back land on it.
   const pickTab = (t: Tab) => setParams(t === "all" ? {} : { tab: t });
@@ -35,11 +38,22 @@ export default function Archive() {
     <div className="page-wrap">
       <PageHeader eyebrow="Library" title="Everything you have made" />
       <Tabs<Tab> tabs={TABS} value={tab} onChange={pickTab} />
-      {tab === "videos" ? <Videos /> : tab === "voices" ? <VoiceProfile /> : <MadeList filter={tab} />}
+      {tab === "videos" ? <Videos /> : <MadeList filter={tab} />}
     </div>
   );
 }
 
+/** "Post" on an audio overview: X and LinkedIn take no audio files, so it explains that and offers the download. */
+function AudioPostButton({ artifact }: { artifact: Artifact }) {
+  const [open, setOpen] = useState(false);
+  return (
+    <>
+      <button type="button" className="btn btn-small" onClick={() => setOpen(true)}>Post</button>
+      {open && <AudioOnlyModal title={artifact.title} downloadUrl={artifact.download_url} onClose={() => setOpen(false)} />}
+    </>
+  );
+}
+
 /** What was made, of one kind (or all), searchable. */
 function MadeList({ filter }: { filter: Filter }) {
   const [q, setQ] = useState("");
@@ -48,19 +62,31 @@ function MadeList({ filter }: { filter: Filter }) {
   const [failed, setFailed] = useState(false);
   const [reading, setReading] = useState<{ id: string; start: number; end: number } | null>(null);
 
+  // The tab and search the list is showing: an answer for any other (a tab just left) is dropped when it arrives late.
+  const showing = useRef("");
+  showing.current = `${filter}|${q}`;
   const load = useCallback(
-    (offset = 0) =>
-      artifactsApi
+    (offset = 0) => {
+      const asked = `${filter}|${q}`;
+      return artifactsApi
         .list({ type: filter === "all" ? undefined : filter, q, limit: PAGE, offset })
         .then((p) => {
+          if (showing.current !== asked) return;
           setFailed(false);
           setTotal(p.total);
           setItems((cur) => (offset ? [...(cur ?? []), ...p.items] : p.items));
         })
-        .catch(() => setFailed(true)),
+        .catch(() => showing.current === asked && setFailed(true));
+    },
     [filter, q],
   );
 
+  // Another tab: the loader until its items are fetched, never the last tab's items meanwhile.
+  useEffect(() => {
+    setItems(null);
+    setFailed(false);
+  }, [filter]);
+
   useEffect(() => {
     const t = setTimeout(() => load(0), 200);
     return () => clearTimeout(t);
@@ -76,7 +102,7 @@ function MadeList({ filter }: { filter: Filter }) {
         <EmptyState title="Could not load your library" body="Something went wrong reaching the server."
                     action={<button className="btn btn-primary" onClick={() => load(0)}>Try again</button>} />
       )}
-      {items?.length === 0 && <EmptyState title="Nothing here yet" body="Reports, summaries, quizzes, flashcards, Mind Constellations, audio and more that you create show up here."
+      {items?.length === 0 && <EmptyState title="Nothing here yet" body="Reports, summaries, quizzes, flashcards, Mind Constellations, slide decks, audio and more that you create show up here."
           action={
             <Link className="btn btn-primary" to="/app/studio">
               Create something
@@ -88,7 +114,8 @@ function MadeList({ filter }: { filter: Filter }) {
           <ArtifactRow
             key={a.id}
             artifact={a}
-            actions={(art) => (canPost(art) ? <PostButton artifactId={art.id} /> : null)}
+            actions={(art) => (canPost(art) ? <PostButton artifactId={art.id} />
+              : art.type === "audio_overview" && art.status === "ready" ? <AudioPostButton artifact={art} /> : null)}
             onCite={(c) => c.document_id && setReading({ id: c.document_id, start: c.line_start, end: c.line_end })}
             onRemoved={(id) => {
               setItems((list) => (list ?? []).filter((x) => x.id !== id));

frontend/src/pages/Launchpad.tsx

@@ -52,8 +52,10 @@ function ItemModal({
   const locked = item.status === "posted" || item.status === "publishing";
   const options = (accounts?.accounts ?? []).filter((a) => a.platform === item.platform);
 
+  // Not on the calendar to go out (a draft, failed, reminded or paused post): Save puts it back, at the time shown.
+  const reschedules = item.status !== "scheduled";
   const save = async () => {
-    if (moved && wallToDate(when) <= new Date()) return setError("Pick a time that is still ahead.");
+    if ((moved || reschedules) && wallToDate(when) <= new Date()) return setError("Pick a time that is still ahead.");
     setBusy(true);
     setError(null);
     try {
@@ -62,7 +64,8 @@ function ItemModal({
         await launchpadApi.update(item.id, {
           content: clean[0],
           thread: clean.slice(1),
-          ...(moved ? { local_time: when, timezone: userTimeZone() } : {}),
+          ...(moved || reschedules ? { local_time: when, timezone: userTimeZone() } : {}),
+          ...(reschedules ? { status: "scheduled" as const } : {}),
           social_account_id: accountId || null,
           ...((attached?.id ?? null) !== item.artifact_id ? { artifact_id: attached?.id ?? null } : {}),
         }),
@@ -143,7 +146,7 @@ function ItemModal({
           </label>
         ))}
         {!locked && (
-          <div className="row">
+          <div className="lp-edit-when">
             <div className="field">
               <span>When</span>
               <SlotPicker value={when} onChange={setWhen} />
@@ -164,7 +167,7 @@ function ItemModal({
           </div>
         )}
         {error && <p className="error-text">{error}</p>}
-        <div className="row between">
+        <div className="row between lp-edit-actions">
           <div className="row">
             <CopyButton text={posts.join("\n\n")} />
             <ConfirmButton
@@ -201,8 +204,9 @@ function ItemModal({
               >
                 {item.auto_post ? "Publish now" : "Send reminder now"}
               </button>
-              <button className="btn btn-primary" disabled={busy} onClick={save}>
-                Save
+              <button className="btn btn-primary" disabled={busy} onClick={save}
+                      title={reschedules ? "Save it and put it back on the calendar at this time" : undefined}>
+                {reschedules ? "Reschedule" : "Save"}
               </button>
             </div>
           )}
@@ -408,7 +412,6 @@ export default function Launchpad() {
         </button>
       </PageHeader>
       {notice && <p className="notice">{notice}</p>}
-      {publishing && <p className="notice">Publishing... uploading a video can take a few minutes.</p>}
       {error && <p className="error-text">{error}</p>}
 
 
@@ -478,7 +481,14 @@ export default function Launchpad() {
             {items.length === 0 && <li className="muted">Nothing scheduled. Quiet moon tonight.</li>}
           </ul>
         )}
-        {items && <p className="mono muted small">{upcoming.length} upcoming in view</p>}
+        {items && (
+          <div className="lp-cal-foot">
+            <p className="mono muted small">{upcoming.length} upcoming in view</p>
+            <p className="muted small lp-cal-hint">
+              Click a post on the calendar to edit it: change its words or time, reschedule it, or publish it now.
+            </p>
+          </div>
+        )}
       </section>
 
         <ConnectionsPanel accounts={accounts} onConnect={connect} onChanged={async () => {
@@ -495,22 +505,75 @@ export default function Launchpad() {
 
 /** /app/launchpad/new: what to launch. Something from the Library opens the composer with it attached; Create a
  * launch kit goes to the kit pages (and is scheduled from the kit). */
+/** Schedule a launch: pick something from the Library to post. Something already scheduled says Reschedule and opens
+ * that post (the calendar's editor), and its menu can schedule it once more, starting from a copy of that post. */
 export function ScheduleLaunch() {
   const navigate = useNavigate();
   const [picked, setPicked] = useState<PostableArtifact | null>(null);
+  // A post already on the calendar: opened to edit (rescheduled), or copied into a new one (a duplicate schedule).
+  const [editing, setEditing] = useState<CalendarItem | null>(null);
+  const [copying, setCopying] = useState<{ a: PostableArtifact; item: CalendarItem } | null>(null);
+  const [accounts, setAccounts] = useState<SocialAccounts | null>(null);
+  const [refreshKey, setRefreshKey] = useState(0);
+  const [error, setError] = useState<string | null>(null);
+  const [openingId, setOpeningId] = useState<string | null>(null); // the row whose post is loading
+  // The accounts the editor needs, loaded once with the page rather than on every click.
+  useEffect(() => {
+    launchpadApi.accounts().then(setAccounts, () => undefined);
+  }, []);
+  const scheduledItem = async (artifactId: string, id: string) => {
+    setError(null);
+    setOpeningId(artifactId);
+    try {
+      const [all, acc] = await Promise.all([launchpadApi.items({ status: "scheduled" }),
+                                            accounts ? Promise.resolve(accounts) : launchpadApi.accounts()]);
+      setAccounts(acc);
+      const found = all.find((i) => i.id === id);
+      if (!found) {
+        setError("That post isn't scheduled anymore.");
+        setRefreshKey((k) => k + 1);
+      }
+      return found ?? null;
+    } catch (e) {
+      setError(errorMessage(e));
+      return null;
+    } finally {
+      setOpeningId(null);
+    }
+  };
   return (
     <div className="page-wrap">
       <BackArrow fallback="/app/launchpad" />
       <PageHeader eyebrow="Launchpad" title="Schedule a launch" />
+      {error && <p className="error-text">{error}</p>}
       <section className="card">
         <LibraryPicker fill onPick={setPicked} onPickKit={(k) => navigate(`/app/launchpad/kits/${k.id}`)}
-                       onCreateKit={() => navigate("/app/launchpad/kits")} />
+                       onCreateKit={() => navigate("/app/launchpad/kits")} refreshKey={refreshKey} openingId={openingId}
+                       onReschedule={async (a, id) => setEditing(await scheduledItem(a.id, id))}
+                       onDuplicate={async (a, id) => {
+                         const item = await scheduledItem(a.id, id);
+                         if (item) setCopying({ a, item });
+                       }} />
       </section>
       {picked && (
         <ScheduleModal platform="linkedin" posts={[]} artifact={picked} artifactId={picked.id}
                        onClose={() => setPicked(null)}
                        onScheduled={() => navigate("/app/launchpad")} />
       )}
+      {copying && (
+        <ScheduleModal platform={copying.item.platform} posts={[copying.item.content, ...copying.item.thread]}
+                       artifact={copying.a} artifactId={copying.a.id}
+                       onClose={() => setCopying(null)}
+                       onScheduled={() => {
+                         setCopying(null);
+                         setRefreshKey((k) => k + 1);
+                       }} />
+      )}
+      {editing && (
+        <ItemModal item={editing} accounts={accounts} onClose={() => setEditing(null)}
+                   onChanged={() => setRefreshKey((k) => k + 1)}
+                   onReconnect={() => navigate("/app/launchpad")} />
+      )}
     </div>
   );
 }

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/pages/VideoCreate.tsx

@@ -465,7 +465,7 @@ export function VideoCreateForm({ startNotebook = null, startDoc = null, inModal
               {voices === null ? (
                 <Loading label="Loading voices" />
               ) : saved.length === 0 ? (
-                <p className="muted">No voices yet. Add some on the <Link to="/app/archive?tab=voices">Voices</Link> tab of your Library.</p>
+                <p className="muted">No voices yet. Add some in <Link to="/app/voices">Manage voices</Link>.</p>
               ) : (
                 <div className="vw-voice-list vw-voice-list-compact" role="radiogroup" aria-label="Narration voice">
                   {saved.map((v) => {

frontend/src/pages/VoiceProfile.tsx

@@ -1,21 +1,11 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { useSearchParams } from "react-router-dom";
 import { voiceApi } from "../api/endpoints";
-import type { Job, VoiceDesignInput, VoiceDesignPreview, VoiceProfileData, VoiceState } from "../api/types";
-import { DocPicker } from "../components/DocPicker";
+import type { Job, VoiceDesignInput, VoiceDesignPreview, VoiceState } from "../api/types";
 import { YourVoices } from "../components/voice/YourVoices";
-import { ConfirmButton, errorMessage, formatDate, JobProgress, Loading, Modal, Tabs } from "../components/ui";
+import { ConfirmButton, errorMessage, JobProgress, Loading, Modal, Tabs } from "../components/ui";
 import { useJob } from "../hooks/useJob";
 import { useUpgrade } from "../hooks/useUpgrade";
 
-const LIST_FIELDS: { key: keyof VoiceProfileData; label: string; hint: string }[] = [
-  { key: "tone", label: "Tone", hint: "warm, wry, direct" },
-  { key: "vocabulary", label: "Signature words and phrases", hint: "readers, the long game" },
-  { key: "structure_habits", label: "Structure habits", hint: "short paragraphs, one idea each" },
-  { key: "openings", label: "How pieces open", hint: "a number, a small scene" },
-  { key: "avoid", label: "Never does", hint: "jargon, hashtags" },
-];
-
 /** Plays one URL at a time across the page. */
 function usePlayer() {
   const audio = useRef<HTMLAudioElement | null>(null);
@@ -416,216 +406,79 @@ function CloneModal({ state, onClose, onDone }: { state: VoiceState; onClose: ()
   );
 }
 
-// The page: two steps. The writing voice builds itself, then the writer picks the two hosts.
-// Cloning lives in the "+ Add a voice" menu; a clone's status shows under the voice cards.
-
-type Step = "writing" | "hosts";
-
-/** The underlined link between the two views (Speaking voices <-> Writing voice), its arrow pointing the way. */
-function ViewLink({ to, label, onGo }: { to: Step; label: string; onGo: (s: Step) => void }) {
-  const back = to === "hosts";
-  return (
-    <button type="button" className={`vp-switch${back ? " back" : ""}`} onClick={() => onGo(to)}>
-      {back && <span aria-hidden="true">←</span>}
-      <span className="vp-switch-text">{label}</span>
-      {!back && <span aria-hidden="true">→</span>}
-    </button>
-  );
-}
+// The page: the speaking voices (who reads audio and video aloud). Cloning lives in the "+ Add a voice" menu; a
+// clone's status shows under the voice cards. The writing voice is built by the server on import and not shown here.
 
 export default function VoiceProfile() {
   const [state, setState] = useState<VoiceState | null>(null);
-  const [draft, setDraft] = useState<VoiceProfileData | null>(null);
-  const [params] = useSearchParams();
-  // Opens on Speaking voices; ?step=writing opens the writing voice (links between the two switch views).
-  const [step, setStep] = useState<Step>(params.get("step") === "writing" ? "writing" : "hosts");
-  const [picking, setPicking] = useState(false);
-  const [samples, setSamples] = useState<string[]>([]);
-  const [buildJob, setBuildJob] = useState<Job | null>(null);
   const [cloneJob, setCloneJob] = useState<Job | null>(null);
   const [cloning, setCloning] = useState(false);
   const [adding, setAdding] = useState(false); // the Add voices modal
   const [voicesKey, setVoicesKey] = useState(0); // bumped when a voice was made, so Your voices reloads
   const { openUpgrade } = useUpgrade();
-  const [saved, setSaved] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const autoBuilt = useRef(false);
   const { play, playing } = usePlayer();
 
-  const load = () =>
-    voiceApi.get().then((s) => {
-      setState(s);
-      setDraft(s.profile);
-      setSamples(s.sample_doc_ids);
-      return s;
-    });
+  const load = () => voiceApi.get().then(setState, (e) => setError(errorMessage(e)));
   const loadVoices = () => setVoicesKey((k) => k + 1);
 
-  const startBuild = async (ids: string[]) => {
-    setPicking(false);
-    setError(null);
-    try {
-      setBuildJob(await voiceApi.build(ids));
-    } catch (e) {
-      setError(errorMessage(e));
-    }
-  };
-
   useEffect(() => {
-    // No writing voice yet: build one from the longest posts straight away instead of asking.
-    load().then((s) => {
-      if (!s.profile && !autoBuilt.current) {
-        autoBuilt.current = true;
-        void startBuild([]);
-      }
-    });
+    void load();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  const build = useJob(buildJob, () => load());
   const clone = useJob(cloneJob, () => {
     load();
     loadVoices(); // a finished clone is saved to Your voices as "My voice"
   });
 
   if (!state) return <div className="loading-center"><Loading label="Loading your voice" /></div>;
-  const building = build && (build.status === "queued" || build.status === "running");
   const cloneRunning = clone && (clone.status === "queued" || clone.status === "running");
   const showClone = state.clone.status !== "none" || Boolean(clone);
 
-  const saveProfile = async () => {
-    setError(null);
-    try {
-      setState(await voiceApi.update({ profile: draft! }));
-      setSaved(true);
-      setTimeout(() => setSaved(false), 1500);
-    } catch (e) {
-      setError(errorMessage(e));
-    }
-  };
-
   return (
-    // The Library's Voices tab: speaking voices, and the writing voice behind a link.
+    // Manage voices (/app/voices): the speaking voices.
     <div className="stack vp">
-
-      <div className="vp-switch-row">
-        {step === "hosts"
-          ? <ViewLink to="writing" label="Writing voice" onGo={setStep} />
-          : <ViewLink to="hosts" label="Speaking voices" onGo={setStep} />}
-      </div>
       {error && <p className="error-text">{error}</p>}
 
-      {step === "writing" && (
-        <section className="card stack vp-card">
-          <h2>How you write</h2>
-          <p className="muted">Launch Kits, carousels, hooks and scripts are all written in this voice, so they read like you wrote them.</p>
-          {build && (building || build.status === "failed") && <JobProgress job={build} />}
-          {!draft && !building && (
+      <section className="card stack vp-card">
+        <h2>Who reads your work aloud</h2>
+        {!state.tts_configured && <p className="muted">Voice previews are unavailable right now.</p>}
+        <YourVoices reloadKey={voicesKey} onAdd={() => setAdding(true)} />
+
+        {showClone && (
+          <div className="vp-clone">
+            <strong>Your cloned voice</strong>
+            {clone && (cloneRunning || clone.status === "failed") && <JobProgress job={clone} compact />}
+            {state.clone.status === "processing" && !clone && <p className="muted small">Your voice is being created. It joins your voices when ready.</p>}
+            {state.clone.status === "failed" && state.clone.error && !cloneRunning && <p className="error-text">{state.clone.error}</p>}
             <div className="row">
-              <button className="btn btn-primary" onClick={() => startBuild([])}>
-                Build my writing voice
-              </button>
-              <button className="link-btn small" onClick={() => setPicking(true)}>
-                or pick the posts yourself
-              </button>
-            </div>
-          )}
-
-          {draft && (
-            <>
-              <label className="field">
-                <span>In a sentence, you sound like this</span>
-                <textarea className="textarea" rows={7} value={draft.summary} onChange={(e) => setDraft({ ...draft, summary: e.target.value })} />
-              </label>
-              <details className="delivery">
-                <summary className="mono muted small">Fine-tune tone, phrases and habits</summary>
-                <label className="field">
-                  <span>Sentence length</span>
-                  <select className="input input-sm" value={draft.sentence_length} onChange={(e) => setDraft({ ...draft, sentence_length: e.target.value as VoiceProfileData["sentence_length"] })}>
-                    {["short", "medium", "long", "varied"].map((v) => (
-                      <option key={v}>{v}</option>
-                    ))}
-                  </select>
-                </label>
-                {LIST_FIELDS.map((f) => (
-                  <label key={f.key} className="field">
-                    <span>{f.label}</span>
-                    <input
-                      className="input input-sm"
-                      placeholder={f.hint}
-                      value={(draft[f.key] as string[]).join(", ")}
-                      onChange={(e) => setDraft({ ...draft, [f.key]: e.target.value.split(",").map((x) => x.trim()).filter(Boolean) })}
-                    />
-                  </label>
-                ))}
-              </details>
-              <p className="mono muted small">
-                Built {formatDate(state.updated_at, true)} from {state.sample_doc_ids.length} posts ·{" "}
-                <button className="link-btn small" disabled={Boolean(building)} onClick={() => setPicking(true)}>
-                  Rebuild from other posts
+              {state.clone.status === "ready" && state.clone.preview_url && (
+                <button className="btn btn-small" onClick={() => play(state.clone.preview_url!, "clone")}>
+                  {playing === "clone" ? "Stop" : "Hear my voice"}
                 </button>
-              </p>
-              <div className="row end">
-                <button className="btn btn-small" onClick={saveProfile}>
-                  {saved ? "Saved" : "Save changes"}
+              )}
+              {!cloneRunning && state.clone.allowed && (
+                <button className="btn btn-small" onClick={() => setCloning(true)}>
+                  {state.clone.status === "failed" ? "Try again" : "Record again"}
                 </button>
-              </div>
-            </>
-          )}
-        </section>
-      )}
-
-      {step === "hosts" && (
-        <section className="card stack vp-card">
-          <h2>Who reads your work aloud</h2>
-          {!state.tts_configured && <p className="muted">Voice previews are unavailable right now.</p>}
-          <YourVoices reloadKey={voicesKey} onAdd={() => setAdding(true)} />
-
-          {showClone && (
-            <div className="vp-clone">
-              <strong>Your cloned voice</strong>
-              {clone && (cloneRunning || clone.status === "failed") && <JobProgress job={clone} compact />}
-              {state.clone.status === "processing" && !clone && <p className="muted small">Your voice is being created. It joins your voices when ready.</p>}
-              {state.clone.status === "failed" && state.clone.error && !cloneRunning && <p className="error-text">{state.clone.error}</p>}
-              <div className="row">
-                {state.clone.status === "ready" && state.clone.preview_url && (
-                  <button className="btn btn-small" onClick={() => play(state.clone.preview_url!, "clone")}>
-                    {playing === "clone" ? "Stop" : "Hear my voice"}
-                  </button>
-                )}
-                {!cloneRunning && state.clone.allowed && (
-                  <button className="btn btn-small" onClick={() => setCloning(true)}>
-                    {state.clone.status === "failed" ? "Try again" : "Record again"}
-                  </button>
-                )}
-                {state.clone.status !== "none" && (
-                  <ConfirmButton
-                    confirmLabel="Revoke and delete my voice?"
-                    onConfirm={async () => {
-                      setState(await voiceApi.revoke());
-                      loadVoices();
-                    }}
-                  >
-                    Revoke consent
-                  </ConfirmButton>
-                )}
-              </div>
+              )}
+              {state.clone.status !== "none" && (
+                <ConfirmButton
+                  confirmLabel="Revoke and delete my voice?"
+                  onConfirm={async () => {
+                    setState(await voiceApi.revoke());
+                    loadVoices();
+                  }}
+                >
+                  Revoke consent
+                </ConfirmButton>
+              )}
             </div>
-          )}
-        </section>
-      )}
-
-      {picking && (
-        <Modal title="Pick 5 to 10 posts that sound most like you" onClose={() => setPicking(false)} wide>
-          <DocPicker selected={samples} onChange={setSamples} max={10} />
-          <p className="muted small">Leave empty to let Notestack pick your longest posts.</p>
-          <div className="row end">
-            <button className="btn btn-primary" onClick={() => startBuild(samples)}>
-              Build profile
-            </button>
           </div>
-        </Modal>
-      )}
+        )}
+      </section>
+
       {cloning && <CloneModal state={state} onClose={() => setCloning(false)} onDone={setCloneJob} />}
       {adding && (
         <Modal title="Add voices" onClose={() => setAdding(false)} wide>

frontend/src/pages/Voices.tsx

@@ -0,0 +1,12 @@
+import { PageHeader } from "../components/ui";
+import VoiceProfile from "./VoiceProfile";
+
+/** Manage voices (in the sidebar): the speaking voices for audio and video, and the writing voice. */
+export default function Voices() {
+  return (
+    <div className="page-wrap">
+      <PageHeader eyebrow="Voices" title="Manage voices" />
+      <VoiceProfile />
+    </div>
+  );
+}

frontend/src/styles/pages.css

@@ -2277,54 +2277,6 @@ select.input option {
   animation: welcome-in 0.35s ease both;
 }
 
-/* The link between the two views (Speaking voices / Writing voice): underlined text and an arrow */
-.vp-switch-row {
-  display: flex;
-  justify-content: flex-end; /* at the right end */
-  margin: -6px 0 4px;
-}
-
-.vp-switch {
-  display: inline-flex;
-  align-items: center;
-  gap: 8px;
-  padding: 4px 0;
-  border: 0;
-  background: none;
-  color: var(--text-2);
-  font: inherit;
-  font-size: 0.95rem;
-  cursor: pointer;
-  transition: color 0.15s;
-}
-
-.vp-switch-text {
-  text-decoration: underline;
-  text-decoration-color: var(--line-strong);
-  text-underline-offset: 4px;
-  transition: text-decoration-color 0.15s;
-}
-
-.vp-switch:hover {
-  color: var(--text);
-}
-
-.vp-switch:hover .vp-switch-text {
-  text-decoration-color: var(--blue);
-}
-
-.vp-switch > span[aria-hidden] {
-  transition: transform 0.15s;
-}
-
-.vp-switch:hover > span[aria-hidden] {
-  transform: translateX(3px);
-}
-
-.vp-switch.back:hover > span[aria-hidden] {
-  transform: translateX(-3px);
-}
-
 .voice-grid {
   list-style: none;
   margin: 0;
@@ -3415,7 +3367,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 +3436,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";
   }
 
@@ -4402,6 +4355,87 @@ select.input,
   color: var(--white);
 }
 
+/* Under the calendar: how many posts are coming up, and how to change one */
+.lp-cal-foot {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 6px 16px;
+}
+
+.lp-cal-foot p {
+  margin: 0;
+}
+
+.lp-cal-hint {
+  color: var(--text-2);
+}
+
+/* Editing a scheduled post: When and Account side by side, their labels and boxes on one line (the time zone note
+   sits under When without pushing Account down), and the actions on their own line below a rule */
+.lp-edit-when {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  align-items: start;
+  gap: 16px;
+}
+
+.lp-edit-when .field {
+  margin: 0;
+}
+
+.lp-edit-when select.input {
+  width: 100%;
+}
+
+@media (max-width: 640px) {
+  .lp-edit-when {
+    grid-template-columns: minmax(0, 1fr);
+  }
+}
+
+.lp-edit-actions {
+  flex-wrap: wrap;
+  gap: 12px;
+  margin-top: 4px;
+  padding-top: 16px;
+  border-top: 1px solid var(--line);
+}
+
+/* "Audio can't be posted": the headphones, why, and the download */
+.lp-audio-only {
+  max-width: 460px;
+}
+
+.lp-audio-only p {
+  margin: 0;
+  line-height: 1.6;
+}
+
+.lp-audio-only-icon {
+  display: grid;
+  place-items: center;
+  width: 52px;
+  height: 52px;
+  border-radius: 50%;
+  background: var(--blue-10);
+  color: var(--blue);
+}
+
+.lp-audio-only-actions {
+  justify-content: flex-end;
+  align-items: center;
+  gap: 10px;
+}
+
+/* A slide deck: outlined like a video, dashed (its slides go out as images) */
+.lp-tag.deck {
+  border-color: var(--blue-35);
+  border-style: dashed;
+  color: var(--white);
+}
+
 .lp-pick-go {
   display: inline-flex;
   flex: none;
@@ -4612,52 +4646,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 +7547,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 +8208,1074 @@ 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;
+}
+
+/* In edit mode the slide's text is edited in place, so the frame takes the mouse */
+.sd-frame-edit iframe {
+  pointer-events: auto;
+}
+
+/* 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);
+}
+
+/* Edit mode: the slide's text boxes are clicked into, so no pointer; the slide being typed in is lit */
+.sd-slide-editing {
+  cursor: default;
+}
+
+.sd-slide-editing:focus-within {
+  border-color: var(--blue);
+  box-shadow: var(--glow-sm);
+}
+
+.sd-save {
+  height: 36px;
+  margin-right: 6px;
+  padding: 0 18px;
+}
+
+.sd-edit-hint {
+  color: var(--text-2);
+}
+
+.sd-edit-error {
+  margin: -4px 0 10px;
+}
+
+/* Edit mode: each slide's controls above it (layout, text boxes to add, move, duplicate, delete) */
+.sd-tools {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+  margin-bottom: 8px;
+}
+
+.sd-tools-no {
+  margin-right: 4px;
+  color: var(--text-2);
+  font-size: 0.8125rem;
+  font-weight: 600;
+}
+
+.sd-tools-layout select,
+.sd-add-slide select {
+  width: auto;
+  height: 32px;
+  padding: 0 30px 0 12px;
+  font-size: 0.8125rem;
+}
+
+.sd-tool {
+  height: 32px;
+  padding: 0 12px;
+  border: 1px dashed var(--line-strong);
+  border-radius: 999px;
+  background: transparent;
+  color: var(--text);
+  font: 600 0.8125rem var(--font-body);
+  cursor: pointer;
+}
+
+.sd-tool:hover:not(:disabled) {
+  border-color: var(--blue);
+  background: var(--surface-2);
+}
+
+.sd-tool:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+.sd-tools-gap {
+  flex: 1;
+}
+
+.sd-tool-icon {
+  width: 32px;
+  height: 32px;
+}
+
+.sd-tool-danger:hover:not(:disabled) {
+  color: #ff8a8a;
+}
+
+/* Between two slides in edit mode: a divider line with "+ Add slide here" on it */
+.sd-add-slide {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  margin: 20px 0 12px;
+}
+
+.sd-add-slide::before,
+.sd-add-slide::after {
+  content: "";
+  flex: 1;
+  height: 1px;
+  background: var(--line-strong);
+}
+
+.sd-add-slide select {
+  border-style: dashed;
+}
+
+/* The server is drawing the slides again: they wait, not taking clicks */
+.sd-stack.sd-busy .sd-slide {
+  opacity: 0.6;
+  pointer-events: none;
+  transition: opacity 0.15s;
+}
+
+.sd-notes-edit {
+  min-height: 84px;
+  resize: vertical;
+  line-height: 1.6;
+}
+
+.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;
+  }
+}