From d3659655ff0d27cf9ef85952eae0ab81e88dcf64 Mon Sep 17 00:00:00 2001
From: Brandon Thomas <echelon@gmail.com>
Date: Mon, 12 Oct 2026 23:44:57 -0400
Subject: [PATCH] UI: the File tab (Backstage) like PowerPoint's (#76)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

File (first ribbon tab) or Alt+F opens a full-window view in place of the
ribbon, slides and status bar: a side menu (Back, Home, New, Open, Info,
Save, Save As, Print, Export, Close; Account and Options at the bottom)
and the chosen page. Esc or Back returns; Up/Down walk the side menu and
show each page as it gets the focus; Enter runs Save/Close/Options.
Laid out after PowerPoint for Windows as observed: 160-pt menu a step
darker than the page, outline icons, current page in the accent colour.

The start screen is now File › Home (as in PowerPoint), with only Home,
New and Open at the top and no Back. Pages call existing commands and
file helpers: file.new {theme} and the sample deck (Home, New); recent
files with search, Browse and Recover Unsaved (Open); file.info and
file.properties, Accessibility Checker, Revert (Info); file.save /
file.saveAs / file.export by type (Save, Save As); a PDF with the Print
page's slides, layout (full page, notes, handouts 1-9), hidden slides and
frames, opened in the system viewer or downloaded on the web, with a
page preview (Print, Ctrl+P); Create PDF, Create Handouts and Change File
Type (Export); appearance and About (Account); Preferences (Options).
Share (cloud) is left out.

Close and Ctrl+W now ask Save / Don't Save / Cancel about unsaved
changes instead of closing at once. The Export dialog shares
SlideApp::export_as with the Export page. New UI commands: app.backstage
{page}, app.closePresentation, app.print; ui.inspect reports the page.
New icons drawn in code: back, save as, account, recent, new file, open
folder.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 crates/ui-egui/src/backstage.rs       | 1245 +++++++++++++++++++++++++
 crates/ui-egui/src/backstage_tests.rs |  438 +++++++++
 crates/ui-egui/src/canvas.rs          |    2 +-
 crates/ui-egui/src/control.rs         |    3 +-
 crates/ui-egui/src/dialogs.rs         |  204 +---
 crates/ui-egui/src/icons.rs           |   34 +
 crates/ui-egui/src/lib.rs             |  238 ++++-
 crates/ui-egui/src/menus.rs           |   22 +-
 crates/ui-egui/src/ribbon.rs          |   19 +-
 9 files changed, 2003 insertions(+), 202 deletions(-)
 create mode 100644 crates/ui-egui/src/backstage.rs
 create mode 100644 crates/ui-egui/src/backstage_tests.rs

diff --git a/crates/ui-egui/src/backstage.rs b/crates/ui-egui/src/backstage.rs
new file mode 100644
index 0000000..f1d0fde
--- /dev/null
+++ b/crates/ui-egui/src/backstage.rs
@@ -0,0 +1,1245 @@
+//! The File tab (Backstage, #76): a full-window view that replaces the ribbon, slides and status
+//! bar until Esc or the back arrow returns to the presentation. With nothing open it is the start
+//! screen: PowerPoint's start screen and File › Home are the same page.
+//!
+//! A side menu on the left picks a page (Home, New, Open, Info, Save As, Print, Export, Account);
+//! Save, Close and Options act at once. Every action runs an existing command through
+//! [`SlideApp::run`] or one of the app's file helpers ([`SlideApp::export_as`],
+//! [`SlideApp::print_pdf`], [`SlideApp::save_as_dialog`]); the state here is UI-only and never
+//! saved. Recent presentations are listed by path: nothing on disk is read until one is picked.
+//!
+//! Laid out after PowerPoint for Windows (observed black-box): a 160-point side menu darker than
+//! the page, 40-point entries with an outline icon, the current page in the accent colour.
+
+use egui::{Align2, Color32, CornerRadius, Key, Rect, RichText, Sense, Stroke, StrokeKind, Ui, pos2, vec2};
+use serde_json::{Value, json};
+
+use crate::SlideApp;
+use crate::icons::{self, Icon};
+use crate::theme::{self, Tokens};
+
+/// Width of the side menu.
+pub const NAV_W: f32 = 160.0;
+/// Height of a side-menu entry (the back arrow's row is a little taller).
+const ITEM_H: f32 = 40.0;
+const BACK_H: f32 = 46.0;
+/// The widest a page's content grows.
+const CONTENT_W: f32 = 1180.0;
+
+/// A page of the File tab.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Page {
+    Home,
+    New,
+    Open,
+    Info,
+    SaveAs,
+    Print,
+    Export,
+    Account,
+}
+
+impl Page {
+    pub const ALL: [Page; 8] = [Page::Home, Page::New, Page::Open, Page::Info, Page::SaveAs, Page::Print, Page::Export, Page::Account];
+
+    /// The id `app.backstage {page}` takes.
+    pub fn id(self) -> &'static str {
+        match self {
+            Page::Home => "home",
+            Page::New => "new",
+            Page::Open => "open",
+            Page::Info => "info",
+            Page::SaveAs => "saveAs",
+            Page::Print => "print",
+            Page::Export => "export",
+            Page::Account => "account",
+        }
+    }
+
+    pub fn parse(id: &str) -> Option<Page> {
+        let id = id.trim();
+        Page::ALL.into_iter().find(|p| p.id().eq_ignore_ascii_case(id))
+    }
+
+    /// Side-menu label and page heading.
+    pub fn label(self) -> &'static str {
+        match self {
+            Page::Home => "Home",
+            Page::New => "New",
+            Page::Open => "Open",
+            Page::Info => "Info",
+            Page::SaveAs => "Save As",
+            Page::Print => "Print",
+            Page::Export => "Export",
+            Page::Account => "Account",
+        }
+    }
+
+    fn icon(self) -> Icon {
+        match self {
+            Page::Home => Icon::Home,
+            Page::New => Icon::NewFile,
+            Page::Open => Icon::OpenFolder,
+            Page::Info => Icon::Info,
+            Page::SaveAs => Icon::SaveAs,
+            Page::Print => Icon::Print,
+            Page::Export => Icon::Export,
+            Page::Account => Icon::Account,
+        }
+    }
+
+    /// Pages about the open presentation (hidden on the start screen).
+    pub fn needs_doc(self) -> bool {
+        matches!(self, Page::Info | Page::SaveAs | Page::Print | Page::Export)
+    }
+}
+
+/// A side-menu entry: a page, or an action that runs at once.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Nav {
+    Page(Page),
+    Save,
+    Close,
+    Options,
+}
+
+impl Nav {
+    fn label(self) -> &'static str {
+        match self {
+            Nav::Page(p) => p.label(),
+            Nav::Save => "Save",
+            Nav::Close => "Close",
+            Nav::Options => "Options",
+        }
+    }
+    fn icon(self) -> Icon {
+        match self {
+            Nav::Page(p) => p.icon(),
+            Nav::Save => Icon::Save,
+            Nav::Close => Icon::File,
+            Nav::Options => Icon::Settings,
+        }
+    }
+}
+
+/// The side menu, top group then bottom group, in keyboard order. PowerPoint's Share (cloud) is
+/// left out; with nothing open only Home, New and Open stay at the top.
+pub fn entries(has_doc: bool) -> (Vec<Nav>, Vec<Nav>) {
+    let mut top = vec![Nav::Page(Page::Home), Nav::Page(Page::New), Nav::Page(Page::Open)];
+    if has_doc {
+        top.extend([Nav::Page(Page::Info), Nav::Save, Nav::Page(Page::SaveAs), Nav::Page(Page::Print), Nav::Page(Page::Export), Nav::Close]);
+    }
+    (top, vec![Nav::Page(Page::Account), Nav::Options])
+}
+
+/// Print page: which slides.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PrintScope {
+    All,
+    Current,
+    Custom,
+}
+
+/// Export page: the chosen task on the left.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ExportTask {
+    Pdf,
+    Handouts,
+    FileType,
+}
+
+/// The File tab's state while it is open.
+#[derive(Clone, Debug)]
+pub struct Backstage {
+    pub page: Page,
+    /// The open presentations (count, active) when it opened: a change closes it.
+    pub docs: (usize, Option<usize>),
+    /// Keyboard focus in the side menu (an index into [`entries`], top then bottom).
+    pub focus: Option<usize>,
+    /// Search text on Home, New and Open.
+    pub query: String,
+    /// Info: property drafts while a field is being edited.
+    props: Vec<String>,
+    pub print_scope: PrintScope,
+    pub print_range: String,
+    /// `slides`, `notes`, or `h1`…`h9` (handouts with that many slides a page).
+    pub print_layout: &'static str,
+    pub print_hidden: bool,
+    pub print_frame: bool,
+    pub preview_page: usize,
+    pub export: ExportTask,
+    /// Export › Change File Type / Save As: the chosen type (an [`SAVE_TYPES`] id).
+    pub file_type: &'static str,
+    pub handouts_per_page: u8,
+    pub pdf_hidden: bool,
+}
+
+impl Backstage {
+    pub fn new(page: Page, docs: (usize, Option<usize>)) -> Backstage {
+        Backstage {
+            page,
+            docs,
+            focus: None,
+            query: String::new(),
+            props: vec![String::new(); PROPERTIES.len()],
+            print_scope: PrintScope::All,
+            print_range: String::new(),
+            print_layout: "slides",
+            print_hidden: false,
+            print_frame: true,
+            preview_page: 0,
+            export: ExportTask::Pdf,
+            file_type: "pptx",
+            handouts_per_page: 3,
+            pdf_hidden: false,
+        }
+    }
+
+    /// Show `page`, as a click in the side menu does.
+    pub fn go(&mut self, page: Page) {
+        if self.page != page {
+            self.query.clear();
+            self.preview_page = 0;
+        }
+        self.page = page;
+    }
+}
+
+/// Save As and Change File Type: (id for [`SlideApp::export_as`], label, detail).
+pub const SAVE_TYPES: [(&str, &str, &str); 6] = [
+    ("pptx", "PowerPoint Presentation (*.pptx)", "Opens in PowerPoint and other presentation apps"),
+    ("deckcraft", "DeckCraft Presentation (*.deckcraft)", "DeckCraft's own format: everything is kept"),
+    ("pdf", "PDF (*.pdf)", "A fixed copy that keeps its layout on any device"),
+    ("outline", "Outline (*.txt)", "The slide titles and bullet text as plain text"),
+    ("png", "PNG Picture (*.png)", "The current slide as a picture"),
+    ("jpeg", "JPEG Picture (*.jpg)", "The current slide as a compressed picture"),
+];
+
+/// Info page properties: (`file.properties` key, label, hint).
+const PROPERTIES: [(&str, &str, &str); 7] = [
+    ("title", "Title", "Add a title"),
+    ("subject", "Subject", "Specify the subject"),
+    ("keywords", "Tags", "Add a tag"),
+    ("category", "Categories", "Add a category"),
+    ("company", "Company", "Specify the company"),
+    ("comments", "Comments", "Add comments"),
+    ("author", "Author", "Add an author"),
+];
+
+/// What a click asked for, applied after drawing.
+#[derive(Default)]
+struct Outcome {
+    close: bool,
+    page: Option<Page>,
+}
+
+/// Colours of the side menu and the page, from the theme: the menu sits a step darker than the
+/// page, as in PowerPoint.
+fn colours(t: &Tokens) -> (Color32, Color32) {
+    (t.chrome, t.card)
+}
+
+/// Runs a side-menu action. Returns the page to show, or None to close the view (Some(current)
+/// leaves it as it is).
+fn act(app: &mut SlideApp, nav: Nav, current: Page) -> Option<Page> {
+    match nav {
+        Nav::Page(p) => Some(p),
+        Nav::Save => {
+            let web = app.services.pick_save.is_none() && app.services.download.is_some();
+            let has_path = app.session.active().is_some_and(|d| d.path.is_some());
+            if !has_path && !web {
+                // A presentation that was never saved goes to Save As first, as in PowerPoint.
+                return Some(Page::SaveAs);
+            }
+            app.save();
+            let saved = app.session.active().is_some_and(|d| !d.is_dirty());
+            if saved || web { None } else { Some(current) }
+        }
+        Nav::Close => {
+            app.close_presentation();
+            Some(current)
+        }
+        Nav::Options => {
+            let _ = app.run("app.preferences", json!({}));
+            Some(current)
+        }
+    }
+}
+
+/// The File tab's own keys: Esc goes back to the presentation; Up and Down walk the side menu
+/// (a page shows as soon as it has the focus, as in PowerPoint); Enter or Space runs the focused
+/// action. True when the key was used.
+pub fn key(app: &mut SlideApp, key: Key, mods: deckcraft_engine::Mods) -> bool {
+    if mods.cmd || mods.alt || mods.shift {
+        return false;
+    }
+    let has_doc = app.session.active().is_some();
+    let (top, bottom) = entries(has_doc);
+    let all: Vec<Nav> = top.into_iter().chain(bottom).collect();
+    let Some(bs) = app.backstage.as_mut() else { return false };
+    match key {
+        Key::Escape => {
+            app.close_backstage();
+            true
+        }
+        Key::ArrowDown | Key::ArrowUp => {
+            let cur = bs.focus.or_else(|| all.iter().position(|n| *n == Nav::Page(bs.page)));
+            let n = all.len();
+            let next = match (cur, key == Key::ArrowDown) {
+                (None, _) => 0,
+                (Some(i), true) => (i + 1) % n,
+                (Some(i), false) => (i + n - 1) % n,
+            };
+            bs.focus = Some(next);
+            if let Some(Nav::Page(p)) = all.get(next) {
+                bs.go(*p);
+            }
+            true
+        }
+        Key::Enter | Key::Space => {
+            let Some(nav) = bs.focus.and_then(|i| all.get(i)).copied() else { return false };
+            let current = bs.page;
+            match act(app, nav, current) {
+                None => app.close_backstage(),
+                Some(p) => {
+                    if let Some(bs) = app.backstage.as_mut() {
+                        bs.go(p);
+                    }
+                }
+            }
+            true
+        }
+        _ => false,
+    }
+}
+
+/// Draws the File tab in place of the ribbon, slides and status bar.
+pub fn show(app: &mut SlideApp, ui: &mut Ui) {
+    let Some(mut bs) = app.backstage.take() else { return };
+    let t = Tokens::get(ui.ctx());
+    let has_doc = app.session.active().is_some();
+    if !has_doc && bs.page.needs_doc() {
+        bs.page = Page::Home;
+    }
+    let (nav_bg, page_bg) = colours(&t);
+    let mut out = Outcome::default();
+    let (top, bottom) = entries(has_doc);
+    egui::Panel::left("backstage_nav").exact_size(NAV_W).resizable(false).frame(egui::Frame::NONE.fill(nav_bg)).show(ui, |ui| {
+        ui.spacing_mut().item_spacing.y = 0.0;
+        if has_doc {
+            let (r, resp) = ui.allocate_exact_size(vec2(NAV_W, BACK_H), Sense::click());
+            resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, "Back"));
+            let hovered = resp.hovered();
+            if hovered {
+                ui.painter().rect_filled(Rect::from_center_size(pos2(r.left() + 26.0, r.center().y), vec2(34.0, 34.0)), 17.0, t.hover);
+            }
+            icons::paint(
+                ui.painter(),
+                Rect::from_center_size(pos2(r.left() + 26.0, r.center().y), vec2(22.0, 22.0)),
+                Icon::BackCircle,
+                t.text,
+                false,
+            );
+            if resp.on_hover_text("Back (Esc)").clicked() {
+                out.close = true;
+            }
+        } else {
+            ui.add_space(BACK_H);
+        }
+        let mut index = 0;
+        for (k, nav) in top.iter().enumerate() {
+            if k == 3 {
+                separator(ui, &t);
+            }
+            if nav_item(ui, *nav, &bs, index, &t).clicked() {
+                bs.focus = None;
+                match act(app, *nav, bs.page) {
+                    None => out.close = true,
+                    Some(p) => out.page = Some(p),
+                }
+            }
+            index += 1;
+        }
+        let first_bottom = index;
+        ui.with_layout(egui::Layout::bottom_up(egui::Align::Min), |ui| {
+            ui.add_space(8.0);
+            // Bottom-up: draw the last entry first.
+            for (k, nav) in bottom.iter().enumerate().rev() {
+                if nav_item(ui, *nav, &bs, first_bottom + k, &t).clicked() {
+                    bs.focus = None;
+                    match act(app, *nav, bs.page) {
+                        None => out.close = true,
+                        Some(p) => out.page = Some(p),
+                    }
+                }
+            }
+            separator(ui, &t);
+        });
+    });
+    egui::CentralPanel::default().frame(egui::Frame::NONE.fill(page_bg)).show(ui, |ui| {
+        // Fields, boxes and buttons sit on the page's own colour: outline them, as PowerPoint does.
+        let w = &mut ui.visuals_mut().widgets;
+        w.inactive.bg_fill = t.field_bg;
+        w.inactive.weak_bg_fill = t.field_bg;
+        w.inactive.bg_stroke = Stroke::new(1.0, t.border);
+        w.hovered.bg_stroke = Stroke::new(1.0, t.accent);
+        w.active.bg_stroke = Stroke::new(1.0, t.accent);
+        egui::ScrollArea::vertical().auto_shrink([false, false]).show(ui, |ui| {
+            egui::Frame::NONE.inner_margin(egui::Margin { left: 48, right: 36, top: 22, bottom: 32 }).show(ui, |ui| {
+                ui.set_max_width(CONTENT_W);
+                if bs.page != Page::Home {
+                    ui.label(RichText::new(bs.page.label()).font(theme::bold(22.0)).color(t.text));
+                    ui.add_space(16.0);
+                }
+                match bs.page {
+                    Page::Home => home(app, ui, &mut bs, &mut out),
+                    Page::New => new_page(app, ui, &mut bs),
+                    Page::Open => open_page(app, ui, &mut bs),
+                    Page::Info => info(app, ui, &mut bs),
+                    Page::SaveAs => save_as(app, ui, &mut bs, &mut out),
+                    Page::Print => print(app, ui, &mut bs),
+                    Page::Export => export(app, ui, &mut bs),
+                    Page::Account => account(app, ui),
+                }
+            });
+        });
+    });
+    if let Some(page) = out.page {
+        bs.go(page);
+    }
+    // A command run from a page may have closed the view itself (a new presentation); keep that.
+    if out.close && has_doc {
+        app.backstage = None;
+    } else if app.backstage.is_none() {
+        app.backstage = Some(bs);
+    }
+}
+
+// ---------------------------------------------------------------- side menu
+
+fn nav_item(ui: &mut Ui, nav: Nav, bs: &Backstage, index: usize, t: &Tokens) -> egui::Response {
+    let (rect, resp) = ui.allocate_exact_size(vec2(NAV_W, ITEM_H), Sense::click());
+    let selected = nav == Nav::Page(bs.page);
+    let label = nav.label();
+    resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Button, true, selected, label));
+    let p = ui.painter();
+    let row = rect.shrink2(vec2(6.0, 1.0));
+    if resp.hovered() {
+        p.rect_filled(row, CornerRadius::same(2), t.hover);
+    }
+    if bs.focus == Some(index) || selected {
+        // The current page (and the keyboard focus) is outlined, as in PowerPoint.
+        let ink = if bs.focus == Some(index) { t.text } else { t.border };
+        p.rect_stroke(row, CornerRadius::same(2), Stroke::new(1.0, ink), StrokeKind::Inside);
+    }
+    let ink = if selected { t.accent } else { t.text };
+    icons::paint(p, Rect::from_center_size(pos2(rect.left() + 26.0, rect.center().y), vec2(16.0, 16.0)), nav.icon(), ink, false);
+    p.text(pos2(rect.left() + 44.0, rect.center().y), Align2::LEFT_CENTER, label, theme::font(13.0), ink);
+    resp
+}
+
+fn separator(ui: &mut Ui, t: &Tokens) {
+    let (rect, _) = ui.allocate_exact_size(vec2(NAV_W, 13.0), Sense::hover());
+    let y = rect.center().y;
+    ui.painter().line_segment([pos2(rect.left() + 20.0, y), pos2(rect.right() - 14.0, y)], Stroke::new(1.0, t.separator));
+}
+
+// ---------------------------------------------------------------- shared pieces
+
+fn heading(ui: &mut Ui, text: &str) {
+    let t = Tokens::get(ui.ctx());
+    ui.label(RichText::new(text).font(theme::bold(16.0)).color(t.text));
+    ui.add_space(8.0);
+}
+
+fn dim(ui: &mut Ui, text: &str) {
+    let t = Tokens::get(ui.ctx());
+    ui.label(RichText::new(text).font(theme::font(12.5)).color(t.text_dim));
+}
+
+/// A link with an arrow (More themes →): true when clicked.
+fn arrow_link(ui: &mut Ui, text: &str) -> bool {
+    let t = Tokens::get(ui.ctx());
+    ui.add(egui::Label::new(RichText::new(format!("{text}  →")).font(theme::font(12.5)).color(t.accent)).sense(Sense::click()))
+        .on_hover_cursor(egui::CursorIcon::PointingHand)
+        .clicked()
+}
+
+/// A search box; true when its text changed.
+fn search(ui: &mut Ui, query: &mut String, hint: &str, width: f32) -> bool {
+    ui.add(egui::TextEdit::singleline(query).hint_text(hint).desired_width(width)).changed()
+}
+
+/// A new-presentation tile: a theme preview drawn in code (or a blank slide) over its name.
+fn tile(ui: &mut Ui, label: &str, theme: Option<&deckcraft_model::Theme>, big: bool) -> egui::Response {
+    let t = Tokens::get(ui.ctx());
+    let thumb_w = if big { 200.0 } else { 160.0 };
+    let (rect, resp) = ui.allocate_exact_size(vec2(thumb_w + 16.0, thumb_w * 9.0 / 16.0 + 44.0), Sense::click());
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, label));
+    let p = ui.painter();
+    if resp.hovered() {
+        p.rect_filled(rect, CornerRadius::same(4), t.hover);
+    }
+    let thumb = Rect::from_min_size(rect.min + vec2(8.0, 10.0), vec2(thumb_w, thumb_w * 9.0 / 16.0));
+    match theme {
+        Some(th) => crate::ribbon::paint_theme_tile(p, thumb, th),
+        None => {
+            p.rect_filled(thumb, CornerRadius::same(2), Color32::WHITE);
+            p.rect_stroke(thumb, CornerRadius::same(2), Stroke::new(1.0, Color32::from_gray(200)), StrokeKind::Inside);
+        }
+    }
+    if resp.hovered() {
+        p.rect_stroke(thumb, CornerRadius::same(2), Stroke::new(2.0, t.accent), StrokeKind::Outside);
+    }
+    let galley = p.layout(label.to_string(), theme::font(12.0), t.text, rect.width() - 8.0);
+    p.galley(pos2(rect.center().x - galley.size().x / 2.0, thumb.bottom() + 8.0), galley, t.text);
+    resp
+}
+
+/// The built-in themes and the sample deck, filtered by `query` (after a blank presentation when
+/// `blank`); at most `limit` theme tiles.
+fn new_tiles(app: &mut SlideApp, ui: &mut Ui, query: &str, limit: usize, blank: bool) {
+    let q = query.trim().to_lowercase();
+    let themes: Vec<deckcraft_model::Theme> =
+        deckcraft_model::theme::builtin_themes().into_iter().filter(|th| q.is_empty() || th.name.to_lowercase().contains(&q)).collect();
+    let sample = q.is_empty() || "sample deck northern lights".contains(&q);
+    if themes.is_empty() && !sample {
+        dim(ui, &format!("No themes match “{}”.", query.trim()));
+        return;
+    }
+    ui.horizontal_wrapped(|ui| {
+        ui.spacing_mut().item_spacing = vec2(10.0, 10.0);
+        if blank && tile(ui, "Blank Presentation", None, false).clicked() {
+            let _ = app.run("file.new", json!({}));
+        }
+        let mut shown = 0;
+        for th in themes {
+            if shown >= limit {
+                break;
+            }
+            if tile(ui, &th.name, Some(&th), false).clicked() {
+                let _ = app.run("file.new", json!({"theme": th.name}));
+            }
+            shown += 1;
+        }
+        if sample && shown < limit {
+            let th = deckcraft_model::theme::builtin_themes().into_iter().find(|t| t.name == "DeckCraft");
+            if tile(ui, "Sample deck: Northern Lights", th.as_ref(), false).clicked()
+                && let Err(e) = deckcraft_engine::sample::open_sample(&mut app.session)
+            {
+                app.set_status(e.to_string());
+            }
+        }
+    });
+}
+
+/// File name and folder of a recent path, split as text (nothing on disk is read).
+pub fn split_path(path: &str) -> (String, String) {
+    let p = std::path::Path::new(path);
+    let name = p.file_name().and_then(|n| n.to_str()).unwrap_or(path).to_string();
+    let folder = p.parent().and_then(|f| f.to_str()).unwrap_or("").to_string();
+    (name, folder)
+}
+
+/// Recent presentations whose name matches `query`, newest first, at most `limit`. Opening one is
+/// the user's explicit choice.
+fn recent_list(app: &mut SlideApp, ui: &mut Ui, query: &str, limit: usize) {
+    let t = Tokens::get(ui.ctx());
+    if app.ui.recent.is_empty() {
+        dim(ui, "Presentations you open show up here. Use Open to browse for one.");
+        return;
+    }
+    let q = query.trim().to_lowercase();
+    let list: Vec<String> =
+        app.ui.recent.iter().filter(|p| q.is_empty() || split_path(p).0.to_lowercase().contains(&q)).take(limit).cloned().collect();
+    if list.is_empty() {
+        dim(ui, &format!("No recent presentations match “{}”.", query.trim()));
+        return;
+    }
+    let width = ui.available_width().min(CONTENT_W);
+    for path in list {
+        let (name, folder) = split_path(&path);
+        let (rect, resp) = ui.allocate_exact_size(vec2(width, 44.0), Sense::click());
+        resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, &name));
+        let p = ui.painter();
+        if resp.hovered() {
+            p.rect_filled(rect, CornerRadius::same(3), t.hover);
+        }
+        icons::paint(p, Rect::from_center_size(pos2(rect.left() + 20.0, rect.center().y), vec2(22.0, 22.0)), Icon::Slide, t.text, false);
+        p.text(pos2(rect.left() + 44.0, rect.center().y - 8.0), Align2::LEFT_CENTER, &name, theme::font(13.0), t.text);
+        p.text(pos2(rect.left() + 44.0, rect.center().y + 9.0), Align2::LEFT_CENTER, &folder, theme::font(11.0), t.text_dim);
+        if resp.on_hover_text(&path).clicked()
+            && let Err(e) = app.open_path(&path)
+        {
+            app.set_status(e);
+        }
+    }
+}
+
+/// A large square command button (Print, Create PDF, Check for Issues…).
+fn square_button(ui: &mut Ui, icon: Icon, label: &str, enabled: bool) -> egui::Response {
+    let t = Tokens::get(ui.ctx());
+    let (rect, resp) = ui.allocate_exact_size(vec2(88.0, 80.0), if enabled { Sense::click() } else { Sense::hover() });
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, enabled, label));
+    let p = ui.painter();
+    p.rect_filled(rect, CornerRadius::same(3), if resp.hovered() && enabled { t.hover } else { t.card });
+    p.rect_stroke(rect, CornerRadius::same(3), Stroke::new(1.0, if resp.hovered() && enabled { t.accent } else { t.border }), StrokeKind::Inside);
+    icons::paint(p, Rect::from_center_size(pos2(rect.center().x, rect.top() + 26.0), vec2(26.0, 26.0)), icon, t.text, !enabled);
+    let ink = if enabled { t.text } else { t.text_faint };
+    let galley = p.layout(label.to_string(), theme::font(12.0), ink, rect.width() - 8.0);
+    p.galley(pos2(rect.center().x - galley.size().x / 2.0, rect.top() + 46.0), galley, ink);
+    resp
+}
+
+/// A row of a page's own list on the left (Open's places, Export's tasks).
+fn place_row(ui: &mut Ui, icon: Icon, label: &str, selected: bool, width: f32) -> egui::Response {
+    let t = Tokens::get(ui.ctx());
+    let (rect, resp) = ui.allocate_exact_size(vec2(width, 44.0), Sense::click());
+    resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Button, true, selected, label));
+    let p = ui.painter();
+    if selected {
+        p.rect_filled(rect, CornerRadius::same(2), t.selected);
+        p.rect_stroke(rect, CornerRadius::same(2), Stroke::new(1.0, t.border), StrokeKind::Inside);
+    } else if resp.hovered() {
+        p.rect_filled(rect, CornerRadius::same(2), t.hover);
+    }
+    icons::paint(p, Rect::from_center_size(pos2(rect.left() + 22.0, rect.center().y), vec2(24.0, 24.0)), icon, t.text, false);
+    p.text(pos2(rect.left() + 46.0, rect.center().y), Align2::LEFT_CENTER, label, theme::font(13.5), t.text);
+    resp
+}
+
+/// A square button with its title and description beside it (Info, Export).
+fn task(ui: &mut Ui, icon: Icon, button: &str, title: &str, detail: &str, enabled: bool) -> bool {
+    let t = Tokens::get(ui.ctx());
+    let mut clicked = false;
+    ui.horizontal_top(|ui| {
+        clicked = square_button(ui, icon, button, enabled).clicked();
+        ui.add_space(12.0);
+        ui.vertical(|ui| {
+            ui.add_space(4.0);
+            ui.label(RichText::new(title).font(theme::font(15.0)).color(t.text));
+            dim(ui, detail);
+        });
+    });
+    ui.add_space(14.0);
+    clicked
+}
+
+// ---------------------------------------------------------------- pages
+
+/// Home: DeckCraft's mark, new presentations (the first themes, with a link to New) and recent
+/// presentations (with a link to Open). The same page is the start screen.
+fn home(app: &mut SlideApp, ui: &mut Ui, bs: &mut Backstage, out: &mut Outcome) {
+    let t = Tokens::get(ui.ctx());
+    ui.horizontal(|ui| {
+        let (r, _) = ui.allocate_exact_size(vec2(36.0, 36.0), Sense::hover());
+        crate::dialogs::paint_logo(ui.painter(), r);
+        ui.label(RichText::new("DeckCraft").font(theme::bold(24.0)).color(t.text));
+    });
+    ui.add_space(18.0);
+    ui.horizontal(|ui| {
+        ui.label(RichText::new("New").font(theme::bold(16.0)).color(t.text));
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if arrow_link(ui, "More themes") {
+                out.page = Some(Page::New);
+            }
+        });
+    });
+    ui.add_space(6.0);
+    new_tiles(app, ui, "", 5, true);
+    ui.add_space(22.0);
+    ui.horizontal(|ui| {
+        ui.label(RichText::new("Recent").font(theme::bold(16.0)).color(t.text));
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            search(ui, &mut bs.query, "Search for a file", 280.0);
+        });
+    });
+    ui.add_space(6.0);
+    recent_list(app, ui, &bs.query.clone(), 8);
+    if app.ui.recent.len() > 8 {
+        ui.add_space(6.0);
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Min), |ui| {
+            if arrow_link(ui, "More presentations") {
+                out.page = Some(Page::Open);
+            }
+        });
+    }
+    ui.add_space(30.0);
+    ui.hyperlink_to("Join the ArtCraft community on Discord", deckcraft_engine::links::DISCORD);
+}
+
+/// New: a blank presentation, then every theme with a search box.
+fn new_page(app: &mut SlideApp, ui: &mut Ui, bs: &mut Backstage) {
+    let t = Tokens::get(ui.ctx());
+    if tile(ui, "Blank Presentation", None, true).clicked() {
+        let _ = app.run("file.new", json!({}));
+    }
+    ui.add_space(8.0);
+    let w = ui.available_width();
+    let (r, _) = ui.allocate_exact_size(vec2(w, 1.0), Sense::hover());
+    ui.painter().line_segment([r.left_center(), r.right_center()], Stroke::new(1.0, t.separator));
+    ui.add_space(14.0);
+    search(ui, &mut bs.query, "Search for themes", 380.0);
+    ui.add_space(14.0);
+    let q = bs.query.clone();
+    new_tiles(app, ui, &q, usize::MAX, false);
+}
+
+/// Open: Recent and Browse on the left; the recent presentations (with a search box) on the right.
+fn open_page(app: &mut SlideApp, ui: &mut Ui, bs: &mut Backstage) {
+    let t = Tokens::get(ui.ctx());
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(230.0);
+            place_row(ui, Icon::Recent, "Recent", true, 220.0);
+            if place_row(ui, Icon::OpenFolder, "Browse", false, 220.0).on_hover_text("Open a presentation from a folder (Ctrl+O)").clicked() {
+                let _ = app.run("app.openDialog", json!({}));
+            }
+            if app.session.recovery_dir.is_some() {
+                ui.add_space(24.0);
+                if ui.button("Recover Unsaved Presentations").clicked() {
+                    match app.run("file.recovery.open", json!({})) {
+                        Ok(v) if v.get("opened").and_then(Value::as_array).is_some_and(|a| a.is_empty()) => {
+                            app.set_status("There are no unsaved presentations to recover");
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        });
+        let h = ui.available_height().max(320.0);
+        let (r, _) = ui.allocate_exact_size(vec2(1.0, h), Sense::hover());
+        ui.painter().line_segment([r.center_top(), r.center_bottom()], Stroke::new(1.0, t.separator));
+        ui.add_space(24.0);
+        ui.vertical(|ui| {
+            search(ui, &mut bs.query, "Search for a file", 380.0);
+            ui.add_space(12.0);
+            heading(ui, "Presentations");
+            let q = bs.query.clone();
+            recent_list(app, ui, &q, usize::MAX);
+        });
+    });
+}
+
+/// Info: the presentation's name and location, Inspect and Manage on the left, its properties
+/// (editable, through `file.properties`) on the right.
+fn info(app: &mut SlideApp, ui: &mut Ui, bs: &mut Backstage) {
+    let t = Tokens::get(ui.ctx());
+    let Ok(v) = app.session.execute("file.info", &json!({})) else {
+        dim(ui, "No presentation is open.");
+        return;
+    };
+    let path = v.get("path").and_then(Value::as_str).map(str::to_string);
+    let title = v.get("title").and_then(Value::as_str).unwrap_or("").to_string();
+    let dirty = v.get("dirty").and_then(Value::as_bool).unwrap_or(false);
+    ui.label(RichText::new(&title).font(theme::font(24.0)).color(t.accent));
+    match &path {
+        Some(p) => dim(ui, p),
+        None => dim(ui, "Not saved yet"),
+    }
+    if let Some(p) = &path {
+        ui.add_space(8.0);
+        ui.horizontal(|ui| {
+            if ui.button("Copy path").clicked() {
+                ui.ctx().copy_text(p.clone());
+                app.set_status("Copied the path");
+            }
+            #[cfg(not(target_arch = "wasm32"))]
+            if let Some(dir) = std::path::Path::new(p).parent().and_then(|d| d.to_str())
+                && ui.button("Open file location").clicked()
+            {
+                app.open_url(&format!("file:///{}", dir.replace('\\', "/").trim_start_matches('/')));
+            }
+        });
+    }
+    ui.add_space(20.0);
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(440.0);
+            if task(
+                ui,
+                Icon::Accessibility,
+                "Check for Issues",
+                "Inspect Presentation",
+                "Before you share it, check the presentation for things people with disabilities might find hard to read.",
+                true,
+            ) {
+                let _ = app.run("app.dialog", json!({"id": "accessibility"}));
+            }
+            let (detail, can_revert) = match (dirty, path.is_some()) {
+                (false, _) => ("There are no unsaved changes.", false),
+                (true, true) => ("This presentation has unsaved changes. Revert goes back to the saved file.", true),
+                (true, false) => ("This presentation has never been saved.", false),
+            };
+            if task(ui, Icon::ResetSlide, "Revert", "Manage Presentation", detail, can_revert) {
+                let _ = app.run("file.revert", json!({}));
+            }
+        });
+        ui.add_space(30.0);
+        ui.vertical(|ui| {
+            heading(ui, "Properties");
+            let props = v.get("properties").cloned().unwrap_or_default();
+            let size = v.get("bytes").and_then(Value::as_u64).map(format_bytes);
+            egui::Grid::new("backstage_props").num_columns(2).spacing(vec2(18.0, 7.0)).show(ui, |ui| {
+                let row = |ui: &mut Ui, k: &str, val: String| {
+                    ui.label(RichText::new(k).color(t.text_dim));
+                    ui.label(val);
+                    ui.end_row();
+                };
+                if let Some(s) = size {
+                    row(ui, "Size", s);
+                }
+                row(ui, "Slides", v.get("slides").and_then(Value::as_u64).unwrap_or(0).to_string());
+                row(ui, "Hidden slides", v.get("hiddenSlides").and_then(Value::as_u64).unwrap_or(0).to_string());
+                for (i, (key, label, hint)) in PROPERTIES.iter().enumerate() {
+                    let saved = props.get(*key).and_then(Value::as_str).unwrap_or("").to_string();
+                    let Some(draft) = bs.props.get_mut(i) else { continue };
+                    let l = ui.label(RichText::new(*label).color(t.text_dim));
+                    let id = ui.make_persistent_id(("backstage_prop", *key));
+                    // Show the presentation's value unless the field is being edited (undo…).
+                    if !ui.ctx().memory(|m| m.has_focus(id)) {
+                        draft.clone_from(&saved);
+                    }
+                    let resp = ui.add(egui::TextEdit::singleline(draft).id(id).hint_text(*hint).desired_width(300.0)).labelled_by(l.id);
+                    if resp.lost_focus() && *draft != saved {
+                        let mut p = serde_json::Map::new();
+                        p.insert((*key).to_string(), json!(draft.clone()));
+                        let _ = app.run("file.properties", Value::Object(p));
+                    }
+                    ui.end_row();
+                }
+                row(ui, "Location", path.clone().unwrap_or_else(|| "Not saved yet".into()));
+            });
+        });
+    });
+}
+
+/// `1234567` → `1.2 MB`.
+pub fn format_bytes(b: u64) -> String {
+    match b {
+        0..1024 => format!("{b} bytes"),
+        1024..1_048_576 => format!("{:.1} KB", b as f64 / 1024.0),
+        _ => format!("{:.1} MB", b as f64 / 1_048_576.0),
+    }
+}
+
+/// Save As: the file type, then the system Save dialog (desktop) or a download (web). A
+/// presentation saved as .pptx or .deckcraft takes the new file; the other types are copies.
+fn save_as(app: &mut SlideApp, ui: &mut Ui, bs: &mut Backstage, out: &mut Outcome) {
+    let t = Tokens::get(ui.ctx());
+    let (title, path) = app.session.active().map(|d| (d.title(), d.path.clone())).unwrap_or_default();
+    ui.label(RichText::new(&title).font(theme::font(15.0)).color(t.text));
+    dim(ui, path.as_deref().unwrap_or("Not saved yet"));
+    ui.add_space(14.0);
+    let current = SAVE_TYPES.iter().find(|s| s.0 == bs.file_type).map_or(SAVE_TYPES[0].1, |s| s.1);
+    ui.horizontal(|ui| {
+        egui::ComboBox::from_id_salt("backstage_save_type").width(340.0).selected_text(current).show_ui(ui, |ui| {
+            for (id, label, _) in SAVE_TYPES {
+                if ui.selectable_label(bs.file_type == id, label).clicked() {
+                    bs.file_type = id;
+                }
+            }
+        });
+        let web = app.services.pick_save.is_none();
+        let label = if web { "Download" } else { "Save" };
+        let save = ui.add(egui::Button::new(RichText::new(label).color(t.accent_text)).fill(t.accent).min_size(vec2(84.0, 26.0)));
+        if save.on_hover_text(if web { "Download the file" } else { "Choose where to save" }).clicked() {
+            let fmt = bs.file_type;
+            let done = if matches!(fmt, "pptx" | "deckcraft") {
+                let before = app.session.active().map(|d| (d.path.clone(), d.is_dirty()));
+                app.save_as_dialog(fmt);
+                web || app.session.active().map(|d| (d.path.clone(), d.is_dirty())) != before
+            } else {
+                app.export_as(fmt, json!({}))
+            };
+            if done {
+                out.close = true;
+            }
+        }
+    });
+    ui.add_space(8.0);
+    if let Some((_, _, detail)) = SAVE_TYPES.iter().find(|s| s.0 == bs.file_type) {
+        dim(ui, detail);
+    }
+}
+
+/// The slides the Print page prints, in order (0-based).
+pub fn print_slides(doc: &deckcraft_model::Presentation, bs: &Backstage, current: usize) -> Result<Vec<usize>, String> {
+    let n = doc.slides.len();
+    let mut v: Vec<usize> = match bs.print_scope {
+        PrintScope::All => (0..n).collect(),
+        PrintScope::Current => vec![current.min(n.saturating_sub(1))],
+        PrintScope::Custom => deckcraft_engine::cmd::file::parse_slide_range(&bs.print_range, n).map_err(|e| e.to_string())?,
+    };
+    if !bs.print_hidden && bs.print_scope != PrintScope::Current {
+        v.retain(|i| doc.slides.get(*i).is_some_and(|s| !s.hidden));
+    }
+    Ok(v)
+}
+
+/// Handout slides per page for a `print_layout` id (`h3` → 3).
+fn per_page(layout: &str) -> usize {
+    layout.strip_prefix('h').and_then(|n| n.parse::<usize>().ok()).filter(|n| matches!(n, 1 | 2 | 3 | 4 | 6 | 9)).unwrap_or(1)
+}
+
+/// The `file.export` / `app.print` params for the Print page's settings.
+pub fn print_params(bs: &Backstage, slides: &[usize]) -> Value {
+    let (layout, per) = match bs.print_layout {
+        "notes" => ("notes", 0),
+        l if l.starts_with('h') => ("handouts", per_page(l)),
+        _ => ("slides", 0),
+    };
+    // The list is already filtered for hidden slides, so the PDF takes it as it is.
+    json!({"layout": layout, "perPage": per, "slides": slides, "includeHidden": true, "frame": bs.print_frame})
+}
+
+const LAYOUTS: [(&str, &str); 8] = [
+    ("slides", "Full Page Slides"),
+    ("notes", "Notes Pages"),
+    ("h1", "Handouts (1 slide per page)"),
+    ("h2", "Handouts (2 slides per page)"),
+    ("h3", "Handouts (3 slides per page)"),
+    ("h4", "Handouts (4 slides per page)"),
+    ("h6", "Handouts (6 slides per page)"),
+    ("h9", "Handouts (9 slides per page)"),
+];
+
+/// Print: the Print button and settings on the left, a preview of each page on the right.
+fn print(app: &mut SlideApp, ui: &mut Ui, bs: &mut Backstage) {
+    let t = Tokens::get(ui.ctx());
+    let Some((doc, current)) = app.session.active().map(|d| (d.doc.clone(), d.selection.slide)) else {
+        dim(ui, "No presentation is open.");
+        return;
+    };
+    let slides = print_slides(&doc, bs, current);
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(250.0);
+            let ok = slides.as_ref().is_ok_and(|s| !s.is_empty());
+            if square_button(ui, Icon::Print, "Print", ok).clicked()
+                && let Ok(s) = &slides
+            {
+                app.print_pdf(print_params(bs, s));
+            }
+            ui.add_space(6.0);
+            dim(
+                ui,
+                if app.services.pick_save.is_some() {
+                    "DeckCraft prints through a PDF: it opens in your PDF viewer, where you choose the printer."
+                } else {
+                    "DeckCraft prints through a PDF: it downloads, ready to print from your browser or PDF viewer."
+                },
+            );
+            ui.add_space(14.0);
+            heading(ui, "Settings");
+            let scope = match bs.print_scope {
+                PrintScope::All => "Print All Slides",
+                PrintScope::Current => "Print Current Slide",
+                PrintScope::Custom => "Custom Range",
+            };
+            egui::ComboBox::from_id_salt("backstage_print_scope").width(240.0).selected_text(scope).show_ui(ui, |ui| {
+                for (s, label) in
+                    [(PrintScope::All, "Print All Slides"), (PrintScope::Current, "Print Current Slide"), (PrintScope::Custom, "Custom Range")]
+                {
+                    if ui.selectable_label(bs.print_scope == s, label).clicked() {
+                        bs.print_scope = s;
+                        bs.preview_page = 0;
+                    }
+                }
+            });
+            ui.add_space(4.0);
+            ui.horizontal(|ui| {
+                let l = ui.label("Slides:");
+                let r = ui.add(egui::TextEdit::singleline(&mut bs.print_range).hint_text("e.g. 1-3, 5").desired_width(176.0)).labelled_by(l.id);
+                if r.changed() {
+                    // Typing a range picks Custom Range, as in PowerPoint.
+                    bs.print_scope = if bs.print_range.trim().is_empty() { PrintScope::All } else { PrintScope::Custom };
+                    bs.preview_page = 0;
+                }
+            });
+            ui.add_space(4.0);
+            let layout = LAYOUTS.iter().find(|l| l.0 == bs.print_layout).map_or("Full Page Slides", |l| l.1);
+            egui::ComboBox::from_id_salt("backstage_print_layout").width(240.0).selected_text(layout).show_ui(ui, |ui| {
+                for (id, label) in LAYOUTS {
+                    if ui.selectable_label(bs.print_layout == id, label).clicked() {
+                        bs.print_layout = id;
+                        bs.preview_page = 0;
+                    }
+                }
+            });
+            ui.add_space(4.0);
+            if ui.checkbox(&mut bs.print_hidden, "Print Hidden Slides").changed() {
+                bs.preview_page = 0;
+            }
+            ui.checkbox(&mut bs.print_frame, "Frame Slides");
+            ui.add_space(6.0);
+            if ui.link("Edit Header & Footer").clicked() {
+                let _ = app.run("app.dialog", json!({"id": "headerFooter"}));
+            }
+        });
+        ui.add_space(20.0);
+        let (r, _) = ui.allocate_exact_size(vec2(1.0, 560.0), Sense::hover());
+        ui.painter().line_segment([r.center_top(), r.center_bottom()], Stroke::new(1.0, t.separator));
+        ui.add_space(20.0);
+        ui.vertical(|ui| match &slides {
+            Err(e) => dim(ui, e),
+            Ok(s) if s.is_empty() => dim(ui, "Nothing to print: every slide in the range is hidden."),
+            Ok(s) => preview(app, ui, bs, &doc, s),
+        });
+    });
+}
+
+/// One printed page in miniature, with a pager under it.
+fn preview(app: &mut SlideApp, ui: &mut Ui, bs: &mut Backstage, doc: &deckcraft_model::Presentation, slides: &[usize]) {
+    let t = Tokens::get(ui.ctx());
+    let per = match bs.print_layout {
+        "slides" | "notes" => 1,
+        l => per_page(l),
+    };
+    let pages: Vec<&[usize]> = slides.chunks(per.max(1)).collect();
+    let last = pages.len().saturating_sub(1);
+    bs.preview_page = bs.preview_page.min(last);
+    let Some(on_page) = pages.get(bs.preview_page).copied() else { return };
+    // Full-page slides print on slide-shaped pages; notes and handouts on portrait Letter.
+    let (pw, ph) = if bs.print_layout == "slides" { (doc.slide_size.width as f32, doc.slide_size.height as f32) } else { (612.0, 792.0) };
+    let avail_w = ui.available_width().clamp(200.0, 760.0);
+    let scale = (avail_w / pw.max(1.0)).min(520.0 / ph.max(1.0));
+    let (area, _) = ui.allocate_exact_size(vec2(avail_w, ph * scale + 24.0), Sense::hover());
+    ui.painter().rect_filled(area, CornerRadius::same(2), t.canvas);
+    let page = Rect::from_center_size(area.center(), vec2(pw * scale, ph * scale));
+    let p = ui.painter();
+    p.rect_filled(page.translate(vec2(2.0, 3.0)), 0.0, t.shadow);
+    p.rect_filled(page, 0.0, Color32::WHITE);
+    let aspect = (doc.slide_size.height / doc.slide_size.width.max(1.0)) as f32;
+    let mut budget = 4u32;
+    let mut draw_slide = |ui: &mut Ui, i: usize, r: Rect| {
+        let px = (r.width() * ui.ctx().pixels_per_point()).round().clamp(16.0, 1600.0) as u32;
+        match app.textures.thumb(ui.ctx(), doc, i, px, &mut budget) {
+            Some(tex) => {
+                ui.painter().image(tex.id(), r, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+            }
+            None => ui.ctx().request_repaint(),
+        }
+        if bs.print_frame || bs.print_layout != "slides" {
+            ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, Color32::from_gray(120)), StrokeKind::Outside);
+        }
+    };
+    match bs.print_layout {
+        "slides" => {
+            if let Some(i) = on_page.first() {
+                draw_slide(ui, *i, page);
+            }
+        }
+        "notes" => {
+            if let Some(i) = on_page.first() {
+                let w = page.width() * 0.75;
+                let r = Rect::from_min_size(pos2(page.center().x - w / 2.0, page.top() + page.height() * 0.08), vec2(w, w * aspect));
+                draw_slide(ui, *i, r);
+                let notes = doc.slides.get(*i).map(|s| s.notes_text()).unwrap_or_default();
+                let font = theme::font((11.0 * scale).clamp(5.0, 13.0));
+                let text_rect = Rect::from_min_max(
+                    pos2(page.left() + page.width() * 0.12, r.bottom() + 20.0 * scale),
+                    page.max - vec2(page.width() * 0.12, 30.0 * scale),
+                );
+                let galley = ui.painter().layout(notes, font, Color32::from_gray(30), text_rect.width());
+                ui.painter().with_clip_rect(text_rect).galley(text_rect.min, galley, Color32::from_gray(30));
+            }
+        }
+        l => {
+            let n = per_page(l);
+            let (cols, rows) = match n {
+                1 => (1, 1),
+                2 => (1, 2),
+                3 => (1, 3),
+                4 => (2, 2),
+                6 => (2, 3),
+                _ => (3, 3),
+            };
+            let inner = page.shrink2(vec2(page.width() * 0.08, page.height() * 0.07));
+            // Three a page leaves lines for notes beside each slide, as PowerPoint's handouts do.
+            let slide_area = if n == 3 { Rect::from_min_size(inner.min, vec2(inner.width() * 0.5, inner.height())) } else { inner };
+            let cell = vec2(slide_area.width() / cols as f32, slide_area.height() / rows as f32);
+            for (k, i) in on_page.iter().enumerate() {
+                let (c, r) = ((k % cols) as f32, (k / cols) as f32);
+                let cell_rect = Rect::from_min_size(slide_area.min + vec2(c * cell.x, r * cell.y), cell).shrink(cell.x.min(cell.y) * 0.08);
+                let w = cell_rect.width().min(cell_rect.height() / aspect.max(0.01));
+                let sr = Rect::from_center_size(cell_rect.center(), vec2(w, w * aspect));
+                draw_slide(ui, *i, sr);
+                if n == 3 {
+                    for line in 1..=5 {
+                        let y = sr.top() + sr.height() * line as f32 / 6.0;
+                        ui.painter()
+                            .line_segment([pos2(inner.center().x + 10.0, y), pos2(inner.right(), y)], Stroke::new(0.8, Color32::from_gray(150)));
+                    }
+                }
+            }
+        }
+    }
+    ui.add_space(6.0);
+    ui.horizontal(|ui| {
+        let prev = icon_button(ui, Icon::ChevronLeft, "Previous Page", bs.preview_page > 0);
+        if prev {
+            bs.preview_page = bs.preview_page.saturating_sub(1);
+        }
+        ui.label(format!("{} of {}", bs.preview_page + 1, pages.len()));
+        if icon_button(ui, Icon::ChevronRight, "Next Page", bs.preview_page < last) {
+            bs.preview_page = (bs.preview_page + 1).min(last);
+        }
+    });
+}
+
+fn icon_button(ui: &mut Ui, icon: Icon, label: &str, enabled: bool) -> bool {
+    let t = Tokens::get(ui.ctx());
+    let (r, resp) = ui.allocate_exact_size(vec2(22.0, 22.0), if enabled { Sense::click() } else { Sense::hover() });
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, enabled, label));
+    if resp.hovered() && enabled {
+        ui.painter().rect_filled(r, CornerRadius::same(3), t.hover);
+    }
+    icons::paint(ui.painter(), r.shrink(3.0), icon, t.text, !enabled);
+    resp.on_hover_text(label).clicked()
+}
+
+/// Export: tasks on the left (Create PDF Document, Create Handouts, Change File Type), the chosen
+/// one's description and button on the right. PowerPoint's video, animated GIF and CD package
+/// exports aren't offered.
+fn export(app: &mut SlideApp, ui: &mut Ui, bs: &mut Backstage) {
+    let t = Tokens::get(ui.ctx());
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(250.0);
+            for (task, icon, label) in [
+                (ExportTask::Pdf, Icon::File, "Create PDF Document"),
+                (ExportTask::Handouts, Icon::Notes, "Create Handouts"),
+                (ExportTask::FileType, Icon::Export, "Change File Type"),
+            ] {
+                if place_row(ui, icon, label, bs.export == task, 244.0).clicked() {
+                    bs.export = task;
+                }
+            }
+        });
+        let (r, _) = ui.allocate_exact_size(vec2(1.0, 420.0), Sense::hover());
+        ui.painter().line_segment([r.center_top(), r.center_bottom()], Stroke::new(1.0, t.separator));
+        ui.add_space(24.0);
+        ui.vertical(|ui| {
+            ui.set_max_width(560.0);
+            match bs.export {
+                ExportTask::Pdf => {
+                    ui.label(RichText::new("Create a PDF Document").font(theme::font(16.0)).color(t.text));
+                    bullets(
+                        ui,
+                        &["Keeps the layout, fonts and pictures", "Opens on any device with a PDF viewer", "The presentation keeps its own file"],
+                    );
+                    ui.checkbox(&mut bs.pdf_hidden, "Include hidden slides");
+                    ui.add_space(10.0);
+                    if square_button(ui, Icon::File, "Create PDF", true).clicked() {
+                        app.export_as("pdf", json!({"includeHidden": bs.pdf_hidden}));
+                    }
+                }
+                ExportTask::Handouts => {
+                    ui.label(RichText::new("Create Handouts").font(theme::font(16.0)).color(t.text));
+                    bullets(ui, &["Several slides on each page of a PDF", "Three a page leaves lines for notes", "Print them for your audience"]);
+                    egui::ComboBox::from_id_salt("backstage_handouts")
+                        .width(240.0)
+                        .selected_text(format!("{} slides per page", bs.handouts_per_page))
+                        .show_ui(ui, |ui| {
+                            for n in [1u8, 2, 3, 4, 6, 9] {
+                                if ui.selectable_label(bs.handouts_per_page == n, format!("{n} slides per page")).clicked() {
+                                    bs.handouts_per_page = n;
+                                }
+                            }
+                        });
+                    ui.add_space(10.0);
+                    if square_button(ui, Icon::Notes, "Create Handouts", true).clicked() {
+                        app.export_as("pdf", json!({"layout": "handouts", "perPage": bs.handouts_per_page}));
+                    }
+                }
+                ExportTask::FileType => {
+                    ui.label(RichText::new("Change File Type").font(theme::font(16.0)).color(t.text));
+                    ui.add_space(8.0);
+                    for (id, label, detail) in SAVE_TYPES.iter().filter(|s| s.0 != "pdf") {
+                        let selected = bs.file_type == *id;
+                        let (rect, resp) = ui.allocate_exact_size(vec2(520.0, 46.0), Sense::click());
+                        resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Button, true, selected, *label));
+                        let p = ui.painter();
+                        if selected {
+                            p.rect_filled(rect, CornerRadius::same(2), t.selected);
+                        } else if resp.hovered() {
+                            p.rect_filled(rect, CornerRadius::same(2), t.hover);
+                        }
+                        p.text(pos2(rect.left() + 12.0, rect.center().y - 8.0), Align2::LEFT_CENTER, *label, theme::font(13.0), t.text);
+                        p.text(pos2(rect.left() + 12.0, rect.center().y + 9.0), Align2::LEFT_CENTER, *detail, theme::font(11.5), t.text_dim);
+                        if resp.clicked() {
+                            bs.file_type = id;
+                        }
+                    }
+                    ui.add_space(12.0);
+                    if square_button(ui, Icon::SaveAs, "Save As", true).clicked() {
+                        app.export_as(bs.file_type, json!({}));
+                    }
+                }
+            }
+        });
+    });
+}
+
+fn bullets(ui: &mut Ui, items: &[&str]) {
+    ui.add_space(4.0);
+    for b in items {
+        ui.horizontal(|ui| {
+            ui.add_space(6.0);
+            ui.label(RichText::new(format!("•  {b}")).font(theme::font(12.5)));
+        });
+    }
+    ui.add_space(10.0);
+}
+
+/// Account: the interface's appearance and what DeckCraft is. DeckCraft has no accounts, so
+/// there is nothing to sign in to.
+fn account(app: &mut SlideApp, ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(340.0);
+            heading(ui, "Appearance");
+            let dark = app.ui.brightness == theme::Brightness::Dark;
+            egui::ComboBox::from_id_salt("backstage_appearance").width(260.0).selected_text(if dark { "Dark" } else { "Light" }).show_ui(ui, |ui| {
+                for (on, label) in [(false, "Light"), (true, "Dark")] {
+                    if ui.selectable_label(dark == on, label).clicked() {
+                        let _ = app.run("view.dark", json!({"on": on}));
+                    }
+                }
+            });
+            ui.add_space(16.0);
+            heading(ui, "User Information");
+            dim(ui, "DeckCraft has no accounts: there is nothing to sign in to, and your presentations stay on your device.");
+        });
+        ui.add_space(40.0);
+        ui.vertical(|ui| {
+            heading(ui, "Product Information");
+            ui.horizontal(|ui| {
+                let (r, _) = ui.allocate_exact_size(vec2(40.0, 40.0), Sense::hover());
+                crate::dialogs::paint_logo(ui.painter(), r);
+                ui.label(RichText::new("DeckCraft").font(theme::bold(24.0)).color(t.text));
+            });
+            dim(ui, &crate::dialogs::version_line());
+            dim(ui, "Open source under MIT OR Apache-2.0. Not affiliated with Microsoft.");
+            ui.add_space(14.0);
+            if task(
+                ui,
+                Icon::Help,
+                "About DeckCraft",
+                "About DeckCraft",
+                "The version, the people and models who built it, and where to find us.",
+                true,
+            ) {
+                let _ = app.run("app.about", json!({}));
+            }
+            ui.hyperlink_to("Join our community on Discord", deckcraft_engine::links::DISCORD);
+            ui.hyperlink_to("Source on GitHub", deckcraft_engine::links::GITHUB);
+        });
+    });
+}
+
+#[cfg(test)]
+#[path = "backstage_tests.rs"]
+mod tests;
diff --git a/crates/ui-egui/src/backstage_tests.rs b/crates/ui-egui/src/backstage_tests.rs
new file mode 100644
index 0000000..115d782
--- /dev/null
+++ b/crates/ui-egui/src/backstage_tests.rs
@@ -0,0 +1,438 @@
+//! The File tab (Backstage, #76) through real egui input: the File tab, Alt+F and Esc, every page,
+//! and the commands its pages run.
+#![allow(clippy::unwrap_used, clippy::expect_used)]
+
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use deckcraft_engine::Session;
+use egui::accesskit::Role;
+use egui::{Key, Modifiers};
+use egui_kittest::Harness;
+use egui_kittest::kittest::Queryable;
+use serde_json::json;
+
+use super::*;
+use crate::{Services, SlideApp};
+
+fn harness(app: SlideApp) -> Harness<'static, SlideApp> {
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).build_ui_state(
+        |ui, app: &mut SlideApp| {
+            app.logic(ui.ctx());
+            app.ui(ui);
+        },
+        app,
+    );
+    // The app keeps asking for frames, so step instead of run().
+    h.run_steps(3);
+    h
+}
+
+fn new_app() -> SlideApp {
+    SlideApp::new(Session::with_new(), Services::default())
+}
+
+/// A folder of its own for one test's files.
+fn temp_dir(name: &str) -> std::path::PathBuf {
+    let d = std::env::temp_dir().join(format!("deckcraft-backstage-{}-{name}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).unwrap();
+    d
+}
+
+/// Desktop services whose Save dialog answers with `dir`/<suggested name> and records the names.
+fn saving_into(dir: &std::path::Path) -> (Services, Rc<RefCell<Vec<String>>>) {
+    let asked: Rc<RefCell<Vec<String>>> = Default::default();
+    let log = asked.clone();
+    let dir = dir.to_path_buf();
+    let services = Services {
+        pick_save: Some(Box::new(move |suggested: &str| {
+            log.borrow_mut().push(suggested.to_string());
+            Some(dir.join(suggested).to_string_lossy().to_string())
+        })),
+        ..Default::default()
+    };
+    (services, asked)
+}
+
+/// Is `r` in the side menu (the harness insets the window by its default margin)?
+fn in_nav(r: egui::Rect) -> bool {
+    r.left() < 20.0 && r.right() <= NAV_W + 20.0
+}
+
+/// Clicks the button called `label` on the page (not the side menu's entry of the same name).
+fn click_on_page(h: &Harness<'_, SlideApp>, label: &str) {
+    let node = h
+        .query_all_by_role_and_label(Role::Button, label)
+        .find(|n| !in_nav(n.rect()))
+        .or_else(|| h.query_all_by_label(label).find(|n| !in_nav(n.rect())));
+    node.unwrap_or_else(|| panic!("no “{label}” button on the page")).click();
+}
+
+/// Clicks the side menu's entry called `label`.
+fn click_nav(h: &Harness<'_, SlideApp>, label: &str) {
+    let node = h.query_all_by_label(label).find(|n| in_nav(n.rect()));
+    node.unwrap_or_else(|| panic!("no “{label}” in the side menu")).click();
+}
+
+fn page(h: &Harness<'_, SlideApp>) -> Option<Page> {
+    h.state().backstage.as_ref().map(|b| b.page)
+}
+
+#[test]
+fn page_ids_round_trip_and_unknown_ids_are_refused() {
+    for p in Page::ALL {
+        assert_eq!(Page::parse(p.id()), Some(p));
+    }
+    assert_eq!(Page::parse(" SAVEAS "), Some(Page::SaveAs));
+    assert_eq!(Page::parse("share"), None);
+    assert_eq!(Page::parse(""), None);
+    let (top, bottom) = entries(false);
+    assert_eq!(top, vec![Nav::Page(Page::Home), Nav::Page(Page::New), Nav::Page(Page::Open)], "the start screen has no presentation pages");
+    assert_eq!(bottom, vec![Nav::Page(Page::Account), Nav::Options]);
+    assert_eq!(entries(true).0.len(), 9);
+    assert_eq!(split_path("/home/me/Talk.pptx"), ("Talk.pptx".into(), "/home/me".into()));
+    assert_eq!(format_bytes(512), "512 bytes");
+    assert_eq!(format_bytes(33_485), "32.7 KB");
+}
+
+/// The File tab opens Home in place of the ribbon; Esc and the back arrow return.
+#[test]
+fn the_file_tab_opens_the_backstage_and_esc_or_back_returns() {
+    let mut h = harness(new_app());
+    assert!(h.query_by_label("Blank Presentation").is_none(), "the slide shows first");
+    h.get_by_label("File").click();
+    h.run_steps(3);
+    assert_eq!(page(&h), Some(Page::Home));
+    assert!(h.state().backstage_open());
+    assert!(h.query_by_label("Blank Presentation").is_some(), "Home offers new presentations");
+    assert!(h.query_by_label("File").is_none(), "the ribbon is hidden");
+    h.key_press(Key::Escape);
+    h.run_steps(3);
+    assert!(!h.state().backstage_open(), "Esc goes back to the slide");
+    assert!(h.query_by_label("File").is_some());
+
+    h.get_by_label("File").click();
+    h.run_steps(3);
+    h.get_by_label("Back").click();
+    h.run_steps(3);
+    assert!(!h.state().backstage_open(), "so does the back arrow");
+    assert_eq!(h.state().session.documents().len(), 1, "nothing was created or closed");
+}
+
+/// Alt+F opens it with the keyboard in the side menu; arrows walk it (pages show as they get the
+/// focus); Enter runs an action; Esc goes back.
+#[test]
+fn alt_f_arrows_enter_and_esc_drive_the_side_menu() {
+    let mut h = harness(new_app());
+    h.key_press_modifiers(Modifiers::ALT, Key::F);
+    h.run_steps(3);
+    assert_eq!(page(&h), Some(Page::Home));
+    assert_eq!(h.state().backstage.as_ref().and_then(|b| b.focus), Some(0));
+    for want in [Page::New, Page::Open, Page::Info] {
+        h.key_press(Key::ArrowDown);
+        h.run_steps(2);
+        assert_eq!(page(&h), Some(want));
+    }
+    // Save has the focus now; the page stays Info until it is run.
+    h.key_press(Key::ArrowDown);
+    h.run_steps(2);
+    assert_eq!(page(&h), Some(Page::Info));
+    // A presentation that was never saved goes to Save As, as in PowerPoint.
+    h.key_press(Key::Enter);
+    h.run_steps(2);
+    assert_eq!(page(&h), Some(Page::SaveAs));
+    // Up from the top wraps to Options at the bottom.
+    for _ in 0..20 {
+        h.key_press(Key::ArrowUp);
+    }
+    h.run_steps(2);
+    h.key_press(Key::Escape);
+    h.run_steps(3);
+    assert!(!h.state().backstage_open());
+    assert!(!h.state().session.active().unwrap().is_dirty(), "the keys never reached the slide");
+}
+
+/// Every page draws its own content.
+#[test]
+fn every_page_renders() {
+    let mut h = harness(new_app());
+    let last_theme = deckcraft_model::theme::builtin_themes().last().map(|t| t.name.clone()).unwrap();
+    let checks: [(Page, &str); 8] = [
+        (Page::Home, "Recent"),
+        (Page::New, &last_theme),
+        (Page::Open, "Browse"),
+        (Page::Info, "Hidden slides"),
+        (Page::SaveAs, "Not saved yet"),
+        (Page::Print, "Print Hidden Slides"),
+        (Page::Export, "Create PDF Document"),
+        (Page::Account, "About DeckCraft"),
+    ];
+    for (p, marker) in checks {
+        h.state_mut().run("app.backstage", json!({"page": p.id()})).unwrap();
+        h.run_steps(3);
+        assert_eq!(page(&h), Some(p));
+        assert!(h.query_all_by_label_contains(marker).next().is_some(), "{} shows “{marker}”", p.label());
+        let selected = h.query_all_by_label(p.label()).any(|n| in_nav(n.rect()));
+        assert!(selected, "{} is in the side menu", p.label());
+    }
+    assert!(h.state_mut().run("app.backstage", json!({"page": "share"})).is_err(), "Share (cloud) isn't offered");
+}
+
+/// New and Home create presentations, which leaves the File tab.
+#[test]
+fn new_creates_a_presentation() {
+    let mut h = harness(new_app());
+    h.state_mut().run("app.backstage", json!({"page": "new"})).unwrap();
+    h.run_steps(3);
+    h.get_by_label("Blank Presentation").click();
+    h.run_steps(3);
+    assert_eq!(h.state().session.documents().len(), 2);
+    assert!(h.state().backstage.is_none(), "the new presentation shows");
+
+    let theme = deckcraft_model::theme::builtin_themes().into_iter().nth(1).unwrap();
+    h.state_mut().run("app.backstage", json!({})).unwrap();
+    h.run_steps(3);
+    h.get_by_label(&theme.name).click();
+    h.run_steps(3);
+    assert_eq!(h.state().session.documents().len(), 3);
+    assert_eq!(h.state().session.active().unwrap().doc.masters[0].theme.name, theme.name);
+    assert!(h.state().backstage.is_none());
+}
+
+/// Open lists recent presentations by name (filtered by the search box) and opens one.
+#[test]
+fn open_lists_recent_files_and_opens_one() {
+    let dir = temp_dir("open");
+    let path = dir.join("Quarterly review.pptx").to_string_lossy().to_string();
+    let mut s = Session::with_new();
+    s.execute("file.saveAs", &json!({"path": path})).unwrap();
+    let mut app = SlideApp::new(Session::with_new(), Services::default());
+    app.ui.recent = vec![path.clone(), dir.join("Other.pptx").to_string_lossy().to_string()];
+    let mut h = harness(app);
+    h.state_mut().run("app.backstage", json!({"page": "open"})).unwrap();
+    h.run_steps(3);
+    assert!(h.query_by_label("Other.pptx").is_some());
+    h.state_mut().backstage.as_mut().unwrap().query = "quarter".into();
+    h.run_steps(2);
+    assert!(h.query_by_label("Other.pptx").is_none(), "the search box filters by name");
+    h.get_by_label("Quarterly review.pptx").click();
+    h.run_steps(3);
+    assert_eq!(h.state().session.documents().len(), 2);
+    assert_eq!(h.state().session.active().unwrap().path.as_deref(), Some(path.as_str()));
+    assert!(h.state().backstage.is_none(), "the opened presentation shows");
+    assert_eq!(h.state().ui.recent.first(), Some(&path));
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// Save As saves through the Save dialog and the presentation takes the new file; Export writes
+/// copies (PDF, another file type) and leaves the presentation's own file alone.
+#[test]
+fn save_as_and_export_run_the_file_commands() {
+    let dir = temp_dir("saveas");
+    let (services, asked) = saving_into(&dir);
+    let mut h = harness(SlideApp::new(Session::with_new(), services));
+    let title = h.state().session.active().unwrap().title();
+
+    // Save on a presentation without a file goes to Save As.
+    h.state_mut().run("app.backstage", json!({})).unwrap();
+    h.run_steps(3);
+    click_nav(&h, "Save");
+    h.run_steps(3);
+    assert_eq!(page(&h), Some(Page::SaveAs));
+    click_on_page(&h, "Save");
+    h.run_steps(3);
+    let pptx = dir.join(format!("{title}.pptx")).to_string_lossy().to_string();
+    assert!(std::path::Path::new(&pptx).is_file(), "saved as PowerPoint by default");
+    assert_eq!(h.state().session.active().unwrap().path.as_deref(), Some(pptx.as_str()));
+    assert!(h.state().backstage.is_none(), "a save returns to the slide");
+
+    // Export › Create PDF Document.
+    h.state_mut().run("app.backstage", json!({"page": "export"})).unwrap();
+    h.run_steps(3);
+    click_on_page(&h, "Create PDF");
+    h.run_steps(3);
+    let pdf = std::fs::read(dir.join(format!("{title}.pdf"))).unwrap();
+    assert!(pdf.starts_with(b"%PDF"));
+
+    // Export › Change File Type › Outline.
+    click_on_page(&h, "Change File Type");
+    h.run_steps(3);
+    click_on_page(&h, "Outline (*.txt)");
+    h.run_steps(2);
+    click_on_page(&h, "Save As");
+    h.run_steps(3);
+    assert!(dir.join(format!("{title}.txt")).is_file());
+    assert_eq!(h.state().session.active().unwrap().path.as_deref(), Some(pptx.as_str()), "exports are copies");
+    assert_eq!(*asked.borrow(), vec![format!("{title}.pptx"), format!("{title}.pdf"), format!("{title}.txt")]);
+
+    // Save with a file saves in place and goes back.
+    h.state_mut().run("slide.new", json!({})).unwrap();
+    h.state_mut().run("app.backstage", json!({})).unwrap();
+    h.run_steps(3);
+    click_nav(&h, "Save");
+    h.run_steps(3);
+    assert!(!h.state().session.active().unwrap().is_dirty());
+    assert!(h.state().backstage.is_none());
+    assert_eq!(asked.borrow().len(), 3, "no Save dialog for a presentation with a file");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// Close closes a saved presentation at once and asks about unsaved changes first.
+#[test]
+fn close_closes_and_asks_about_unsaved_changes() {
+    let mut h = harness(new_app());
+    h.state_mut().run("app.backstage", json!({})).unwrap();
+    h.run_steps(3);
+    click_nav(&h, "Close");
+    h.run_steps(3);
+    assert_eq!(h.state().session.documents().len(), 0);
+    assert_eq!(page(&h), Some(Page::Home), "the start screen shows");
+    assert!(h.query_by_label("Back").is_none() && h.query_by_label("Close").is_none(), "nothing to go back to or close");
+
+    // Unsaved: Cancel keeps it, Don't Save closes it.
+    h.get_by_label("Blank Presentation").click();
+    h.run_steps(3);
+    h.state_mut().run("slide.new", json!({})).unwrap();
+    h.state_mut().run("app.backstage", json!({})).unwrap();
+    h.run_steps(3);
+    click_nav(&h, "Close");
+    h.run_steps(3);
+    assert_eq!(h.state().dialog.as_ref().map(|d| d.id.as_str()), Some("close"));
+    h.get_by_label("Cancel").click();
+    h.run_steps(3);
+    assert_eq!(h.state().session.documents().len(), 1);
+    assert!(h.state().backstage_open(), "Cancel leaves the File tab as it was");
+    click_nav(&h, "Close");
+    h.run_steps(3);
+    h.get_by_label("Don't Save").click();
+    h.run_steps(3);
+    assert_eq!(h.state().session.documents().len(), 0);
+}
+
+/// Ctrl+W asks too (it used to close unsaved presentations without a word).
+#[test]
+fn ctrl_w_asks_before_closing_unsaved_changes() {
+    let mut h = harness(new_app());
+    h.state_mut().run("slide.new", json!({})).unwrap();
+    h.run_steps(2);
+    h.key_press_modifiers(Modifiers::COMMAND, Key::W);
+    h.run_steps(3);
+    assert_eq!(h.state().session.documents().len(), 1);
+    assert_eq!(h.state().dialog.as_ref().map(|d| d.id.as_str()), Some("close"));
+}
+
+/// Info shows the presentation's counts and properties, and edits them through file.properties.
+#[test]
+fn info_shows_and_edits_the_properties() {
+    let mut app = new_app();
+    app.run("file.properties", json!({"title": "Quarterly", "keywords": "sales"})).unwrap();
+    app.run("slide.new", json!({})).unwrap();
+    app.run("slide.hide", json!({})).unwrap();
+    let mut h = harness(app);
+    h.state_mut().run("app.backstage", json!({"page": "info"})).unwrap();
+    h.run_steps(3);
+    assert_eq!(h.get_by_role_and_label(Role::TextInput, "Title").value().as_deref(), Some("Quarterly"));
+    assert_eq!(h.get_by_role_and_label(Role::TextInput, "Tags").value().as_deref(), Some("sales"));
+    assert!(h.query_all_by_label("Not saved yet").next().is_some());
+    let author = h.get_by_role_and_label(Role::TextInput, "Author");
+    author.click();
+    h.run_steps(2);
+    h.get_by_role_and_label(Role::TextInput, "Author").type_text("Ada");
+    h.run_steps(2);
+    h.key_press(Key::Enter);
+    h.run_steps(3);
+    assert_eq!(h.state().session.active().unwrap().doc.props.author, "Ada");
+    // Esc in a field leaves the field; the next one goes back.
+    assert!(h.state().backstage_open());
+}
+
+/// With nothing open the File tab is the start screen: Home, New and Open, no back arrow, and Esc
+/// has nowhere to go.
+#[test]
+fn the_start_screen_is_file_home() {
+    let mut h = harness(SlideApp::new(Session::new(), Services::default()));
+    assert_eq!(page(&h), Some(Page::Home));
+    assert!(h.query_by_label("Back").is_none());
+    assert!(h.query_all_by_label("Info").next().is_none());
+    h.key_press(Key::Escape);
+    h.run_steps(2);
+    assert_eq!(page(&h), Some(Page::Home));
+    h.key_press(Key::ArrowDown);
+    h.run_steps(2);
+    assert_eq!(page(&h), Some(Page::New));
+    assert!(h.state_mut().run("app.backstage", json!({"page": "print"})).is_err(), "nothing to print");
+    h.get_by_label("Blank Presentation").click();
+    h.run_steps(3);
+    assert_eq!(h.state().session.documents().len(), 1);
+    assert!(h.state().backstage.is_none());
+}
+
+/// Print previews the pages its settings make and prints through a PDF opened in the system
+/// viewer.
+#[test]
+fn print_previews_pages_and_prints_a_pdf() {
+    let dir = temp_dir("print");
+    let (services, _) = saving_into(&dir);
+    let mut app = SlideApp::new(Session::with_new(), services);
+    for _ in 0..3 {
+        app.run("slide.new", json!({})).unwrap();
+    }
+    app.run("slide.hide", json!({"index": 1})).unwrap();
+    let mut h = harness(app);
+    h.key_press_modifiers(Modifiers::COMMAND, Key::P);
+    h.run_steps(3);
+    assert_eq!(page(&h), Some(Page::Print), "Ctrl+P opens File › Print");
+    assert!(h.query_by_label("1 of 3").is_some(), "hidden slides are left out");
+    h.state_mut().backstage.as_mut().unwrap().print_layout = "h4";
+    h.run_steps(2);
+    assert!(h.query_by_label("1 of 1").is_some(), "four slides a page");
+    h.state_mut().backstage.as_mut().unwrap().print_layout = "slides";
+    h.state_mut().backstage.as_mut().unwrap().print_hidden = true;
+    h.run_steps(2);
+    assert!(h.query_by_label("1 of 4").is_some());
+    h.get_by_label("Next Page").click();
+    h.run_steps(2);
+    assert!(h.query_by_label("2 of 4").is_some());
+    {
+        let bs = h.state_mut().backstage.as_mut().unwrap();
+        bs.print_scope = PrintScope::Custom;
+        bs.print_range = "9".into();
+    }
+    h.run_steps(2);
+    assert!(h.query_by_label_contains("outside them").is_some(), "a bad range says why");
+    h.state_mut().backstage.as_mut().unwrap().print_range = "1-2".into();
+    h.run_steps(2);
+    click_on_page(&h, "Print");
+    h.run_steps(2);
+    let url = h.state().pending_urls.first().cloned().unwrap_or_default();
+    // The URL was handed to egui at the end of the frame; check what it pointed at.
+    let printed = std::env::temp_dir().join(format!("{} (print).pdf", h.state().session.active().unwrap().title()));
+    assert!(printed.is_file(), "the PDF to print was written: {url}");
+    assert!(std::fs::read(&printed).unwrap().starts_with(b"%PDF"));
+    let _ = std::fs::remove_file(printed);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn print_slides_follow_the_settings() {
+    let mut s = Session::with_new();
+    for _ in 0..4 {
+        s.execute("slide.new", &json!({})).unwrap();
+    }
+    s.execute("slide.hide", &json!({"index": 2})).unwrap();
+    let doc = s.doc().unwrap().doc.clone();
+    let mut bs = Backstage::new(Page::Print, (1, Some(0)));
+    assert_eq!(print_slides(&doc, &bs, 0).unwrap(), vec![0, 1, 3, 4]);
+    bs.print_hidden = true;
+    assert_eq!(print_slides(&doc, &bs, 0).unwrap().len(), 5);
+    bs.print_scope = PrintScope::Current;
+    assert_eq!(print_slides(&doc, &bs, 2).unwrap(), vec![2], "the current slide prints even when hidden");
+    bs.print_scope = PrintScope::Custom;
+    bs.print_range = "2-4".into();
+    bs.print_hidden = false;
+    assert_eq!(print_slides(&doc, &bs, 0).unwrap(), vec![1, 3]);
+    bs.print_layout = "h6";
+    assert_eq!(print_params(&bs, &[1, 3])["perPage"], 6);
+    assert_eq!(print_params(&bs, &[1, 3])["layout"], "handouts");
+}
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index bf138c3..253765b 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -216,7 +216,7 @@ pub fn ime_area(app: &SlideApp, xf: Xf) -> Option<Rect> {
 /// separate jamo (ㅇ ㅏ ㄴ) instead of syllables. A focused text field sets its own.
 fn ime_output(app: &SlideApp, ui: &Ui, xf: Xf) {
     let ctx = ui.ctx();
-    if ctx.memory(|m| m.focused().is_some()) || app.dialog.as_ref().is_some_and(|d| d.modal()) || app.palette.is_some() || app.home_open() {
+    if ctx.memory(|m| m.focused().is_some()) || app.dialog.as_ref().is_some_and(|d| d.modal()) || app.palette.is_some() || app.backstage_open() {
         return;
     }
     let Some(r) = ime_area(app, xf) else { return };
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index 84f511e..d344d91 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -73,7 +73,8 @@ pub fn inspect(app: &SlideApp, ctx: &egui::Context) -> Value {
         "slideRect": app.slide_rect.map(|c| json!([c.left(), c.top(), c.width(), c.height()])),
         "canvasScale": app.canvas_scale,
         "dialog": app.dialog.as_ref().map(|d| d.id.clone()),
-        "home": app.home_open(),
+        "home": app.backstage_open(),
+        "backstage": app.backstage.as_ref().map(|b| b.page.id()),
         "showing": app.show.as_ref().map(|s| json!({"slide": s.state.slide, "step": s.state.step, "ended": s.ended})),
         "documents": app.session.documents().iter().map(|d| json!({"title": d.title(), "dirty": d.is_dirty(), "path": d.path})).collect::<Vec<_>>(),
         "status": app.status.as_ref().map(|s| s.0.clone()),
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index 73ce180..d1934be 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -1,11 +1,11 @@
-//! Dialogs (Insert Table, Slide Size, Header & Footer, Hyperlink, Set Up Show, Zoom, …), the start
-//! screen and the About window.
+//! Dialogs (Insert Table, Slide Size, Header & Footer, Hyperlink, Set Up Show, Zoom, …) and the
+//! About window. The start screen is File › Home (`backstage.rs`).
 
 use egui::{Align2, Color32, CornerRadius, Rect, Sense, Stroke, Ui, pos2, vec2};
 use serde_json::{Value, json};
 
+use crate::SlideApp;
 use crate::theme::{self, Tokens};
-use crate::{SlideApp, ribbon};
 
 #[derive(Clone, Debug, serde::Serialize)]
 pub struct Dialog {
@@ -290,6 +290,37 @@ fn body(app: &mut SlideApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             });
             done
         }
+        "close" => {
+            // File › Close and Ctrl+W on a presentation with unsaved changes.
+            let Some(name) = app.session.active().map(|d| d.title()) else { return true };
+            ui.label(egui::RichText::new(format!("Do you want to save the changes you made to “{name}”?")).strong());
+            ui.label("Your changes will be lost if you don't save them.");
+            ui.add_space(8.0);
+            let mut done = false;
+            ui.horizontal(|ui| {
+                let t = Tokens::get(ui.ctx());
+                if ui.add(egui::Button::new("Don't Save").min_size(vec2(84.0, 24.0))).clicked() {
+                    run(app, "file.close", json!({}));
+                    done = true;
+                }
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    let save = ui.add(egui::Button::new(egui::RichText::new("Save").color(t.accent_text)).fill(t.accent).min_size(vec2(72.0, 24.0)));
+                    if save.clicked() || ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+                        app.save();
+                        // In the browser a save is a download: the presentation stays "unsaved".
+                        let web = app.services.pick_save.is_none() && app.services.download.is_some();
+                        if web || app.session.active().is_some_and(|d| !d.is_dirty()) {
+                            run(app, "file.close", json!({}));
+                        }
+                        done = true;
+                    }
+                    if ui.add(egui::Button::new("Cancel").min_size(vec2(72.0, 24.0))).clicked() {
+                        done = true;
+                    }
+                });
+            });
+            done
+        }
         "zoom" => {
             for pct in [400, 200, 150, 100, 75, 66, 50, 33] {
                 if ui.radio(false, format!("{pct}%")).clicked() {
@@ -430,45 +461,8 @@ fn body(app: &mut SlideApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             };
             let (ok, cancel) = buttons(ui, "Export");
             if ok {
-                let name = app.session.active().map(|s| s.title()).unwrap_or_else(|| "Presentation".into());
-                let (ext, all) = match fmt.as_str() {
-                    "pdf" => ("pdf", false),
-                    "pngAll" => ("png", true),
-                    "jpeg" => ("jpg", false),
-                    "pptx" => ("pptx", false),
-                    "outline" => ("txt", false),
-                    _ => ("png", false),
-                };
-                let suggested = format!("{name}.{ext}");
-                if let Some(pick) = app.services.pick_save.as_mut() {
-                    if let Some(path) = pick(&suggested) {
-                        let mut params = json!({"path": path, "all": all});
-                        if ext == "pdf"
-                            && let (Some(o), Some(extra)) = (params.as_object_mut(), pdf_params.as_object())
-                        {
-                            o.extend(extra.clone());
-                        }
-                        let r = app.session.execute("file.export", &params);
-                        match r {
-                            Ok(_) => app.set_status(format!("Exported {path}")),
-                            Err(e) => app.set_status(e.to_string()),
-                        }
-                    }
-                } else if let (Some(dl), Some(s)) = (app.services.download.as_mut(), app.session.active()) {
-                    let bytes = match ext {
-                        "png" | "jpg" => {
-                            let img = deckcraft_render::render_slide(
-                                &s.doc,
-                                s.selection.slide,
-                                &deckcraft_render::RenderOpts { scale: 2.0, ..Default::default() },
-                            );
-                            if ext == "png" { img.to_png() } else { img.to_jpeg(92) }
-                        }
-                        "pdf" => deckcraft_pdf_bytes(&s.doc, &pdf_params),
-                        other => deckcraft_engine::cmd::file::save_bytes(&s.doc, other).unwrap_or_default(),
-                    };
-                    dl(&suggested, &bytes);
-                }
+                let extra = if fmt == "pdf" { pdf_params } else { json!({}) };
+                app.export_as(&fmt, extra);
             }
             ok || cancel
         }
@@ -835,129 +829,3 @@ pub fn paint_logo(p: &egui::Painter, r: Rect) {
         Stroke::NONE,
     ));
 }
-
-/// The start screen (no presentation open): new from themes, open, recent files.
-pub fn start_screen(app: &mut SlideApp, ui: &mut Ui) {
-    let t = Tokens::get(ui.ctx());
-    egui::ScrollArea::vertical().show(ui, |ui| {
-        ui.add_space(24.0);
-        ui.horizontal(|ui| {
-            ui.add_space(40.0);
-            let (r, _) = ui.allocate_exact_size(vec2(40.0, 40.0), Sense::hover());
-            paint_logo(ui.painter(), r);
-            ui.label(egui::RichText::new("DeckCraft").font(theme::bold(26.0)));
-        });
-        if app.home_open() {
-            let title = app.session.active().map(|d| d.title()).unwrap_or_default();
-            ui.add_space(8.0);
-            ui.horizontal(|ui| {
-                ui.add_space(40.0);
-                if ui.button(format!("← Back to {title}")).on_hover_text("Esc").clicked() {
-                    let _ = app.run("app.home", json!({"on": false}));
-                }
-            });
-        }
-        ui.add_space(16.0);
-        ui.horizontal(|ui| {
-            ui.add_space(40.0);
-            ui.label(egui::RichText::new("New presentation").font(theme::bold(16.0)));
-        });
-        ui.add_space(8.0);
-        inset_wrapped(ui, |ui| {
-            for th in deckcraft_model::theme::builtin_themes() {
-                let (r, resp) = ui.allocate_exact_size(vec2(180.0, 128.0), Sense::click());
-                let tile = Rect::from_min_size(r.min, vec2(180.0, 101.0));
-                ribbon::paint_theme_tile(ui.painter(), tile, &th);
-                if resp.hovered() {
-                    ui.painter().rect_stroke(tile, CornerRadius::same(2), Stroke::new(2.0, t.accent), egui::StrokeKind::Outside);
-                }
-                ui.painter().text(pos2(r.min.x, r.max.y - 10.0), Align2::LEFT_CENTER, &th.name, theme::font(12.0), t.text);
-                if resp.clicked() {
-                    let _ = app.run("file.new", json!({"theme": th.name}));
-                }
-            }
-        });
-        ui.add_space(16.0);
-        ui.horizontal(|ui| {
-            ui.add_space(40.0);
-            if ui.button("Open…").clicked() {
-                let _ = app.run("app.openDialog", json!({}));
-            }
-            if ui.button("Open the sample deck").clicked()
-                && let Err(e) = deckcraft_engine::sample::open_sample(&mut app.session)
-            {
-                app.set_status(e.to_string());
-            }
-        });
-        if !app.ui.recent.is_empty() {
-            ui.add_space(16.0);
-            ui.horizontal(|ui| {
-                ui.add_space(40.0);
-                ui.label(egui::RichText::new("Recent").font(theme::bold(16.0)));
-            });
-            for p in app.ui.recent.clone() {
-                ui.horizontal(|ui| {
-                    ui.add_space(40.0);
-                    if ui.link(&p).clicked()
-                        && let Err(e) = app.open_path(&p)
-                    {
-                        app.set_status(e);
-                    }
-                });
-            }
-        }
-        ui.add_space(30.0);
-        ui.horizontal(|ui| {
-            ui.add_space(40.0);
-            ui.hyperlink_to("Join the ArtCraft community on Discord", deckcraft_engine::links::DISCORD);
-        });
-    });
-}
-
-/// Wrapped rows that all start 40 points in from the left, in line with the start screen's
-/// headings. The inset is a margin on the container: an `add_space` inside `horizontal_wrapped`
-/// would indent only the first row.
-fn inset_wrapped(ui: &mut Ui, add_contents: impl FnOnce(&mut Ui)) {
-    egui::Frame::NONE.inner_margin(egui::Margin { left: 40, ..Default::default() }).show(ui, |ui| {
-        ui.horizontal_wrapped(add_contents);
-    });
-}
-
-/// PDF bytes with the export dialog's options (web: downloaded instead of written).
-fn deckcraft_pdf_bytes(doc: &deckcraft_model::Presentation, params: &serde_json::Value) -> Vec<u8> {
-    deckcraft_engine::cmd::file::pdf_bytes(doc, params).unwrap_or_default()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::cell::{Cell, RefCell};
-
-    /// Start screen theme tiles that wrap onto a second row keep the 40-point inset (#17).
-    #[test]
-    fn inset_wrapped_indents_every_row() {
-        let left = Cell::new(0.0_f32);
-        let tiles = RefCell::new(Vec::<Rect>::new());
-        let mut harness = egui_kittest::Harness::builder().with_size(vec2(500.0, 400.0)).build_ui(|ui| {
-            left.set(ui.max_rect().left());
-            tiles.borrow_mut().clear();
-            inset_wrapped(ui, |ui| {
-                for _ in 0..4 {
-                    let (r, _) = ui.allocate_exact_size(vec2(180.0, 128.0), Sense::click());
-                    tiles.borrow_mut().push(r);
-                }
-            });
-        });
-        harness.run();
-        let tiles = tiles.borrow().clone();
-        let first_top = tiles.first().map_or(0.0, |r| r.top());
-        assert!(tiles.iter().any(|r| r.top() > first_top), "tiles should wrap onto a second row: {tiles:?}");
-        let mut row_top = f32::NEG_INFINITY;
-        for r in &tiles {
-            if r.top() > row_top {
-                row_top = r.top();
-                assert!((r.left() - (left.get() + 40.0)).abs() < 0.5, "row starts at {} instead of {}", r.left(), left.get() + 40.0);
-            }
-        }
-    }
-}
diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs
index aa3f2b5..5450914 100644
--- a/crates/ui-egui/src/icons.rs
+++ b/crates/ui-egui/src/icons.rs
@@ -306,6 +306,13 @@ icons! {
     Collapse => "collapse",
     Expand => "expand",
     Pin => "pin",
+    // File tab (Backstage)
+    BackCircle => "back-circle",
+    SaveAs => "save-as",
+    Account => "account",
+    Recent => "recent",
+    NewFile => "new-file",
+    OpenFolder => "open-folder",
     // Status bar (small, monochrome)
     NotesSmall => "notes-small",
     CommentsSmall => "comments-small",
@@ -2361,6 +2368,33 @@ fn draw(p: &Pen<'_>, icon: Icon) {
             p.rshape(&m(&[(-4.2, -10.0), (4.2, -10.0), (4.2, -7.0), (-4.2, -7.0)]), 0.6, R, N);
         }
 
+        // ----- File tab (Backstage) navigation: outlines in the ink colour -----
+        I::BackCircle => {
+            p.circle((12.0, 12.0), 9.8, N, K);
+            p.arrow((17.0, 12.0), (6.5, 12.0), K);
+        }
+        I::SaveAs => {
+            p.rline(&[(11.0, 20.5), (2.5, 20.5), (2.5, 3.0), (15.0, 3.0), (18.0, 6.0), (18.0, 10.5)], 1.2, K);
+            p.rect(6.0, 3.0, 13.0, 7.5, 0.6, N, K);
+            p.seg_w((13.5, 21.0), (21.5, 13.0), O, 1.4);
+            p.seg_w((12.5, 22.0), (13.5, 21.0), K, 1.0);
+        }
+        I::Account => {
+            p.circle((12.0, 8.0), 4.5, N, K);
+            p.line(&arc_pts((12.0, 22.0), 8.5, 7.5, 180.0, 360.0), K);
+        }
+        I::Recent => {
+            p.circle((12.0, 12.0), 9.8, N, K);
+            p.line(&[(12.0, 6.0), (12.0, 12.0), (16.0, 14.5)], K);
+        }
+        I::NewFile => {
+            p.rline(&[(14.0, 2.5), (5.0, 2.5), (5.0, 21.5), (19.0, 21.5), (19.0, 7.5), (14.0, 2.5), (14.0, 7.5), (19.0, 7.5)], 0.8, K);
+        }
+        I::OpenFolder => {
+            p.rline(&[(18.5, 9.0), (18.5, 6.5), (10.0, 6.5), (8.0, 4.0), (2.5, 4.0), (2.5, 19.5), (18.0, 19.5)], 1.0, K);
+            p.rline(&[(2.5, 19.5), (6.0, 10.0), (22.0, 10.0), (18.0, 19.5)], 1.0, K);
+        }
+
         // ----- Status bar (monochrome) -----
         I::NotesSmall => {
             p.rect(3.0, 4.0, 21.0, 20.0, 1.5, N, K);
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index e536878..ec97e6e 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -6,6 +6,7 @@
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 #![forbid(unsafe_code)]
 
+pub mod backstage;
 pub mod canvas;
 pub mod control;
 pub mod credits;
@@ -154,6 +155,9 @@ pub const UI_COMMANDS: &[(&str, &str, Option<&str>, &str)] = &[
     ("show.presenter", "Presenter View", None, "{on?: bool}"),
     ("show.end", "End Show", None, "{}"),
     ("app.home", "Home", None, "{on?}"),
+    ("app.backstage", "File", Some("Alt+F"), "{page?: home|new|open|info|saveAs|print|export|account, on?: bool}"),
+    ("app.closePresentation", "Close", Some("Cmd+W"), "{}"),
+    ("app.print", "Print", Some("Cmd+P"), "{layout?, perPage?, slides?, includeHidden?, frame?}"),
     ("app.about", "About DeckCraft", None, "{}"),
     ("app.palette", "Command Palette", Some("Cmd+Shift+P"), "{}"),
     ("app.preferences", "Preferences…", Some("Cmd+,"), "{}"),
@@ -200,9 +204,10 @@ pub struct SlideApp {
     pub palette: Option<(String, usize)>,
     /// Integrated title bar (macOS traffic lights over our chrome).
     pub integrated_titlebar: bool,
-    /// The start screen is shown over the open presentations (Home), with the document count
-    /// and active index when it was opened: opening or creating a presentation leaves it.
-    pub home: Option<(usize, Option<usize>)>,
+    /// The File tab's full-window view (Backstage). Over a presentation it replaces the ribbon,
+    /// slides and status bar until Esc or Back; with nothing open it is the start screen. Opening,
+    /// creating or closing a presentation leaves it.
+    pub backstage: Option<backstage::Backstage>,
     pending_urls: Vec<String>,
     shot_token: u64,
     queued_shots: Vec<(u64, f64, u32)>,
@@ -247,7 +252,7 @@ impl SlideApp {
             canvas_region: None,
             palette: None,
             integrated_titlebar: false,
-            home: None,
+            backstage: None,
             pending_urls: vec![],
             shot_token: 0,
             queued_shots: vec![],
@@ -289,13 +294,153 @@ impl SlideApp {
         r
     }
 
-    fn docs_key(&self) -> (usize, Option<usize>) {
+    pub(crate) fn docs_key(&self) -> (usize, Option<usize>) {
         (self.session.documents().len(), self.session.active_index())
     }
 
-    /// Home is open over a presentation (not just the start screen with nothing open).
-    pub fn home_open(&self) -> bool {
-        self.home.is_some() && self.session.active().is_some()
+    /// The File tab's view is open over a presentation (not just the start screen with nothing
+    /// open).
+    pub fn backstage_open(&self) -> bool {
+        self.backstage.is_some() && self.session.active().is_some()
+    }
+
+    /// Opens the File tab's view on `page` (keeping its state when it is already open).
+    pub fn open_backstage(&mut self, page: backstage::Page) {
+        let key = self.docs_key();
+        match &mut self.backstage {
+            Some(b) => b.go(page),
+            None => self.backstage = Some(backstage::Backstage::new(page, key)),
+        }
+    }
+
+    /// Back to the presentation (no effect on the start screen, where nothing is open).
+    pub fn close_backstage(&mut self) {
+        if self.session.active().is_some() {
+            self.backstage = None;
+        }
+    }
+
+    /// Keeps the File tab's view in step with the open presentations: it closes when one is
+    /// opened, created or closed (the result shows), and it is the start screen when none is open.
+    fn sync_backstage(&mut self) {
+        let key = self.docs_key();
+        let has_doc = self.session.active().is_some();
+        let stale = self.backstage.as_ref().is_some_and(|b| b.docs != key);
+        if has_doc && stale {
+            self.backstage = None;
+        } else if !has_doc && (stale || self.backstage.is_none()) {
+            self.backstage = Some(backstage::Backstage::new(backstage::Page::Home, key));
+        }
+    }
+
+    /// File › Close and Ctrl+W: closes the active presentation, asking first when it has unsaved
+    /// changes (Save, Don't Save, Cancel), as PowerPoint does.
+    pub fn close_presentation(&mut self) {
+        match self.session.active() {
+            None => {}
+            Some(d) if d.is_dirty() => self.dialog = Some(dialogs::Dialog::new("close")),
+            Some(_) => {
+                let _ = self.run("file.close", json!({}));
+            }
+        }
+    }
+
+    /// The file name a save or export suggests: the presentation's title with `ext`.
+    fn suggested_name(&self, ext: &str) -> String {
+        let name = self.session.active().map(|d| d.title()).unwrap_or_else(|| "Presentation".into());
+        format!("{name}.{ext}")
+    }
+
+    /// Exports the active presentation as `fmt` (`pdf`, `png`, `pngAll`, `jpeg`, `pptx`,
+    /// `deckcraft`, `outline`) through `file.export`: the save picker on the desktop, a download
+    /// on the web. `extra` adds `file.export` params (the PDF's layout, slides…). The
+    /// presentation keeps its own file. Returns whether a file was written or handed over.
+    pub fn export_as(&mut self, fmt: &str, extra: Value) -> bool {
+        let Some(slide) = self.session.active().map(|d| d.selection.slide) else { return false };
+        let (ext, format, all) = match fmt {
+            "pdf" => ("pdf", "pdf", false),
+            "png" => ("png", "png", false),
+            "pngAll" => ("png", "png", true),
+            "jpeg" | "jpg" => ("jpg", "jpeg", false),
+            "pptx" => ("pptx", "pptx", false),
+            "outline" | "txt" => ("txt", "outline", false),
+            "deckcraft" => ("deckcraft", "deckcraft", false),
+            other => {
+                self.set_status(format!("DeckCraft can't export “{other}”"));
+                return false;
+            }
+        };
+        let suggested = self.suggested_name(ext);
+        if let Some(pick) = self.services.pick_save.as_mut() {
+            let Some(path) = pick(&suggested) else { return false };
+            let mut params = json!({"path": path, "format": format, "all": all});
+            if let (Some(o), Some(x)) = (params.as_object_mut(), extra.as_object()) {
+                o.extend(x.clone());
+            }
+            return match self.run("file.export", params) {
+                Ok(_) => {
+                    self.set_status(format!("Exported {path}"));
+                    true
+                }
+                Err(_) => false,
+            };
+        }
+        let Some(doc) = self.session.active().map(|d| d.doc.clone()) else { return false };
+        let bytes = match format {
+            "png" | "jpeg" => {
+                let img = deckcraft_render::render_slide(&doc, slide, &deckcraft_render::RenderOpts { scale: 2.0, ..Default::default() });
+                Ok(if format == "png" { img.to_png() } else { img.to_jpeg(92) })
+            }
+            "pdf" => deckcraft_engine::cmd::file::pdf_bytes(&doc, &extra),
+            other => deckcraft_engine::cmd::file::save_bytes(&doc, other),
+        };
+        self.download(&suggested, bytes)
+    }
+
+    /// Hands `bytes` to the browser as a download (web); false (with the reason in the status
+    /// bar) when there are no bytes or no way to download.
+    fn download(&mut self, name: &str, bytes: deckcraft_engine::Result<Vec<u8>>) -> bool {
+        match (bytes, self.services.download.as_mut()) {
+            (Ok(b), Some(dl)) => {
+                dl(name, &b);
+                true
+            }
+            (Err(e), _) => {
+                self.set_status(e.to_string());
+                false
+            }
+            (Ok(_), None) => {
+                self.set_status("Saving a copy needs a file picker, which this window doesn't have.");
+                false
+            }
+        }
+    }
+
+    /// File › Print: DeckCraft prints through a PDF. On the desktop the PDF (with the Print page's
+    /// layout, slides and options) is written to the temporary folder and opened in the system's
+    /// PDF viewer, which has the printers; on the web it downloads.
+    pub fn print_pdf(&mut self, params: Value) -> bool {
+        let Some((title, doc)) = self.session.active().map(|d| (d.title(), d.doc.clone())) else { return false };
+        let mut params = if params.is_object() { params } else { json!({}) };
+        if self.services.pick_save.is_none() {
+            // Web: the browser hands the PDF to the user.
+            let bytes = deckcraft_engine::cmd::file::pdf_bytes(&doc, &params);
+            return self.download(&format!("{title}.pdf"), bytes);
+        }
+        let safe: String = title.chars().map(|c| if c.is_alphanumeric() || c == ' ' || c == '-' { c } else { '_' }).collect();
+        let path = std::env::temp_dir().join(format!("{safe} (print).pdf")).to_string_lossy().to_string();
+        if let Some(o) = params.as_object_mut() {
+            o.insert("path".into(), json!(path));
+            o.insert("format".into(), json!("pdf"));
+        }
+        match self.run("file.export", params) {
+            Ok(_) => {
+                self.open_url(&format!("file:///{}", path.replace('\\', "/").trim_start_matches('/')));
+                self.set_status("Opened the presentation as a PDF to print");
+                true
+            }
+            Err(_) => false,
+        }
     }
 
     fn flag(&mut self, params: &Value, cur: bool) -> bool {
@@ -358,8 +503,34 @@ impl SlideApp {
                 self.media.stop_owned(media::Owner::Show);
             }
             "app.home" => {
-                let on = self.flag(p, self.home.is_some());
-                self.home = (on && self.session.active().is_some()).then(|| self.docs_key());
+                let on = self.flag(p, self.backstage_open());
+                if on {
+                    self.open_backstage(backstage::Page::Home);
+                } else {
+                    self.close_backstage();
+                }
+            }
+            "app.backstage" => {
+                if !p.get("on").and_then(Value::as_bool).unwrap_or(true) {
+                    self.close_backstage();
+                    return Ok(json!({"page": self.backstage.as_ref().map(|b| b.page.id())}));
+                }
+                let page = match p.get("page").and_then(Value::as_str) {
+                    Some(id) => backstage::Page::parse(id).ok_or_else(|| format!("unknown File page `{id}`"))?,
+                    None => backstage::Page::Home,
+                };
+                if page.needs_doc() && self.session.active().is_none() {
+                    return Err(format!("File › {} needs an open presentation", page.label()));
+                }
+                self.open_backstage(page);
+                return Ok(json!({"page": page.id()}));
+            }
+            "app.closePresentation" => self.close_presentation(),
+            "app.print" => {
+                if self.session.active().is_none() {
+                    return Err("nothing to print: no presentation is open".into());
+                }
+                return Ok(json!({"printed": self.print_pdf(p.clone())}));
             }
             "app.about" => self.dialog = Some(dialogs::Dialog::new("about")),
             "app.palette" => self.palette = Some((String::new(), 0)),
@@ -678,16 +849,22 @@ impl SlideApp {
             return;
         }
         let events = ctx.input(|i| i.events.clone());
-        if self.home_open() {
-            // Only app shortcuts (Open, Command Palette…) and Escape, which goes back to the
-            // presentation: typing, pasting or deleting would edit the hidden presentation.
+        if self.backstage.is_some() {
+            // The File tab: its own keys (Esc goes back, arrows walk the side menu) and app
+            // shortcuts (New, Open, Command Palette…); typing, pasting or deleting would edit the
+            // hidden presentation.
             for e in events {
                 if let egui::Event::Key { key, pressed: true, modifiers, .. } = e {
                     let mods = Mods { shift: modifiers.shift, alt: modifiers.alt, cmd: modifiers.command || modifiers.ctrl };
-                    if key == egui::Key::Escape {
-                        self.home = None;
-                    } else if mods.cmd || mods.alt {
-                        menus::ui_shortcut(self, key, mods);
+                    if backstage::key(self, key, mods) || !(mods.cmd || mods.alt) || menus::ui_shortcut(self, key, mods) {
+                        continue;
+                    }
+                    // Engine shortcuts that don't touch the hidden slide (Ctrl+N).
+                    if mods.cmd
+                        && matches!(key, egui::Key::N)
+                        && let Err(e) = self.session.key(key_name(key), mods)
+                    {
+                        self.set_status(e.to_string());
                     }
                 }
             }
@@ -763,18 +940,21 @@ impl SlideApp {
             self.perf.frame_ms = now_ms() - t0;
             return;
         }
-        if self.home.is_some_and(|k| k != self.docs_key()) {
-            self.home = None;
-        }
+        self.sync_backstage();
         self.keyboard(&ctx);
+        self.sync_backstage();
         ribbon::title_bar(self, ui);
-        if self.session.active().is_some() && !self.home_open() {
+        if self.backstage.is_none() && self.session.active().is_some() {
             ribbon::show(self, ui);
             status::status_bar(self, ui);
         }
         egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.chrome)).show(ui, |ui| {
-            if self.session.active().is_none() || self.home_open() {
-                dialogs::start_screen(self, ui);
+            if self.backstage.is_some() {
+                // File tab: the Backstage view replaces everything below the title bar.
+                backstage::show(self, ui);
+                return;
+            }
+            if self.session.active().is_none() {
                 return;
             }
             match self.ui.view {
@@ -1010,7 +1190,7 @@ mod tests {
 
         harness.state_mut().run("app.home", json!({})).unwrap();
         harness.run_steps(2);
-        assert!(harness.state().home_open());
+        assert!(harness.state().backstage_open());
         assert_eq!(harness.state().session.documents().len(), 1, "Home doesn't create a presentation");
 
         // Typing on the start screen doesn't reach the presentation behind it; Escape goes back.
@@ -1021,18 +1201,18 @@ mod tests {
         assert!(!harness.state().session.active().unwrap().is_dirty());
         harness.key_press(egui::Key::Escape);
         harness.run_steps(2);
-        assert!(!harness.state().home_open());
+        assert!(!harness.state().backstage_open());
 
         // Home again toggles; picking a theme on the start screen (a new presentation) leaves it.
         harness.state_mut().run("app.home", json!({})).unwrap();
         harness.run_steps(2);
-        assert!(harness.state().home_open());
+        assert!(harness.state().backstage_open());
         harness.state_mut().run("app.home", json!({})).unwrap();
-        assert!(!harness.state().home_open());
+        assert!(!harness.state().backstage_open());
         harness.state_mut().run("app.home", json!({"on": true})).unwrap();
         harness.state_mut().run("file.new", json!({})).unwrap();
         harness.run_steps(2);
-        assert!(!harness.state().home_open(), "a new presentation leaves Home");
+        assert!(!harness.state().backstage_open(), "a new presentation leaves Home");
         assert_eq!(harness.state().session.documents().len(), 2);
     }
 
@@ -1123,7 +1303,7 @@ mod tests {
     fn home_needs_an_open_presentation() {
         let mut app = SlideApp::new(Session::new(), Services::default());
         app.run("app.home", json!({})).unwrap();
-        assert!(!app.home_open() && app.home.is_none(), "with nothing open the start screen shows anyway");
+        assert!(!app.backstage_open(), "with nothing open the start screen shows anyway");
     }
     fn canvas_harness() -> egui_kittest::Harness<'static, SlideApp> {
         let mut harness = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state(
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index 9349dc3..25398b4 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -29,6 +29,25 @@ pub fn ui_shortcut(app: &mut SlideApp, key: egui::Key, m: Mods) -> bool {
             return true;
         }
         (S, true, true, false) => "app.saveAsDialog",
+        // File tab: Alt+F opens it on Home with the keyboard in its side menu; Ctrl+P on Print.
+        (F, false, false, true) => {
+            app.open_backstage(crate::backstage::Page::Home);
+            if let Some(b) = app.backstage.as_mut() {
+                b.focus = Some(0);
+            }
+            return true;
+        }
+        (P, true, false, false) => {
+            if app.session.active().is_none() {
+                return false;
+            }
+            app.open_backstage(crate::backstage::Page::Print);
+            return true;
+        }
+        (W, true, false, false) => {
+            app.close_presentation();
+            return true;
+        }
         (O, true, false, false) => "app.openDialog",
         (P, true, true, false) => "app.palette",
         (Comma, true, false, false) => "app.preferences",
@@ -133,10 +152,11 @@ pub fn menu_tree() -> Vec<(&'static str, Vec<(&'static str, &'static str)>)> {
                 ("New Presentation", "file.new"),
                 ("Open…", "app.openDialog"),
                 ("-", ""),
-                ("Close", "file.close"),
+                ("Close", "app.closePresentation"),
                 ("Save", "file.save"),
                 ("Save As…", "app.saveAsDialog"),
                 ("Export…", "app.exportDialog"),
+                ("Print…", "app.print"),
                 ("-", ""),
                 ("Properties", "file.properties"),
             ],
diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index c7c251e..8e84792 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -47,7 +47,7 @@ pub fn title_bar(app: &mut SlideApp, ui: &mut Ui) {
         child.spacing_mut().item_spacing.x = 2.0;
         let has_doc = app.session.active().is_some();
         let dirty = app.session.active().is_some_and(|d| d.is_dirty());
-        if icon_toggle(&mut child, Icon::Home, "Home", true, app.home_open()).clicked() {
+        if icon_toggle(&mut child, Icon::Home, "Home", true, app.backstage_open()).clicked() {
             let _ = app.run("app.home", json!({}));
         }
         if icon_toggle(&mut child, Icon::Save, "Save (⌘S)", has_doc, false).clicked() {
@@ -143,9 +143,24 @@ pub fn show(app: &mut SlideApp, ui: &mut Ui) {
     let h = 28.0 + if app.ui.ribbon_collapsed { 4.0 } else { RIBBON_H + 20.0 };
     egui::Panel::top("ribbon").exact_size(h).frame(egui::Frame::NONE.fill(t.chrome)).show(ui, |ui| {
         let rect = ui.max_rect();
-        // Tabs.
+        // Tabs. File comes first and opens the File tab's full-window view (Backstage), as in
+        // PowerPoint.
         let mut x = rect.min.x + 12.0;
         let y = rect.min.y + 2.0;
+        {
+            let w = ui.fonts_mut(|f| f.layout_no_wrap("File".to_string(), theme::font(13.0), t.text).size().x) + 18.0;
+            let r = Rect::from_min_size(pos2(x, y), vec2(w, 24.0));
+            let resp = ui.interact(r, ui.id().with("tab_file"), Sense::click());
+            resp.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, "File"));
+            if resp.hovered() {
+                ui.painter().rect_filled(r.shrink2(vec2(2.0, 2.0)), CornerRadius::same(4), t.hover);
+            }
+            ui.painter().text(r.center(), Align2::CENTER_CENTER, "File", theme::font(13.0), t.text);
+            if resp.on_hover_text("File (Alt+F)").clicked() {
+                app.open_backstage(crate::backstage::Page::Home);
+            }
+            x += w + 2.0;
+        }
         let all: Vec<(&str, bool)> = TABS.iter().map(|s| (*s, false)).chain(ctx_tabs.iter().map(|s| (*s, true))).collect();
         for (name, contextual) in all {
             let font = theme::font(13.0);