diff --git a/README.md b/README.md
index 8884f2bd3..8d6a8b414 100644
--- a/README.md
+++ b/README.md
@@ -268,6 +268,20 @@ lightcraft --control 7980 ~/Pictures/trip
   with the same font coverage as watermarks (CJK requires craft-fonts), with long names shortened in the middle.
   This is a contact-sheet workflow,
   not a printer-driver or custom picture-package layout editor.
+- **Print layouts (native app / CLI):** **File → Print…** opens the Print module's layout editor: Single Image,
+  Contact Sheet, Picture Package (Auto Layout packs cells onto pages) and Custom Package (drag and resize cells,
+  stacking order, snap to cells or a grid), Zoom to Fill / Rotate to Fit, Photo Border and Inner Stroke, paper
+  sizes from 4 × 6 to 13 × 19 and A3 to A5 or custom, margins, rulers in in/cm/mm/pt, page background, 72–720 ppi,
+  and saved templates. **Print to PDF…** renders in the background. Everything is a `print.*` command
+  (`print.get`, `print.set`, `print.cell.add`, `print.layout.autoLayout`, `print.exportPdf`,
+  `print.template.save`…), so the CLI and MCP drive it too:
+
+  ```sh
+  lightcraft-cli run --import ~/Pictures/shoot print.set 'layout={"style":"picturePackage","page":{"paper":"8x10"}}' \
+      print.cell.add width=5 height=7 print.cell.add width=2.5 height=3.5 print.layout.autoLayout print.exportPdf path=Package.pdf
+  ```
+
+  Printer colour management and page overlays (identity plate, watermark, page numbers) are not there yet.
 - **Every widget is addressable** (`ui.widgets`) and clickable by name, so agents operate the real UI, not a
   side door.
 - The screenshots in this README were produced end to end by the [`docs/showcase/`](docs/showcase/) scripts.
diff --git a/apps/lightcraft-cli/tests/cli.rs b/apps/lightcraft-cli/tests/cli.rs
index fe29704b1..137caca7f 100644
--- a/apps/lightcraft-cli/tests/cli.rs
+++ b/apps/lightcraft-cli/tests/cli.rs
@@ -76,8 +76,11 @@ fn print_commands_chain_into_a_picture_package_pdf() {
     let export = lines.last().unwrap();
     assert_eq!((export["result"]["pages"].as_u64(), export["result"]["photos"].as_u64()), (Some(1), Some(1)));
     let bytes = std::fs::read(&out).unwrap();
-    assert!(bytes.starts_with(b"%PDF-1.4"));
-    assert!(String::from_utf8_lossy(&bytes).contains("/MediaBox [0 0 432.00 288.00]"), "6 x 4 in");
+    assert!(bytes.starts_with(b"%PDF-"));
+    let text = String::from_utf8_lossy(&bytes);
+    let at = text.find("/MediaBox [").unwrap() + "/MediaBox [".len();
+    let nums: Vec<f64> = text[at..].split(']').next().unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();
+    assert_eq!((nums[2], nums[3]), (432.0, 288.0), "6 x 4 in");
     // a bad setting fails the run and writes nothing new
     let before = std::fs::read(&out).unwrap();
     let (ok, _, _) =
diff --git a/crates/engine/src/print/output.rs b/crates/engine/src/print/output.rs
index f058ccf0b..937884a8e 100644
--- a/crates/engine/src/print/output.rs
+++ b/crates/engine/src/print/output.rs
@@ -88,9 +88,11 @@ mod tests {
         let pages = [raster(425, 550, [255, 255, 255]), raster(425, 550, [0, 0, 255])];
         let bytes = write(&pages, &PrintJob::default(), "t").unwrap();
         let text = String::from_utf8_lossy(&bytes);
-        assert!(text.starts_with("%PDF-1.4"));
+        assert!(text.starts_with("%PDF-"));
         assert!(text.contains("/Count 2"));
-        assert!(text.contains("/MediaBox [0 0 306.00 396.00]"), "4.25 x 5.5 in is 306 x 396 pt");
+        let at = text.find("/MediaBox [").unwrap() + "/MediaBox [".len();
+        let nums: Vec<f64> = text[at..].split(']').next().unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();
+        assert_eq!((nums[2], nums[3]), (306.0, 396.0), "4.25 x 5.5 in is 306 x 396 pt");
         assert!(text.contains("/Width 425 /Height 550"));
         assert!(write(&[], &PrintJob::default(), "t").is_err());
         let mixed = [raster(10, 10, [0; 3]), raster(10, 12, [0; 3])];
diff --git a/crates/engine/src/tests_print.rs b/crates/engine/src/tests_print.rs
index 261d47d52..eb7ab032c 100644
--- a/crates/engine/src/tests_print.rs
+++ b/crates/engine/src/tests_print.rs
@@ -171,6 +171,14 @@ fn auto_layout_fills_pages_without_overlap() {
     }
 }
 
+/// The first page's MediaBox width and height in points.
+fn media_box(pdf: &[u8]) -> (f64, f64) {
+    let text = String::from_utf8_lossy(pdf);
+    let at = text.find("/MediaBox [").expect("a MediaBox") + "/MediaBox [".len();
+    let nums: Vec<f64> = text[at..].split(']').next().unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();
+    (nums[2], nums[3])
+}
+
 fn temp_pdf(name: &str) -> String {
     std::env::temp_dir().join(format!("lightcraft-print-{name}-{}.pdf", std::process::id())).to_string_lossy().to_string()
 }
@@ -190,9 +198,10 @@ fn export_pdf_prints_the_current_settings() {
     let bytes = std::fs::read(&path).unwrap();
     assert_eq!(bytes.len() as u64, r["bytes"].as_u64().unwrap());
     let text = String::from_utf8_lossy(&bytes);
-    assert!(text.starts_with("%PDF-1.4") && text.contains("/Count 2"));
+    assert!(text.starts_with("%PDF-") && text.contains("/Count 2"));
     // A5 is 148 x 210 mm = 419.53 x 595.28 pt, rounded to whole pixels at 100 ppi (583 x 827)
-    assert!(text.contains("/MediaBox [0 0 419.76 595.44]"), "{}", &text[..text.len().min(400)]);
+    let (w, h) = media_box(&bytes);
+    assert!((w - 419.53).abs() < 1.0 && (h - 595.28).abs() < 1.0, "A5, got {w} x {h} pt");
     // the row in the activity stack is gone when the print is done
     assert!(s.activity.list().is_empty());
     fails(&mut s, "print.exportPdf", json!({}));
diff --git a/crates/ui-egui/src/export_task.rs b/crates/ui-egui/src/export_task.rs
index 051ad22bd..470e2a377 100644
--- a/crates/ui-egui/src/export_task.rs
+++ b/crates/ui-egui/src/export_task.rs
@@ -132,6 +132,59 @@ pub fn start_contact_sheet(app: &mut LightcraftApp, params: &Value) -> Result<Va
     Ok(json!({"background": true, "total": total}))
 }
 
+/// Print the session's current print (`print.get`) to a PDF in the background, with the same
+/// activity row and cancellation as the other exports.
+pub fn start_print(app: &mut LightcraftApp, params: &Value) -> Result<Value, String> {
+    use lightcraft_engine::print::{compose, output};
+    if app.export.is_some() {
+        return Err("an export is already running".into());
+    }
+    let path = params.get("path").and_then(Value::as_str).filter(|s| !s.trim().is_empty()).ok_or("missing path")?.to_string();
+    app.session.check_write_target(&path)?;
+    let guard = app.session.original_guard();
+    let settings = app.session.print.clone();
+    let ids = app.session.targets(params);
+    let prepared = compose::prepare(&mut app.session, &settings, &ids)?;
+    let total = prepared.len();
+    let title = std::path::Path::new(&path).file_stem().and_then(|n| n.to_str()).unwrap_or("Print").to_string();
+    let write = app.services.write_shared.clone();
+    let progress = Arc::new(Mutex::new((0, String::new())));
+    let cancel = Arc::new(AtomicBool::new(false));
+    let (p, c) = (progress.clone(), cancel.clone());
+    let (tx, rx) = channel();
+    let photos = ids.len();
+    let work = move || {
+        let result = prepared
+            .run(&mut |done, name| {
+                if let Ok(mut g) = p.lock() {
+                    *g = (done, name.to_string());
+                }
+                !c.load(Ordering::Relaxed)
+            })
+            .and_then(|pages| {
+                if c.load(Ordering::Relaxed) {
+                    return Err("Print cancelled".into());
+                }
+                let bytes = output::write(&pages, &settings.job, &title)?;
+                guard.check(std::path::Path::new(&path))?;
+                match write {
+                    Some(write) => write(&path, &bytes)?,
+                    None => lightcraft_engine::export::write_file(&path, &bytes)?,
+                }
+                Ok(vec![json!({"path": path, "pages": pages.len(), "photos": photos, "bytes": bytes.len(), "print": true})])
+            });
+        let _ = tx.send(result.map(|files| (files, None, c.load(Ordering::Relaxed))));
+    };
+    #[cfg(not(target_arch = "wasm32"))]
+    std::thread::Builder::new().name("print".into()).spawn(work).map_err(|e| e.to_string())?;
+    #[cfg(target_arch = "wasm32")]
+    work();
+    let row = app.session.activity.start("export", "Printing to PDF", Cancel::Flag(cancel.clone()));
+    row.progress(0, total as u64);
+    app.export = Some(ExportTask { total, progress, cancel, rx, guard: row });
+    Ok(json!({"background": true, "total": total}))
+}
+
 /// The toast's account of [`AfterExport::run`]'s Apple Photos outcome.
 pub fn apple_photos_note(outcome: &Value) -> String {
     if let Some(e) = outcome.get("error").and_then(Value::as_str) {
@@ -200,6 +253,9 @@ pub fn poll(app: &mut LightcraftApp, ctx: &egui::Context) {
                     if let Some(sheet) = sheet {
                         m = format!("Exported contact sheet: {} photos, {} pages", sheet["photos"], sheet["pages"]);
                     }
+                    if let Some(pdf) = files.first().filter(|f| f["print"] == true) {
+                        m = format!("Printed to PDF: {} photos, {} pages", pdf["photos"], pdf["pages"]);
+                    }
                     if skipped > 0 {
                         m += &crate::i18n::tr_format!(" · {skipped} skipped (file exists)", skipped = skipped);
                     }
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 9a387c77c..96ef1d91e 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -26,6 +26,7 @@ pub mod merge;
 mod model_setup;
 pub mod panels;
 pub mod pick;
+pub mod print_view;
 pub mod region;
 pub mod render;
 pub mod shortcuts;
@@ -104,6 +105,8 @@ mod tests_preset_import;
 #[cfg(test)]
 mod tests_preview_limit;
 #[cfg(test)]
+mod tests_print;
+#[cfg(test)]
 mod tests_quit_unsaved;
 #[cfg(test)]
 mod tests_scroll;
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index daf0f08e0..ff7f1519d 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -162,6 +162,8 @@ pub const UI_COMMANDS: &[UiCommand] = &[
     ("dialog.pasteSettings", "Paste Selected Settings…", Some("Cmd+Shift+V"), "Edit"),
     ("view.focusSearch", "Find…", Some("Cmd+F"), "Edit"),
     ("dialog.export", "Export…", None, "File"),
+    ("dialog.print", "Print…", Some("Cmd+P"), "File"),
+    ("app.print", "Print to PDF", None, ""),
     ("dialog.contactSheet", "Contact Sheet PDF…", None, "File"),
     ("app.contactSheet", "Export Contact Sheet PDF", None, ""),
     ("photo.editInPhotoCraft", "Edit in PhotoCraft", Some("Cmd+Shift+E"), "Photo>Edit In"),
@@ -1169,6 +1171,28 @@ pub fn run_ui_command(app: &mut LightcraftApp, id: &str, p: &Value) -> Option<Re
             app.ui.dialog = Some(Dialog::ContactSheet { options: lightcraft_engine::contact_sheet::Options::default() });
             Ok(Value::Null)
         }
+        "dialog.print" => {
+            app.ui.print = Default::default();
+            app.ui.dialog = Some(Dialog::Print);
+            Ok(Value::Null)
+        }
+        "app.print" => {
+            if app.export.is_some() {
+                return Some(Err("an export is already running".into()));
+            }
+            let mut params = p.clone();
+            if p.get("path").is_none() {
+                let req = PickRequest::save("Print to PDF", "PDF", &["pdf"], "Print.pdf");
+                let paths = match crate::pick::ask(app, id, p, "path", req, |_| None) {
+                    Picked::Now(paths) => paths,
+                    Picked::Later => return Some(Ok(Value::Null)),
+                    Picked::Unavailable => return Some(Err("no save dialog on this platform; supply path".into())),
+                };
+                let Some(path) = paths.first() else { return Some(Ok(Value::Null)) };
+                params["path"] = json!(path);
+            }
+            crate::export_task::start_print(app, &params)
+        }
         "app.contactSheet" => {
             if app.export.is_some() {
                 return Some(Err("an export is already running".into()));
@@ -1798,7 +1822,9 @@ pub fn run_ui_command(app: &mut LightcraftApp, id: &str, p: &Value) -> Option<Re
 
 pub fn ui_enabled(app: &LightcraftApp, id: &str) -> bool {
     match id {
-        "dialog.contactSheet" | "app.contactSheet" => !cfg!(target_arch = "wasm32") && app.session.active().is_some() && app.export.is_none(),
+        "dialog.contactSheet" | "app.contactSheet" | "dialog.print" | "app.print" => {
+            !cfg!(target_arch = "wasm32") && app.session.active().is_some() && app.export.is_none()
+        }
         s if s.starts_with("panel.") || s.starts_with("tool.") || s.starts_with("section.") => app.session.active().is_some() || s == "panel.close",
         "app.export" | "dialog.export" | "dialog.createPreset" | "dialog.rename" | "dialog.captureTime" | "dialog.copySettings" => {
             app.session.active().is_some()
diff --git a/crates/ui-egui/src/panels/dialogs.rs b/crates/ui-egui/src/panels/dialogs.rs
index 72528fca9..b574acbe3 100644
--- a/crates/ui-egui/src/panels/dialogs.rs
+++ b/crates/ui-egui/src/panels/dialogs.rs
@@ -176,6 +176,7 @@ pub const WHATS_NEW: &str = include_str!("../../../../docs/whats-new.md");
 fn window_id(dialog: &Dialog) -> egui::Id {
     egui::Id::new(match dialog {
         Dialog::Import { .. } => "lightcraft-import-dialog",
+        Dialog::Print => "lightcraft-print-dialog",
         Dialog::Settings { .. } => "lightcraft-settings-dialog",
         _ => "lightcraft-dialog",
     })
@@ -251,6 +252,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {
         Dialog::PasteSettings { .. } => "Paste Selected Settings",
         Dialog::Export { .. } => "Export",
         Dialog::ContactSheet { .. } => "Contact Sheet PDF",
+        Dialog::Print => "Print",
         Dialog::Merge { opts } => opts.title(),
         Dialog::Settings { .. } => "Settings",
         Dialog::ConfirmDelete { .. } => "Delete Photos",
@@ -270,6 +272,8 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {
     // own so the size it is given doesn't carry over to the other dialogs. Its content scrolls
     // rather than growing the window when the options below the grid get taller (e.g. Copy).
     let import = matches!(dlg, Dialog::Import { .. });
+    // The Print dialog sizes itself to the window and scrolls its settings column on its own.
+    let print = matches!(dlg, Dialog::Print);
     let window_id = window_id(&dlg);
     // Every other dialog fits the window (#781): its options scroll when they don't, and the title
     // bar and the button row stay outside the scroll area. The room they take is measured on the
@@ -289,13 +293,14 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {
             Dialog::Import { .. } => crate::import::DIALOG_SIZE[0],
             Dialog::SmartRules { .. } => 680.0,
             Dialog::AllMetadata { .. } => 620.0,
+            Dialog::Print => 1100.0,
             Dialog::FaceModel { .. } => 460.0,
             Dialog::LightroomCatalog { .. } => 440.0,
             _ => 380.0,
         })
         .show(ctx, |ui| {
             ui.spacing_mut().item_spacing.y = 8.0;
-            body_h = dialog_body(ui, (!import).then_some(title.as_str()), body_max, |ui| match &mut dlg {
+            body_h = dialog_body(ui, (!import && !print).then_some(title.as_str()), body_max, |ui| match &mut dlg {
                 Dialog::AutoStack { gap } => {
                     ui.label(egui::RichText::new(crate::i18n::tr("Stack photos taken within this time of each other:")).color(t.text_label));
                     ui.add(
@@ -1167,6 +1172,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {
                     }
                 }
                 Dialog::Shortcuts => crate::panels::keymap::body(app, ui, &t),
+                Dialog::Print => crate::print_view::body(app, ui, &t),
             });
             ui.add_space(4.0);
             ui.horizontal(|ui| {
@@ -1203,6 +1209,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {
                         add_label.as_str()
                     }
                     Dialog::ContactSheet { .. } => "Choose PDF…",
+                    Dialog::Print => "Print to PDF…",
                     Dialog::Merge { .. } => "Merge",
                     Dialog::DenoiseModel { info, .. } if info["download"].is_string() => "Accept & Download",
                     Dialog::DenoiseModel { .. } => "Install",
@@ -1276,6 +1283,7 @@ pub fn show(app: &mut LightcraftApp, ctx: &egui::Context) {
                     Dialog::Import { .. }
                         | Dialog::Export { .. }
                         | Dialog::ContactSheet { .. }
+                        | Dialog::Print
                         | Dialog::NewAlbum { .. }
                         | Dialog::NewSmartAlbum { .. }
                         | Dialog::SmartRules { .. }
@@ -1665,6 +1673,7 @@ pub fn confirm_dialog(app: &mut LightcraftApp, dlg: &Dialog) -> Result<serde_jso
             }),
         ),
         Dialog::ContactSheet { options } => app.run("app.contactSheet", json!(options)),
+        Dialog::Print => app.run("app.print", json!({})),
         Dialog::CopySettings { groups } => app.run("develop.copy", json!({"groups": groups})),
         Dialog::PasteSettings { groups } => app.run("develop.paste", json!({"groups": groups})),
         Dialog::Export { opts, full_size, resize, limit_kb, dir, .. } => {
diff --git a/crates/ui-egui/src/print_view.rs b/crates/ui-egui/src/print_view.rs
new file mode 100644
index 000000000..7c1ab85fb
--- /dev/null
+++ b/crates/ui-egui/src/print_view.rs
@@ -0,0 +1,823 @@
+//! The Print dialog (File ▸ Print…): settings on the left, the pages drawn to scale on the right.
+//!
+//! Every change goes through a `print.*` command ([`lightcraft_engine::cmd`]); this file only draws
+//! the session's print ([`lightcraft_engine::Session::print`]) and turns pointer input into
+//! commands: dragging a cell is `print.cell.move`, its corner handle `print.cell.resize`, with
+//! the guides' snapping done by the command. Widgets register under `print:*`, `button:print*`
+//! and `drag:print*` ids for the control channel and the headless tests.
+use egui::{Align2, Color32, Pos2, Rect, Sense, Stroke, StrokeKind, Ui, Vec2, pos2, vec2};
+use lightcraft_catalog::PhotoId;
+use lightcraft_engine::export::ExportOptions;
+use lightcraft_engine::print::compose::{self, place};
+use lightcraft_engine::print::layout::{self, Snap, Style, Unit};
+use lightcraft_engine::print::template::PrintSettings;
+use serde_json::{Value, json};
+
+use crate::LightcraftApp;
+use crate::theme::Tokens;
+use crate::widgets::{register, text_button};
+
+/// Width of the settings column.
+const SETTINGS_W: f32 = 290.0;
+/// Handle for resizing the selected cell, screen points.
+const HANDLE: f32 = 12.0;
+/// Snap distance while dragging, screen points.
+const SNAP_PX: f32 = 8.0;
+/// Cell sizes offered as buttons, inches (width, height).
+const CELL_SIZES: &[(f64, f64)] = &[(2.0, 2.0), (2.5, 3.5), (3.5, 5.0), (4.0, 5.0), (4.0, 6.0), (5.0, 7.0), (8.0, 10.0), (3.0, 3.0)];
+
+/// A drag of a cell in progress: the cell's rectangle when it began and how far the pointer went.
+#[derive(Clone, Debug)]
+pub struct Drag {
+    cell: u32,
+    origin: layout::Rect,
+    resize: bool,
+    /// Where the pointer was pressed; the distance dragged is measured from it, so the first few
+    /// points egui spends deciding between a click and a drag are not lost.
+    press: Pos2,
+    total: Vec2,
+}
+
+/// What the Print dialog remembers between frames (not saved).
+#[derive(Clone, Debug, Default)]
+pub struct PrintUi {
+    /// The page being shown, zero-based.
+    pub page: usize,
+    /// The selected cell.
+    pub selected: Option<u32>,
+    drag: Option<Drag>,
+    /// The name typed for Save Template.
+    pub template_name: String,
+    /// Size of the next cell added, inches.
+    pub new_cell: Option<(f64, f64)>,
+}
+
+fn run(app: &mut LightcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Option<Value> {
+    match app.run(id, params) {
+        Ok(v) => Some(v),
+        Err(e) => {
+            app.toast(ctx, e);
+            None
+        }
+    }
+}
+
+fn patch(app: &mut LightcraftApp, ctx: &egui::Context, params: Value) {
+    run(app, ctx, "print.set", params);
+}
+
+fn heading(ui: &mut Ui, t: &Tokens, text: &str) {
+    ui.add_space(8.0);
+    ui.label(egui::RichText::new(crate::i18n::tr(text)).font(t.semibold(12.0)).color(t.text));
+    ui.add_space(2.0);
+}
+
+fn row<R>(ui: &mut Ui, t: &Tokens, label: &str, add: impl FnOnce(&mut Ui) -> R) -> R {
+    ui.horizontal(|ui| {
+        ui.allocate_ui_with_layout(vec2(86.0, 22.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
+            ui.label(egui::RichText::new(crate::i18n::tr(label)).color(t.text_label));
+        });
+        add(ui)
+    })
+    .inner
+}
+
+fn decimals(unit: Unit) -> usize {
+    match unit {
+        Unit::Inches | Unit::Centimeters => 2,
+        Unit::Millimeters => 1,
+        Unit::Points => 0,
+    }
+}
+
+fn fmt_len(inches: f64, unit: Unit) -> String {
+    format!("{:.*} {}", decimals(unit), unit.from_inches(inches), unit.label())
+}
+
+/// A length field in the ruler's unit; the new value in inches when it changed.
+fn length(ui: &mut Ui, id: &str, inches: f64, unit: Unit, min_in: f64, max_in: f64) -> Option<f64> {
+    let mut v = unit.from_inches(inches);
+    let r = ui.add(
+        egui::DragValue::new(&mut v)
+            .range(unit.from_inches(min_in)..=unit.from_inches(max_in))
+            .speed(unit.per_inch() * 0.01)
+            .max_decimals(decimals(unit))
+            .suffix(format!(" {}", unit.label())),
+    );
+    register(ui.ctx(), format!("drag:{id}"), r.rect);
+    r.changed().then(|| unit.to_inches(v))
+}
+
+fn check(ui: &mut Ui, id: &str, label: &str, value: bool) -> Option<bool> {
+    let mut v = value;
+    let r = ui.checkbox(&mut v, crate::i18n::tr(label));
+    register(ui.ctx(), format!("check:{id}"), r.rect);
+    r.changed().then_some(v)
+}
+
+fn choice<V: PartialEq + Copy>(ui: &mut Ui, id: &str, options: &[(V, &str)], current: V) -> Option<V> {
+    let mut out = None;
+    ui.spacing_mut().item_spacing.x = 3.0;
+    for (i, (v, l)) in options.iter().enumerate() {
+        if text_button(ui, &format!("{id}-{i}"), l, current == *v).clicked() && current != *v {
+            out = Some(*v);
+        }
+    }
+    out
+}
+
+fn colour(ui: &mut Ui, id: &str, rgb: [u8; 3]) -> Option<[u8; 3]> {
+    let mut c = rgb;
+    let r = ui.color_edit_button_srgb(&mut c);
+    register(ui.ctx(), format!("color:{id}"), r.rect);
+    (c != rgb).then_some(c)
+}
+
+fn paper_label(name: &str) -> String {
+    match name {
+        "a3" | "a4" | "a5" => name.to_uppercase(),
+        "letter" => "Letter".into(),
+        "legal" => "Legal".into(),
+        "tabloid" => "Tabloid".into(),
+        "custom" => "Custom".into(),
+        other => other.replace('x', " × ") + " in",
+    }
+}
+
+/// The dialog's body: the settings column and the page preview side by side.
+pub fn body(app: &mut LightcraftApp, ui: &mut Ui, t: &Tokens) {
+    let ctx = ui.ctx().clone();
+    let screen = ctx.content_rect();
+    let width = (screen.width() - 80.0).clamp(640.0, 1180.0);
+    let height = (screen.height() - 190.0).clamp(280.0, 780.0);
+    let mut pu = std::mem::take(&mut app.ui.print);
+    let st = app.session.print.clone();
+    let ids = app.session.targets(&json!({}));
+    // the page shown stays inside the print
+    let pages = st.layout.page_count(ids.len());
+    pu.page = pu.page.min(pages.saturating_sub(1));
+    if pu.selected.is_some_and(|c| st.layout.cell(c).is_none_or(|c| c.page as usize != pu.page)) && pu.drag.is_none() {
+        pu.selected = pu.selected.filter(|c| st.layout.cell(*c).is_some());
+    }
+    ui.horizontal_top(|ui| {
+        ui.allocate_ui_with_layout(vec2(SETTINGS_W, height), egui::Layout::top_down(egui::Align::Min), |ui| {
+            ui.set_min_size(vec2(SETTINGS_W, height));
+            egui::ScrollArea::vertical().id_salt("print-settings").max_height(height).auto_shrink([false, false]).show(ui, |ui| {
+                ui.set_width(SETTINGS_W - 14.0);
+                settings(app, ui, t, &mut pu, &st, ids.len());
+            });
+        });
+        // (a `separator` would take the dialog's whole free height)
+        let (line, _) = ui.allocate_exact_size(vec2(1.0, height), Sense::hover());
+        ui.painter().line_segment([line.center_top(), line.center_bottom()], Stroke::new(1.0, t.divider));
+        let w = (width - SETTINGS_W - 24.0).max(300.0);
+        ui.allocate_ui_with_layout(vec2(w, height), egui::Layout::top_down(egui::Align::Min), |ui| {
+            ui.set_min_size(vec2(w, height));
+            preview(app, ui, t, &mut pu, &st, &ids, pages);
+        });
+    });
+    app.ui.print = pu;
+}
+
+fn settings(app: &mut LightcraftApp, ui: &mut Ui, t: &Tokens, pu: &mut PrintUi, st: &PrintSettings, photos: usize) {
+    let ctx = ui.ctx().clone();
+    let l = &st.layout;
+    let unit = st.guides.units;
+    ui.spacing_mut().item_spacing.y = 5.0;
+    ui.label(egui::RichText::new(crate::i18n::tr_format!("{n} photo{}", if photos == 1 { "" } else { "s" }, n = photos)).color(t.text_dim));
+
+    heading(ui, t, "Templates");
+    ui.horizontal(|ui| {
+        crate::text_field::TextField::singleline("field:printTemplateName", &mut pu.template_name)
+            .hint(crate::i18n::tr("Template name"))
+            .width(140.0)
+            .show(ui);
+        if text_button(ui, "printSaveTemplate", "Save", false).clicked() && !pu.template_name.trim().is_empty() {
+            run(app, &ctx, "print.template.save", json!({"name": pu.template_name}));
+        }
+    });
+    let names: Vec<String> = app.session.print_templates.iter().map(|t| t.name.clone()).collect();
+    for (i, name) in names.iter().enumerate() {
+        ui.horizontal(|ui| {
+            ui.label(egui::RichText::new(name).color(t.text_label));
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if text_button(ui, &format!("printTemplateDelete-{i}"), "Delete", false).clicked() {
+                    run(app, &ctx, "print.template.delete", json!({"name": name}));
+                }
+                if text_button(ui, &format!("printTemplateApply-{i}"), "Apply", false).clicked() {
+                    run(app, &ctx, "print.template.apply", json!({"name": name}));
+                    pu.page = 0;
+                    pu.selected = None;
+                }
+            });
+        });
+    }
+
+    heading(ui, t, "Layout Style");
+    let styles =
+        [(Style::SingleImage, "Single"), (Style::ContactSheet, "Contact"), (Style::PicturePackage, "Package"), (Style::CustomPackage, "Custom")];
+    ui.horizontal_wrapped(|ui| {
+        if let Some(s) = choice(ui, "printStyle", &styles, l.style) {
+            patch(app, &ctx, json!({"layout": {"style": s}}));
+            pu.page = 0;
+        }
+    });
+
+    heading(ui, t, "Image Settings");
+    let im = &st.image;
+    if let Some(v) = check(ui, "printZoomFill", "Zoom to Fill Frame", im.zoom_to_fill) {
+        patch(app, &ctx, json!({"image": {"zoomToFill": v}}));
+    }
+    if let Some(v) = check(ui, "printRotateFit", "Rotate to Fit", im.rotate_to_fit) {
+        patch(app, &ctx, json!({"image": {"rotateToFit": v}}));
+    }
+    if l.style.is_package() {
+        ui.horizontal(|ui| {
+            if let Some(v) = check(ui, "printBorder", "Photo Border", im.border_enabled) {
+                patch(app, &ctx, json!({"image": {"borderEnabled": v}}));
+            }
+            if let Some(w) = length(ui, "printBorderWidth", im.border_width, unit, 0.0, 2.0) {
+                patch(app, &ctx, json!({"image": {"borderWidth": w}}));
+            }
+            if let Some(c) = colour(ui, "printBorderColor", im.border_color) {
+                patch(app, &ctx, json!({"image": {"borderColor": c}}));
+            }
+        });
+    }
+    ui.horizontal(|ui| {
+        if let Some(v) = check(ui, "printStroke", "Inner Stroke", im.stroke_enabled) {
+            patch(app, &ctx, json!({"image": {"strokeEnabled": v}}));
+        }
+        let mut pt = im.stroke_width_pt;
+        let r = ui.add(egui::DragValue::new(&mut pt).range(0.0..=36.0).speed(0.05).max_decimals(2).suffix(" pt"));
+        register(ui.ctx(), "drag:printStrokeWidth", r.rect);
+        if r.changed() {
+            patch(app, &ctx, json!({"image": {"strokeWidthPt": pt}}));
+        }
+        if let Some(c) = colour(ui, "printStrokeColor", im.stroke_color) {
+            patch(app, &ctx, json!({"image": {"strokeColor": c}}));
+        }
+    });
+
+    heading(ui, t, "Layout");
+    match l.style {
+        Style::SingleImage => {
+            ui.label(egui::RichText::new(crate::i18n::tr("One photo fills each page inside the margins.")).color(t.text_dim));
+        }
+        Style::ContactSheet => {
+            let g = &l.grid;
+            row(ui, t, "Grid", |ui| {
+                let (mut c, mut r) = (g.columns, g.rows);
+                let a = ui.add(egui::DragValue::new(&mut c).range(1..=layout::MAX_GRID).suffix(" cols"));
+                register(ui.ctx(), "drag:printColumns", a.rect);
+                let b = ui.add(egui::DragValue::new(&mut r).range(1..=layout::MAX_GRID).suffix(" rows"));
+                register(ui.ctx(), "drag:printRows", b.rect);
+                if a.changed() || b.changed() {
+                    patch(app, &ctx, json!({"layout": {"grid": {"columns": c, "rows": r}}}));
+                }
+            });
+            row(ui, t, "Spacing", |ui| {
+                if let Some(v) = length(ui, "printSpacingX", g.spacing_x, unit, 0.0, 2.0) {
+                    patch(app, &ctx, json!({"layout": {"grid": {"spacingX": v}}}));
+                }
+                if let Some(v) = length(ui, "printSpacingY", g.spacing_y, unit, 0.0, 2.0) {
+                    patch(app, &ctx, json!({"layout": {"grid": {"spacingY": v}}}));
+                }
+            });
+            if let Some(v) = check(ui, "printKeepSquare", "Keep Square", g.keep_square) {
+                patch(app, &ctx, json!({"layout": {"grid": {"keepSquare": v}}}));
+            }
+        }
+        Style::PicturePackage | Style::CustomPackage => {
+            ui.label(egui::RichText::new(crate::i18n::tr("Add a cell")).color(t.text_label));
+            ui.horizontal_wrapped(|ui| {
+                ui.spacing_mut().item_spacing = vec2(3.0, 3.0);
+                for (i, (w, h)) in CELL_SIZES.iter().enumerate() {
+                    if text_button(ui, &format!("printAddCell-{i}"), &format!("{} × {}", trim(*w), trim(*h)), false).clicked() {
+                        add_cell(app, &ctx, pu, *w, *h);
+                    }
+                }
+            });
+            let (mut w, mut h) = pu.new_cell.unwrap_or((3.0, 2.0));
+            row(ui, t, "Custom size", |ui| {
+                if let Some(v) = length(ui, "printNewCellW", w, unit, layout::MIN_CELL_IN, 30.0) {
+                    w = v;
+                }
+                if let Some(v) = length(ui, "printNewCellH", h, unit, layout::MIN_CELL_IN, 30.0) {
+                    h = v;
+                }
+            });
+            pu.new_cell = Some((w, h));
+            ui.horizontal(|ui| {
+                if text_button(ui, "printAddCustom", "Add Cell", false).clicked() {
+                    add_cell(app, &ctx, pu, w, h);
+                }
+                if l.style == Style::PicturePackage && text_button(ui, "printAutoLayout", "Auto Layout", false).clicked() {
+                    run(app, &ctx, "print.layout.autoLayout", json!({}));
+                    pu.page = 0;
+                }
+            });
+            ui.horizontal(|ui| {
+                if text_button(ui, "printNewPage", "New Page", false).clicked()
+                    && let Some(r) = run(app, &ctx, "print.layout.newPage", json!({}))
+                {
+                    pu.page = r["page"].as_u64().unwrap_or(0) as usize;
+                }
+                if text_button(ui, "printClear", "Clear Layout", false).clicked() {
+                    run(app, &ctx, "print.layout.clear", json!({}));
+                    pu.page = 0;
+                    pu.selected = None;
+                }
+            });
+            row(ui, t, "Gap", |ui| {
+                if let Some(v) = length(ui, "printGap", l.spacing, unit, 0.0, 2.0) {
+                    patch(app, &ctx, json!({"layout": {"spacing": v}}));
+                }
+            });
+        }
+    }
+
+    heading(ui, t, "Rulers, Grid & Guides");
+    let g = &st.guides;
+    if let Some(v) = check(ui, "printRulers", "Show Rulers", g.show_rulers) {
+        patch(app, &ctx, json!({"guides": {"showRulers": v}}));
+    }
+    row(ui, t, "Units", |ui| {
+        let units = [(Unit::Inches, "in"), (Unit::Centimeters, "cm"), (Unit::Millimeters, "mm"), (Unit::Points, "pt")];
+        if let Some(u) = choice(ui, "printUnits", &units, g.units) {
+            patch(app, &ctx, json!({"guides": {"units": u}}));
+        }
+    });
+    row(ui, t, "Snap", |ui| {
+        if let Some(s) = choice(ui, "printSnap", &[(Snap::Off, "Off"), (Snap::Cells, "Cells"), (Snap::Grid, "Grid")], g.snap) {
+            patch(app, &ctx, json!({"guides": {"snap": s}}));
+        }
+    });
+    row(ui, t, "Grid size", |ui| {
+        if let Some(v) = length(ui, "printGridSize", g.grid_size, unit, 0.05, 10.0) {
+            patch(app, &ctx, json!({"guides": {"gridSize": v}}));
+        }
+    });
+    for (id, label, on, key) in [
+        ("printShowMargins", "Page Margins", g.show_margins, "showMargins"),
+        ("printShowBleed", "Page Bleed", g.show_bleed, "showBleed"),
+        ("printShowGrid", "Page Grid", g.show_page_grid, "showPageGrid"),
+        ("printShowCells", "Image Cells", g.show_cells, "showCells"),
+        ("printShowDims", "Dimensions", g.show_dimensions, "showDimensions"),
+    ] {
+        if let Some(v) = check(ui, id, label, on) {
+            patch(app, &ctx, json!({"guides": {(key): v}}));
+        }
+    }
+
+    heading(ui, t, "Page Setup");
+    row(ui, t, "Paper", |ui| {
+        let current = if l.page.paper.eq_ignore_ascii_case("custom") { "custom".to_string() } else { l.page.paper.to_ascii_lowercase() };
+        let c = egui::ComboBox::from_id_salt("printPaper").selected_text(paper_label(&current)).show_ui(ui, |ui| {
+            for name in layout::paper_names().chain(std::iter::once("custom")) {
+                if ui.selectable_label(current == name, paper_label(name)).clicked() {
+                    patch(app, &ctx, json!({"layout": {"page": {"paper": name}}}));
+                }
+            }
+        });
+        register(ui.ctx(), "combo:printPaper", c.response.rect);
+    });
+    if l.page.paper.eq_ignore_ascii_case("custom") {
+        row(ui, t, "Size", |ui| {
+            if let Some(v) = length(ui, "printCustomW", l.page.custom_width, unit, layout::MIN_PAGE_IN, layout::MAX_PAGE_IN) {
+                patch(app, &ctx, json!({"layout": {"page": {"customWidth": v}}}));
+            }
+            if let Some(v) = length(ui, "printCustomH", l.page.custom_height, unit, layout::MIN_PAGE_IN, layout::MAX_PAGE_IN) {
+                patch(app, &ctx, json!({"layout": {"page": {"customHeight": v}}}));
+            }
+        });
+    }
+    row(ui, t, "Orientation", |ui| {
+        let o = [(layout::Orientation::Portrait, "Portrait"), (layout::Orientation::Landscape, "Landscape")];
+        if let Some(v) = choice(ui, "printOrientation", &o, l.page.orientation) {
+            patch(app, &ctx, json!({"layout": {"page": {"orientation": v}}}));
+        }
+    });
+    let m = &l.page.margins;
+    for (label, id, key, v) in [
+        ("Left", "printMarginLeft", "left", m.left),
+        ("Right", "printMarginRight", "right", m.right),
+        ("Top", "printMarginTop", "top", m.top),
+        ("Bottom", "printMarginBottom", "bottom", m.bottom),
+    ] {
+        row(ui, t, label, |ui| {
+            if let Some(v) = length(ui, id, v, unit, 0.0, layout::MAX_MARGIN_IN) {
+                patch(app, &ctx, json!({"layout": {"page": {"margins": {(key): v}}}}));
+            }
+        });
+    }
+
+    heading(ui, t, "Page");
+    row(ui, t, "Background", |ui| {
+        if let Some(c) = colour(ui, "printBackground", st.page.background) {
+            patch(app, &ctx, json!({"page": {"background": c}}));
+        }
+    });
+
+    heading(ui, t, "Print Job");
+    row(ui, t, "Resolution", |ui| {
+        let mut ppi = st.job.ppi;
+        let r = ui.add(egui::DragValue::new(&mut ppi).range(72.0..=720.0).speed(1.0).max_decimals(0).suffix(" ppi"));
+        register(ui.ctx(), "drag:printPpi", r.rect);
+        if r.changed() {
+            patch(app, &ctx, json!({"job": {"ppi": ppi}}));
+        }
+    });
+    ui.label(egui::RichText::new(crate::i18n::tr("PDF · sRGB · current edits")).color(t.text_dim));
+}
+
+fn trim(v: f64) -> String {
+    let s = format!("{v:.2}");
+    s.trim_end_matches('0').trim_end_matches('.').to_string()
+}
+
+fn add_cell(app: &mut LightcraftApp, ctx: &egui::Context, pu: &mut PrintUi, w: f64, h: f64) {
+    if let Some(r) = run(app, ctx, "print.cell.add", json!({"width": w, "height": h})) {
+        pu.selected = r["id"].as_u64().and_then(|v| u32::try_from(v).ok());
+        pu.page = r["cell"]["page"].as_u64().unwrap_or(0) as usize;
+    }
+}
+
+// ---- preview -------------------------------------------------------------------------------
+
+/// Screen geometry of the page on show.
+struct Sheet {
+    page: Rect,
+    /// Screen points per inch.
+    scale: f32,
+}
+
+impl Sheet {
+    fn rect(&self, r: &layout::Rect) -> Rect {
+        Rect::from_min_size(self.page.min + vec2(r.x as f32, r.y as f32) * self.scale, vec2(r.w as f32, r.h as f32) * self.scale)
+    }
+}
+
+fn preview(app: &mut LightcraftApp, ui: &mut Ui, t: &Tokens, pu: &mut PrintUi, st: &PrintSettings, ids: &[PhotoId], pages: usize) {
+    let ctx = ui.ctx().clone();
+    // room for the page buttons and, for a package, the selected cell's row (which may wrap)
+    let footer = if st.layout.style.is_package() { 104.0 } else { 44.0 };
+    let size = vec2(ui.available_width(), (ui.available_height() - footer).max(120.0));
+    let (area, _) = ui.allocate_exact_size(size, Sense::hover());
+    let painter = ui.painter_at(area);
+    painter.rect_filled(area, 4.0, t.canvas);
+    let Ok((pw, ph)) = st.layout.page_size() else {
+        painter.text(area.center(), Align2::CENTER_CENTER, crate::i18n::tr("This page setup is not valid"), t.font(13.0), t.caution);
+        return;
+    };
+    let g = &st.guides;
+    let ruler = if g.show_rulers { 22.0 } else { 0.0 };
+    let inner = Rect::from_min_max(area.min + vec2(ruler, ruler), area.max).shrink(14.0);
+    let scale = ((inner.width() as f64 / pw).min(inner.height() as f64 / ph) as f32).max(1.0);
+    let sheet = Sheet { page: Rect::from_center_size(inner.center(), vec2(pw as f32, ph as f32) * scale), scale };
+    register(&ctx, "print:page", sheet.page);
+
+    painter.rect_filled(sheet.page.translate(vec2(2.0, 3.0)), 0.0, Color32::from_black_alpha(70));
+    let bg = st.page.background;
+    painter.rect_filled(sheet.page, 0.0, Color32::from_rgb(bg[0], bg[1], bg[2]));
+    let guide = Stroke::new(1.0, Color32::from_rgb(90, 160, 240));
+    if g.show_rulers {
+        rulers(&painter, t, &sheet, area, pw, ph, g.units);
+    }
+    let area_in = st.layout.printable().ok();
+    if g.show_bleed {
+        let b = 0.125;
+        dashed(&painter, sheet.page.expand(b as f32 * scale), Stroke::new(1.0, t.caution));
+    }
+    if g.show_page_grid
+        && let Some(a) = area_in
+    {
+        let faint = Stroke::new(1.0, Color32::from_rgba_unmultiplied(120, 120, 120, 70));
+        let step = g.grid_size.max(0.05);
+        let mut x = 0.0;
+        while a.x + x <= a.right() + 1e-9 && x < 200.0 {
+            let sx = sheet.page.left() + (a.x + x) as f32 * scale;
+            painter.line_segment([pos2(sx, sheet.page.top()), pos2(sx, sheet.page.bottom())], faint);
+            x += step;
+        }
+        let mut y = 0.0;
+        while a.y + y <= a.bottom() + 1e-9 && y < 200.0 {
+            let sy = sheet.page.top() + (a.y + y) as f32 * scale;
+            painter.line_segment([pos2(sheet.page.left(), sy), pos2(sheet.page.right(), sy)], faint);
+            y += step;
+        }
+    }
+    if g.show_margins
+        && let Some(a) = area_in
+    {
+        dashed(&painter, sheet.rect(&layout::Rect::new(a.x, a.y, a.w, a.h)), guide);
+    }
+
+    let package = st.layout.style.is_package();
+    if package {
+        package_cells(app, ui, &painter, t, pu, st, ids, &sheet);
+    } else {
+        let plan = compose::plan_cells(&st.layout, ids).ok();
+        let cells: Vec<(layout::Rect, Option<PhotoId>)> = match plan.as_ref().and_then(|p| p.get(pu.page)) {
+            Some(page) => page.iter().map(|(r, id)| (*r, Some(*id))).collect(),
+            None => st.layout.grid_rects().unwrap_or_default().into_iter().map(|r| (r, None)).collect(),
+        };
+        for (i, (r, photo)) in cells.iter().enumerate() {
+            let rect = sheet.rect(r);
+            register(&ctx, format!("print:gridcell:{i}"), rect);
+            paint_cell(app, &painter, t, st, rect, *photo, &sheet, r);
+        }
+    }
+
+    // footer: page navigation and the selected cell
+    ui.horizontal(|ui| {
+        if text_button(ui, "printPagePrev", "◀", false).clicked() && pu.page > 0 {
+            pu.page -= 1;
+            pu.selected = None;
+        }
+        let label = ui.label(egui::RichText::new(format!("{} {} / {}", crate::i18n::tr("Page"), pu.page + 1, pages)).color(t.text));
+        register(ui.ctx(), "print:pageLabel", label.rect);
+        if text_button(ui, "printPageNext", "▶", false).clicked() && pu.page + 1 < pages {
+            pu.page += 1;
+            pu.selected = None;
+        }
+        ui.label(egui::RichText::new(fmt_len(pw, g.units) + " × " + &fmt_len(ph, g.units)).color(t.text_dim));
+        if package {
+            ui.label(egui::RichText::new(format!("{} {}", st.layout.cells.len(), crate::i18n::tr("cells"))).color(t.text_dim));
+            if st.layout.has_overlaps() {
+                ui.label(egui::RichText::new(crate::i18n::tr("cells overlap")).color(t.caution));
+            }
+        }
+    });
+    if package {
+        inspector(app, ui, t, pu, st);
+    }
+}
+
+fn press_origin(ui: &Ui, resp: &egui::Response) -> Pos2 {
+    ui.input(|i| i.pointer.press_origin()).or_else(|| resp.interact_pointer_pos()).unwrap_or_default()
+}
+
+/// Draws and handles every cell of a package page, back to front.
+#[allow(clippy::too_many_arguments)]
+fn package_cells(
+    app: &mut LightcraftApp,
+    ui: &mut Ui,
+    painter: &egui::Painter,
+    t: &Tokens,
+    pu: &mut PrintUi,
+    st: &PrintSettings,
+    ids: &[PhotoId],
+    sheet: &Sheet,
+) {
+    let ctx = ui.ctx().clone();
+    let first = ids.first().copied();
+    let cells: Vec<layout::Cell> = st.layout.cells_on_page(pu.page as u32).cloned().collect();
+    for c in &cells {
+        let photo = if st.layout.style == Style::CustomPackage { c.photo.map(PhotoId).or(first) } else { first };
+        let rect = sheet.rect(&c.rect);
+        paint_cell(app, painter, t, st, rect, photo, sheet, &c.rect);
+        let resp = ui.interact(rect, egui::Id::new(("print-cell", c.id)), Sense::click_and_drag());
+        register(&ctx, format!("print:cell:{}", c.id), rect);
+        if resp.clicked() || resp.drag_started() {
+            pu.selected = Some(c.id);
+        }
+        if resp.drag_started() {
+            pu.drag = Some(Drag { cell: c.id, origin: c.rect, resize: false, press: press_origin(ui, &resp), total: Vec2::ZERO });
+        }
+        if resp.dragged()
+            && let Some(d) = pu.drag.as_mut().filter(|d| d.cell == c.id && !d.resize)
+        {
+            d.total = resp.interact_pointer_pos().map_or(d.total, |p| p - d.press);
+            let (x, y) = (d.origin.x + f64::from(d.total.x / sheet.scale), d.origin.y + f64::from(d.total.y / sheet.scale));
+            let threshold = f64::from(SNAP_PX / sheet.scale);
+            run(app, &ctx, "print.cell.move", json!({"id": c.id, "x": x, "y": y, "snap": true, "threshold": threshold}));
+        }
+        if resp.drag_stopped() {
+            pu.drag = None;
+        }
+        let id = c.id;
+        resp.context_menu(|ui| {
+            for (how, label) in
+                [("toFront", "Bring to Front"), ("forward", "Bring Forward"), ("backward", "Send Backward"), ("toBack", "Send to Back")]
+            {
+                if ui.button(crate::i18n::tr(label)).clicked() {
+                    run(app, &ctx, "print.cell.stack", json!({"id": id, "order": how}));
+                    ui.close();
+                }
+            }
+            ui.separator();
+            if ui.button(crate::i18n::tr("Delete Cell")).clicked() {
+                run(app, &ctx, "print.cell.delete", json!({"id": id}));
+                ui.close();
+            }
+        });
+    }
+    // the selected cell's outline and resize handle go over everything
+    let Some(sel) = pu.selected.and_then(|s| cells.iter().find(|c| c.id == s)) else { return };
+    let rect = sheet.rect(&sel.rect);
+    painter.rect_stroke(rect, 0.0, Stroke::new(2.0, t.accent), StrokeKind::Outside);
+    let handle = Rect::from_center_size(rect.right_bottom(), Vec2::splat(HANDLE));
+    painter.rect_filled(handle, 2.0, t.accent);
+    let resp = ui.interact(handle, egui::Id::new(("print-resize", sel.id)), Sense::drag());
+    register(&ctx, format!("print:resize:{}", sel.id), handle);
+    if resp.drag_started() {
+        pu.drag = Some(Drag { cell: sel.id, origin: sel.rect, resize: true, press: press_origin(ui, &resp), total: Vec2::ZERO });
+    }
+    if resp.dragged()
+        && let Some(d) = pu.drag.as_mut().filter(|d| d.cell == sel.id && d.resize)
+    {
+        d.total = resp.interact_pointer_pos().map_or(d.total, |p| p - d.press);
+        let (w, h) = (d.origin.w + f64::from(d.total.x / sheet.scale), d.origin.h + f64::from(d.total.y / sheet.scale));
+        let threshold = f64::from(SNAP_PX / sheet.scale);
+        run(
+            app,
+            &ctx,
+            "print.cell.resize",
+            json!({"id": sel.id, "width": w.max(layout::MIN_CELL_IN), "height": h.max(layout::MIN_CELL_IN), "snap": true, "threshold": threshold}),
+        );
+    }
+    if resp.drag_stopped() {
+        pu.drag = None;
+    }
+}
+
+/// The selected cell's numbers, its place in the stack and its photo.
+fn inspector(app: &mut LightcraftApp, ui: &mut Ui, t: &Tokens, pu: &mut PrintUi, st: &PrintSettings) {
+    let ctx = ui.ctx().clone();
+    let Some(cell) = pu.selected.and_then(|id| st.layout.cell(id)) else {
+        ui.label(egui::RichText::new(crate::i18n::tr("Click a cell to move, resize or arrange it")).color(t.text_dim));
+        return;
+    };
+    let (id, r, unit) = (cell.id, cell.rect, st.guides.units);
+    ui.horizontal_wrapped(|ui| {
+        ui.spacing_mut().item_spacing.x = 4.0;
+        if let Some(v) = length(ui, "printCellX", r.x, unit, 0.0, 60.0) {
+            run(app, &ctx, "print.cell.move", json!({"id": id, "x": v, "y": r.y}));
+        }
+        if let Some(v) = length(ui, "printCellY", r.y, unit, 0.0, 60.0) {
+            run(app, &ctx, "print.cell.move", json!({"id": id, "x": r.x, "y": v}));
+        }
+        if let Some(v) = length(ui, "printCellW", r.w, unit, layout::MIN_CELL_IN, 60.0) {
+            run(app, &ctx, "print.cell.resize", json!({"id": id, "width": v, "height": r.h}));
+        }
+        if let Some(v) = length(ui, "printCellH", r.h, unit, layout::MIN_CELL_IN, 60.0) {
+            run(app, &ctx, "print.cell.resize", json!({"id": id, "width": r.w, "height": v}));
+        }
+        for (i, (how, label)) in [("toBack", "Back"), ("backward", "Backward"), ("forward", "Forward"), ("toFront", "Front")].into_iter().enumerate()
+        {
+            if text_button(ui, &format!("printStack-{i}"), label, false).clicked() {
+                run(app, &ctx, "print.cell.stack", json!({"id": id, "order": how}));
+            }
+        }
+        if st.layout.style == Style::CustomPackage {
+            if text_button(ui, "printCellPhoto", "Use Active Photo", false).clicked() {
+                let active = app.session.active().map(|p| p.0);
+                run(app, &ctx, "print.cell.photo", json!({"id": id, "photo": active}));
+            }
+            if cell.photo.is_some() && text_button(ui, "printCellPhotoClear", "Clear Photo", false).clicked() {
+                run(app, &ctx, "print.cell.photo", json!({"id": id, "photo": null}));
+            }
+        }
+        if text_button(ui, "printCellDelete", "Delete", false).clicked() {
+            run(app, &ctx, "print.cell.delete", json!({"id": id}));
+            pu.selected = None;
+        }
+    });
+}
+
+/// One cell on screen: the photo as it will print (fit or fill, turned, border, stroke).
+#[allow(clippy::too_many_arguments)]
+fn paint_cell(
+    app: &mut LightcraftApp,
+    painter: &egui::Painter,
+    t: &Tokens,
+    st: &PrintSettings,
+    cell: Rect,
+    photo: Option<PhotoId>,
+    sheet: &Sheet,
+    inches: &layout::Rect,
+) {
+    let im = &st.image;
+    if st.guides.show_cells {
+        painter.rect_stroke(cell, 0.0, Stroke::new(1.0, Color32::from_rgba_unmultiplied(120, 150, 190, 150)), StrokeKind::Inside);
+    }
+    let border = if st.layout.style.is_package() && im.border_enabled {
+        (im.border_width as f32 * sheet.scale).min(cell.width().min(cell.height()).max(2.0) / 2.0 - 1.0).max(0.0)
+    } else {
+        0.0
+    };
+    let avail = cell.shrink(border);
+    if avail.width() < 1.0 || avail.height() < 1.0 {
+        return;
+    }
+    // the photo's shape: its cropped size, or 3:2 for a placeholder
+    let (nw, nh) = photo.and_then(|id| app.session.catalog.photo(id)).map_or((3.0, 2.0), |p| {
+        let (w, h) = lightcraft_engine::export::output_size(p, &ExportOptions::default());
+        (w as f64, h as f64)
+    });
+    let scale = 8.0; // sub-point resolution for the rounding in `place`
+    let aw = (f64::from(avail.width()) * scale).round() as usize;
+    let ah = (f64::from(avail.height()) * scale).round() as usize;
+    let Some(p) = place(nw, nh, aw, ah, im.zoom_to_fill, im.rotate_to_fit) else { return };
+    let shown = Rect::from_center_size(avail.center(), vec2(p.w as f32, p.h as f32) / scale as f32);
+    let visible = shown.intersect(avail);
+    if border > 0.0 {
+        let frame = visible.expand(border);
+        let c = im.border_color;
+        painter.rect_filled(frame.intersect(cell), 0.0, Color32::from_rgb(c[0], c[1], c[2]));
+    }
+    let clip = painter.with_clip_rect(avail.intersect(painter.clip_rect()));
+    let tex = photo.and_then(|id| {
+        let px = (shown.width().max(shown.height()) * 2.0).clamp(64.0, 1024.0) as usize;
+        crate::panels::grid::request_thumb(app, id, px, 10);
+        app.renderer.thumb(id).map(|tex| tex.tex.id())
+    });
+    match tex {
+        Some(id) => {
+            let mut mesh = egui::Mesh::with_texture(id);
+            // an unturned quad maps the texture straight; a turned one (a quarter clockwise) takes
+            // the left edge to the top
+            let uv: [Pos2; 4] = if p.rotated {
+                [pos2(0.0, 1.0), pos2(0.0, 0.0), pos2(1.0, 0.0), pos2(1.0, 1.0)]
+            } else {
+                [pos2(0.0, 0.0), pos2(1.0, 0.0), pos2(1.0, 1.0), pos2(0.0, 1.0)]
+            };
+            let corners = [shown.left_top(), shown.right_top(), shown.right_bottom(), shown.left_bottom()];
+            for (pos, uv) in corners.into_iter().zip(uv) {
+                mesh.vertices.push(egui::epaint::Vertex { pos, uv, color: Color32::WHITE });
+            }
+            mesh.indices.extend([0, 1, 2, 0, 2, 3]);
+            clip.add(egui::Shape::mesh(mesh));
+        }
+        None => {
+            clip.rect_filled(shown, 0.0, if photo.is_some() { Color32::from_gray(52) } else { Color32::from_gray(200) });
+        }
+    }
+    if im.stroke_enabled && im.stroke_width_pt > 0.0 {
+        let w = (im.stroke_width_pt as f32 / 72.0 * sheet.scale).max(1.0).min(visible.width().min(visible.height()) / 2.0);
+        let c = im.stroke_color;
+        painter.rect_stroke(visible, 0.0, Stroke::new(w, Color32::from_rgb(c[0], c[1], c[2])), StrokeKind::Inside);
+    }
+    if st.guides.show_dimensions {
+        let text = format!("{} × {}", fmt_len(inches.w, st.guides.units), fmt_len(inches.h, st.guides.units));
+        let galley = painter.layout_no_wrap(text, t.font(10.0), Color32::WHITE);
+        let at = pos2(cell.center().x - galley.size().x / 2.0, cell.bottom() - galley.size().y - 3.0);
+        painter.rect_filled(Rect::from_min_size(at, galley.size()).expand(2.0), 2.0, Color32::from_black_alpha(160));
+        painter.galley(at, galley, Color32::WHITE);
+    }
+}
+
+fn dashed(painter: &egui::Painter, r: Rect, stroke: Stroke) {
+    let pts = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.left_top()];
+    painter.extend(egui::Shape::dashed_line(&pts, stroke, 5.0, 4.0));
+}
+
+/// Rulers along the top and left of the preview, in `unit`, zero at the page's corner.
+fn rulers(painter: &egui::Painter, t: &Tokens, sheet: &Sheet, area: Rect, pw: f64, ph: f64, unit: Unit) {
+    let (major, minor) = match unit {
+        Unit::Inches => (1.0, 0.25),
+        Unit::Centimeters => (1.0, 0.5),
+        Unit::Millimeters => (10.0, 5.0),
+        Unit::Points => (72.0, 18.0),
+    };
+    let tick = Stroke::new(1.0, t.text_dim);
+    let ink = t.text_dim;
+    let top = Rect::from_min_max(area.min, pos2(area.max.x, area.min.y + 20.0));
+    let left = Rect::from_min_max(area.min, pos2(area.min.x + 20.0, area.max.y));
+    painter.rect_filled(top, 0.0, t.chrome);
+    painter.rect_filled(left, 0.0, t.chrome);
+    let ticks = |len_in: f64| (0..).map(move |k| f64::from(k) * minor).take_while(move |v| *v <= unit.from_inches(len_in) + 1e-9).take(2000);
+    for v in ticks(pw) {
+        let x = sheet.page.left() + unit.to_inches(v) as f32 * sheet.scale;
+        let is_major = (v / major - (v / major).round()).abs() < 1e-9;
+        painter.line_segment([pos2(x, top.bottom()), pos2(x, top.bottom() - if is_major { 10.0 } else { 5.0 })], tick);
+        if is_major {
+            painter.text(pos2(x + 2.0, top.top() + 1.0), Align2::LEFT_TOP, format!("{}", v.round() as i64), t.font(9.0), ink);
+        }
+    }
+    for v in ticks(ph) {
+        let y = sheet.page.top() + unit.to_inches(v) as f32 * sheet.scale;
+        let is_major = (v / major - (v / major).round()).abs() < 1e-9;
+        painter.line_segment([pos2(left.right(), y), pos2(left.right() - if is_major { 10.0 } else { 5.0 }, y)], tick);
+        if is_major {
+            painter.text(pos2(left.left() + 1.0, y + 1.0), Align2::LEFT_TOP, format!("{}", v.round() as i64), t.font(9.0), ink);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lengths_read_in_the_ruler_unit() {
+        assert_eq!(fmt_len(1.0, Unit::Inches), "1.00 in");
+        assert_eq!(fmt_len(1.0, Unit::Millimeters), "25.4 mm");
+        assert_eq!(fmt_len(1.0, Unit::Points), "72 pt");
+        assert_eq!(trim(4.0), "4");
+        assert_eq!(trim(2.5), "2.5");
+        assert_eq!(paper_label("a4"), "A4");
+        assert_eq!(paper_label("4x6"), "4 × 6 in");
+    }
+}
diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs
index b76066d55..5e43cbe93 100644
--- a/crates/ui-egui/src/state.rs
+++ b/crates/ui-egui/src/state.rs
@@ -735,6 +735,9 @@ pub struct UiState {
     pub status: String,
     #[serde(skip)]
     pub dialog: Option<Dialog>,
+    /// The Print dialog's page, selection and drag.
+    #[serde(skip)]
+    pub print: crate::print_view::PrintUi,
 }
 
 /// Settings group ids (`SettingsGroup` serde names) a new preset includes by default: everything
@@ -763,6 +766,9 @@ pub struct NameEdit {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(tag = "kind", rename_all = "camelCase")]
 pub enum Dialog {
+    /// File ▸ Print…: the Print module. Its state is the session's (`print.*`); the page on show
+    /// and the selected cell are [`UiState::print`].
+    Print,
     ContactSheet {
         options: lightcraft_engine::contact_sheet::Options,
     },
@@ -1133,6 +1139,7 @@ impl Default for UiState {
             last_find_missing: None,
             status: String::new(),
             dialog: None,
+            print: Default::default(),
         }
     }
 }
diff --git a/crates/ui-egui/src/tests_print.rs b/crates/ui-egui/src/tests_print.rs
new file mode 100644
index 000000000..6dbea7a40
--- /dev/null
+++ b/crates/ui-egui/src/tests_print.rs
@@ -0,0 +1,300 @@
+//! The Print dialog, driven through the control channel: styles, cells dragged and resized with
+//! real pointer input, Auto Layout, pages, templates and the PDF.
+
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use serde_json::{Value, json};
+
+use crate::headless::Headless;
+use crate::state::Dialog;
+use crate::{LightcraftApp, Services};
+
+const T: Duration = Duration::from_secs(30);
+
+fn demo(services: Services) -> Headless {
+    let app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), services);
+    let mut h = Headless::new(app, [1400.0, 900.0], 1.0);
+    h.settle(T);
+    h
+}
+
+fn rect(h: &Headless, id: &str) -> egui::Rect {
+    h.app.widgets.iter().find(|(w, _)| w == id).map(|(_, r)| *r).unwrap_or_else(|| panic!("no widget {id}"))
+}
+
+fn has(h: &Headless, id: &str) -> bool {
+    h.app.widgets.iter().any(|(w, _)| w == id)
+}
+
+fn click(h: &mut Headless, id: &str) {
+    let r = h.request("ui.clickWidget", json!({"id": id}), T);
+    assert_eq!(r["ok"], true, "{id}: {r}");
+    h.settle(T);
+}
+
+fn drag(h: &mut Headless, id: &str, dx: f32, dy: f32) {
+    let r = h.request("ui.dragWidget", json!({"id": id, "dx": dx, "dy": dy, "steps": 8}), T);
+    assert_eq!(r["ok"], true, "{id}: {r}");
+    h.settle(T);
+}
+
+fn cmd(h: &mut Headless, id: &str, params: Value) -> Value {
+    let r = h.request("engine.execute", json!({"command": id, "params": params}), T);
+    assert_eq!(r["ok"], true, "{id}: {r}");
+    h.settle(T);
+    r["result"].clone()
+}
+
+/// The first page's MediaBox width and height in points.
+fn media_box(pdf: &[u8]) -> (f64, f64) {
+    let text = String::from_utf8_lossy(pdf);
+    let at = text.find("/MediaBox [").expect("a MediaBox") + "/MediaBox [".len();
+    let nums: Vec<f64> = text[at..].split(']').next().unwrap().split_whitespace().map(|v| v.parse().unwrap()).collect();
+    (nums[2], nums[3])
+}
+
+fn open_print(h: &mut Headless) {
+    cmd(h, "dialog.print", json!({}));
+    assert!(matches!(h.app.ui.dialog, Some(Dialog::Print)));
+    assert!(has(h, "print:page"), "the page is on screen");
+}
+
+/// Screen points per inch of the page shown.
+fn scale(h: &Headless) -> f32 {
+    rect(h, "print:page").width() / h.app.session.print.layout.page_size().unwrap().0 as f32
+}
+
+fn cell_rect(h: &Headless, id: u32) -> lightcraft_engine::print::layout::Rect {
+    h.app.session.print.layout.cell(id).unwrap().rect
+}
+
+#[test]
+fn the_print_dialog_opens_from_the_menu_command_and_closes() {
+    let mut h = demo(Services::default());
+    open_print(&mut h);
+    assert!(has(&h, "button:printStyle-0") && has(&h, "check:printZoomFill") && has(&h, "button:dialogOk"));
+    assert!(rect(&h, "print:pageLabel").width() > 0.0);
+    click(&mut h, "button:dialogCancel");
+    assert!(h.app.ui.dialog.is_none());
+}
+
+#[test]
+fn style_buttons_and_checkboxes_run_print_set() {
+    let mut h = demo(Services::default());
+    open_print(&mut h);
+    click(&mut h, "button:printStyle-1");
+    assert_eq!(h.app.session.print.layout.style, lightcraft_engine::print::layout::Style::ContactSheet);
+    assert!(has(&h, "drag:printColumns") && has(&h, "print:gridcell:0"));
+    click(&mut h, "check:printZoomFill");
+    click(&mut h, "check:printStroke");
+    assert!(h.app.session.print.image.zoom_to_fill && h.app.session.print.image.stroke_enabled);
+    click(&mut h, "button:printOrientation-1");
+    assert_eq!(h.app.session.print.layout.page.orientation, lightcraft_engine::print::layout::Orientation::Landscape);
+    let p = rect(&h, "print:page");
+    assert!(p.width() > p.height(), "the page is drawn landscape");
+    click(&mut h, "button:printUnits-2");
+    assert_eq!(h.app.session.print.guides.units, lightcraft_engine::print::layout::Unit::Millimeters);
+    click(&mut h, "check:printShowGrid");
+    assert!(h.app.session.print.guides.show_page_grid);
+}
+
+#[test]
+fn cells_are_added_dragged_resized_and_arranged() {
+    let mut h = demo(Services::default());
+    open_print(&mut h);
+    click(&mut h, "button:printStyle-3");
+    // snapping off, so the pointer maths is exact
+    cmd(&mut h, "print.set", json!({"guides": {"snap": "off"}}));
+    click(&mut h, "button:printAddCell-4");
+    click(&mut h, "button:printAddCell-1");
+    let cells: Vec<u32> = h.app.session.print.layout.cells.iter().map(|c| c.id).collect();
+    assert_eq!(cells.len(), 2);
+    assert_eq!(h.app.session.print.layout.cells[0].rect.w, 4.0);
+    assert!(has(&h, &format!("print:cell:{}", cells[0])));
+
+    // drag the first cell with the pointer: the move is in inches, through print.cell.move
+    let before = cell_rect(&h, cells[0]);
+    let s = scale(&h);
+    drag(&mut h, &format!("print:cell:{}", cells[0]), 0.0, 100.0);
+    let after = cell_rect(&h, cells[0]);
+    assert!((after.y - before.y - f64::from(100.0 / s)).abs() < 0.05, "moved {} in, expected {}", after.y - before.y, 100.0 / s);
+    assert!((after.x - before.x).abs() < 0.05);
+    assert_eq!(h.app.ui.print.selected, Some(cells[0]));
+
+    // resize with its corner handle
+    let r0 = cell_rect(&h, cells[0]);
+    drag(&mut h, &format!("print:resize:{}", cells[0]), 30.0, 20.0);
+    let r1 = cell_rect(&h, cells[0]);
+    assert!((r1.w - r0.w - f64::from(30.0 / s)).abs() < 0.05 && (r1.h - r0.h - f64::from(20.0 / s)).abs() < 0.05, "{r0:?} → {r1:?}");
+    assert_eq!((r1.x, r1.y), (r0.x, r0.y), "the top-left corner stays");
+
+    // arrange: Front moves it last
+    click(&mut h, "button:printStack-3");
+    assert_eq!(h.app.session.print.layout.cells.last().unwrap().id, cells[0]);
+    click(&mut h, "button:printStack-0");
+    assert_eq!(h.app.session.print.layout.cells.first().unwrap().id, cells[0]);
+
+    // the inspector's delete
+    click(&mut h, "button:printCellDelete");
+    assert_eq!(h.app.session.print.layout.cells.len(), 1);
+    assert_eq!(h.app.ui.print.selected, None);
+}
+
+#[test]
+fn dragging_a_cell_snaps_to_its_neighbour_when_snap_is_on() {
+    let mut h = demo(Services::default());
+    open_print(&mut h);
+    click(&mut h, "button:printStyle-3");
+    cmd(&mut h, "print.set", json!({"layout": {"spacing": 0.0}}));
+    click(&mut h, "button:printAddCell-0");
+    click(&mut h, "button:printAddCell-0");
+    let ids: Vec<u32> = h.app.session.print.layout.cells.iter().map(|c| c.id).collect();
+    assert_eq!(h.app.session.print.guides.snap, lightcraft_engine::print::layout::Snap::Cells);
+    let a = cell_rect(&h, ids[0]);
+    // park the second cell away from the first, then drag it back to 0.06 in from the first's right edge
+    cmd(&mut h, "print.cell.move", json!({"id": ids[1], "x": a.right() + 0.8, "y": a.y}));
+    let s = scale(&h);
+    drag(&mut h, &format!("print:cell:{}", ids[1]), -(0.74 * s), 0.0);
+    let r = cell_rect(&h, ids[1]);
+    assert!((r.x - a.right()).abs() < 1e-6, "snapped to the neighbour's edge: {} vs {}", r.x, a.right());
+    // with snapping off the same drag lands where the pointer put it
+    cmd(&mut h, "print.set", json!({"guides": {"snap": "off"}}));
+    cmd(&mut h, "print.cell.move", json!({"id": ids[1], "x": a.right() + 0.8, "y": a.y}));
+    drag(&mut h, &format!("print:cell:{}", ids[1]), -(0.74 * s), 0.0);
+    let r = cell_rect(&h, ids[1]);
+    assert!((r.x - (a.right() + 0.06)).abs() < 0.05 && r.x > a.right() + 0.01, "unsnapped: {}", r.x - a.right());
+}
+
+#[test]
+fn auto_layout_new_page_and_clear_buttons() {
+    let mut h = demo(Services::default());
+    open_print(&mut h);
+    click(&mut h, "button:printStyle-2");
+    for _ in 0..3 {
+        click(&mut h, "button:printAddCell-4");
+    }
+    for _ in 0..3 {
+        click(&mut h, "button:printAddCell-5");
+    }
+    let before_pages = h.app.session.print.layout.pages;
+    // scramble everything onto one spot, then pack
+    cmd(&mut h, "print.layout.autoLayout", json!({}));
+    click(&mut h, "button:printAutoLayout");
+    assert!(!h.app.session.print.layout.has_overlaps());
+    assert!(h.app.session.print.layout.pages >= before_pages.min(2));
+    let pages = h.app.session.print.layout.pages;
+    click(&mut h, "button:printNewPage");
+    assert_eq!(h.app.session.print.layout.pages, pages + 1);
+    assert_eq!(h.app.ui.print.page as u32, pages, "the new page is shown");
+    // the next-page button stays on the last page
+    click(&mut h, "button:printPageNext");
+    assert_eq!(h.app.ui.print.page as u32, pages);
+    click(&mut h, "button:printPagePrev");
+    assert_eq!(h.app.ui.print.page as u32, pages - 1);
+    click(&mut h, "button:printClear");
+    assert_eq!((h.app.session.print.layout.cells.len(), h.app.session.print.layout.pages), (0, 1));
+    assert_eq!(h.app.ui.print.page, 0);
+}
+
+#[test]
+fn templates_save_apply_and_delete_from_the_dialog() {
+    let mut h = demo(Services::default());
+    open_print(&mut h);
+    click(&mut h, "button:printStyle-1");
+    cmd(&mut h, "print.set", json!({"layout": {"grid": {"columns": 5, "rows": 6}}}));
+    h.app.ui.print.template_name = "Sheet 5x6".into();
+    click(&mut h, "button:printSaveTemplate");
+    assert_eq!(h.app.session.print_templates.len(), 1);
+    cmd(&mut h, "print.reset", json!({}));
+    assert!(has(&h, "button:printTemplateApply-0"));
+    click(&mut h, "button:printTemplateApply-0");
+    assert_eq!(h.app.session.print.layout.grid.columns, 5);
+    click(&mut h, "button:printTemplateDelete-0");
+    assert!(h.app.session.print_templates.is_empty());
+}
+
+#[test]
+fn print_to_pdf_picks_a_file_and_runs_in_the_background() {
+    let asked = Arc::new(Mutex::new(Vec::<crate::pick::PickRequest>::new()));
+    let requests = asked.clone();
+    let bytes = Arc::new(Mutex::new(Vec::new()));
+    let written = bytes.clone();
+    let services = Services {
+        picker: Some(Box::new(move |req| {
+            requests.lock().unwrap().push(req);
+            let (tx, rx) = std::sync::mpsc::channel();
+            tx.send(vec!["Print.pdf".into()]).unwrap();
+            Ok(rx)
+        })),
+        write_shared: Some(Arc::new(move |path, data| {
+            assert_eq!(path, "Print.pdf");
+            *written.lock().unwrap() = data.to_vec();
+            Ok(())
+        })),
+        ..Default::default()
+    };
+    let mut h = demo(services);
+    open_print(&mut h);
+    cmd(&mut h, "print.set", json!({"layout": {"page": {"paper": "5x7", "orientation": "landscape"}}, "job": {"ppi": 100.0}}));
+    click(&mut h, "button:dialogOk");
+    assert!(h.app.ui.dialog.is_none(), "the dialog closes once the print has started");
+    assert!(h.step_until(Duration::from_secs(60), |h| h.app.last_export_result.is_some()), "the print did not finish");
+    let req = asked.lock().unwrap();
+    assert_eq!(req[0].file_name.as_deref(), Some("Print.pdf"));
+    let b = bytes.lock().unwrap();
+    assert!(b.starts_with(b"%PDF-"));
+    let (pw, ph) = media_box(&b);
+    assert!((pw - 504.0).abs() < 1.0 && (ph - 360.0).abs() < 1.0, "7 x 5 in, got {pw} x {ph} pt");
+    assert_eq!(h.app.last_export_result.as_ref().unwrap()["files"][0]["print"], true);
+}
+
+#[test]
+fn printing_shows_a_row_in_the_activity_stack_and_stops() {
+    let mut app = LightcraftApp::new(
+        lightcraft_engine::Session::with_demo(),
+        Services { write_shared: Some(Arc::new(|_, _| panic!("a stopped print wrote a file"))), ..Default::default() },
+    );
+    app.session.execute("print.set", &json!({"layout": {"style": "contactSheet"}, "job": {"ppi": 300.0}})).unwrap();
+    let ids: Vec<_> = app.session.catalog.photos().take(12).map(|p| p.id.0).collect();
+    crate::export_task::start_print(&mut app, &json!({"path": "Stop.pdf", "ids": ids})).unwrap();
+    let rows = app.session.activity.list();
+    assert_eq!(rows.len(), 1, "{rows:?}");
+    assert_eq!((rows[0].kind, rows[0].label.as_str()), ("export", "Printing to PDF"));
+    assert!(rows[0].cancellable);
+    app.session.activity.cancel(rows[0].id).unwrap();
+    let task = app.export.take().unwrap();
+    assert!(task.cancel.load(std::sync::atomic::Ordering::Relaxed));
+    drop(task);
+    assert!(app.session.activity.list().is_empty(), "the row goes with the print");
+}
+
+#[test]
+fn the_print_menu_item_needs_a_photo_and_is_listed() {
+    let app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), Services::default());
+    assert!(crate::menus::ui_enabled(&app, "dialog.print"));
+    let empty = LightcraftApp::new(lightcraft_engine::Session::new(), Services::default());
+    assert!(!crate::menus::ui_enabled(&empty, "dialog.print"));
+}
+
+#[test]
+fn the_print_dialog_fits_the_window_with_its_buttons_on_screen() {
+    for size in [[1400.0, 900.0], [1100.0, 760.0]] {
+        for style in ["singleImage", "customPackage"] {
+            let app = LightcraftApp::new(lightcraft_engine::Session::with_demo(), Services::default());
+            let mut h = Headless::new(app, size, 1.0);
+            h.settle(T);
+            cmd(&mut h, "print.set", json!({"layout": {"style": style}}));
+            if style == "customPackage" {
+                cmd(&mut h, "print.cell.add", json!({"width": 4, "height": 6}));
+            }
+            open_print(&mut h);
+            let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, h.size);
+            let dialog = rect(&h, "dialog:window");
+            assert!(screen.contains_rect(dialog), "{style} at {size:?}: dialog {dialog:?} runs off the window");
+            for b in ["button:dialogOk", "button:dialogCancel"] {
+                assert!(dialog.contains_rect(rect(&h, b)), "{style} at {size:?}: {b} is outside the dialog");
+            }
+        }
+    }
+}
diff --git a/docs/gaps.md b/docs/gaps.md
index 72649a5bc..f24cbf5bc 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -29,7 +29,7 @@ Hours are Opus 5.5 agent wall-clock hours (see [target-app-parity.md](target-app
 | 12 | **Content-aware / generative remove, detect distractions, reflections removal** | REM rows 75%; patch synthesis missing | cleanup work goes back to Photoshop | 25–45 (+ generative model) | [target-app-parity](target-app-parity.md#ai) |
 | 13 | **Lightroom catalog migration is one-way and approximate**: unsupported Adobe profiles / AI settings archived, history kept as data | lightroom-catalog-import.md | switching users lose some looks | 8–12 | [file-format-parity](file-format-parity.md) |
 | 14 | **HDR display** (EDR / Windows HDR); HLG; the headroom limit and SDR rendition from `crs` XMP (the HDR switch, `HDREditMode`, is read) | HDR rows 70%; LR-VIEW-HDR-DISPLAY ⬜ | HDR editing works blind on HDR monitors | 12–25 | [hardware-parity](hardware-parity.md) |
-| 15 | **Print module**: no Print view (layouts, cells, image settings and templates exist as `print.*` commands only), printer colour management, identity plate / watermark / page numbers / crop marks / photo info, Custom Package Auto Layout | LRC-PRINT rows | Classic users who print | 25–40 | [target-app-parity](target-app-parity.md#features) |
+| 15 | **Print module**: printer colour management (profile, rendering intent, black point compensation, print adjustment and sharpening), identity plate / watermark / page numbers / crop marks / photo info overlays, Custom Package Auto Layout, printer-driver Page Setup and direct printing (the Print dialog writes a PDF) | LRC-PRINT rows | Classic users who print | 25–40 | [target-app-parity](target-app-parity.md#features) |
 | 16 | **Map view, Book, Slideshow module, publish services** | LRC-MAP / BOOK / SS rows ⬜ | Classic users; publish services matter for Flickr / SmugMug workflows | 60–100 | [target-app-parity](target-app-parity.md#features) |
 | 17 | **Tethered capture** | ⬜ | studio photographers | 25–45 + cameras | [hardware-parity](hardware-parity.md) |
 | 18 | **Video**: playback, trim, global edits, export | VID rows 0% | users who mix stills and clips | 25–45 | [target-app-parity](target-app-parity.md#features) |
@@ -72,6 +72,7 @@ Beta-blocking gaps (B) total **~230–430 h**; with the stability and platform w
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-12 | minor | Gap 15 shrinks: File → Print… is a Print dialog with the four layout styles, cell editing, image settings, guides, page setup and templates; printer colour management, page overlays and direct printing remain |
 | 2026-10-12 | minor | Gap 15: the Print module's layout styles, cells, image settings, templates and PDF are `print.*` commands (CLI, control, MCP); the Print view, printer colour management and page overlays remain |
 | 2026-10-12 | minor | Gap 15: print pages compose in the engine (fit / Zoom to Fill, Rotate to Fit, border, stroke, background) with an interim PDF writer; commands and UI still to land |
 | 2026-10-12 | minor | Gap 15: the Print layout model (paper sizes, margins, grid, package cells, Auto Layout packer, snapping) is in the engine; commands, composition and UI still to land |
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index 75dc988ae..4edb4eff5 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -1,6 +1,6 @@
 # Lightroom parity checklist
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (LRC-PRINT-LAYOUTSTYLE, LRC-PRINT-CELLS, LRC-PRINT-TEMPLATES and the other print rows: `print.*` commands; LRC-PRINT-IMAGESETTINGS: print page composition (fit / Zoom to Fill, Rotate to Fit, border, stroke, background); LRC-PRINT-LAYOUT: print layout model; rapid slider entry; LR-PROF-CAMERACOLOR: tone curve from black-and-white camera JPEGs; LR-VIEW-ZOOM, LR-VIEW-COMPARE: Compare and Reference zoom windows; LR-IMP-FORMATS, LR-IMP-CAMERA-COVERAGE: EOS R5 Mark II CR3 decodes; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md; filesystem history retry/Undo/Redo evidence; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (LRC-PRINT-GUIDES and the other print rows: the Print dialog (File → Print…); LRC-PRINT-LAYOUTSTYLE, LRC-PRINT-CELLS, LRC-PRINT-TEMPLATES and the other print rows: `print.*` commands; LRC-PRINT-IMAGESETTINGS: print page composition (fit / Zoom to Fill, Rotate to Fit, border, stroke, background); LRC-PRINT-LAYOUT: print layout model; rapid slider entry; LR-PROF-CAMERACOLOR: tone curve from black-and-white camera JPEGs; LR-VIEW-ZOOM, LR-VIEW-COMPARE: Compare and Reference zoom windows; LR-IMP-FORMATS, LR-IMP-CAMERA-COVERAGE: EOS R5 Mark II CR3 decodes; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md; filesystem history retry/Undo/Redo evidence; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
 
 The measured, row-by-row checklist: one row per Lightroom feature, menu item and shortcut, what we
 have and what is missing. It answers *does the feature exist?* (feature breadth). Whether it is good
@@ -52,10 +52,10 @@ cited here still exists. Formerly docs/parity.md.
 | X. Cross-cutting behaviours (BEHAV) | 23 | 6 | 1 | 1 | 8/8 (100%) | 7/10 (70%) |
 | Y. Menus | 84 | 0 | 4 | 8 | 47/47 (100%) | 23/23 (100%) |
 | Z. Keyboard shortcuts (desktop) | 76 | 3 | 3 | 1 | 49/52 (94%) | 23/24 (96%) |
-| Lightroom Classic extras | 34 | 19 | 32 | 8 | — | 24/26 (92%) |
-| **Total** | 408 | 54 | 69 | 35 | 193/201 (96%) | 145/157 (92%) |
+| Lightroom Classic extras | 38 | 16 | 31 | 8 | — | 24/26 (92%) |
+| **Total** | 412 | 51 | 68 | 35 | 193/201 (96%) | 145/157 (92%) |
 
-Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **81.9%** of 531 in-scope rows — P0 98.0% of 201 · P1 95.2% of 157 · P2 50.9% of 172.
+Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **82.4%** of 531 in-scope rows — P0 98.0% of 201 · P1 95.2% of 157 · P2 52.3% of 172.
 <!-- /parity:summary -->
 
 ## Top gaps and shortcut notes
@@ -747,14 +747,14 @@ From `08-lightroom-classic-extras.md` (Classic-only features) and part 2 of `06-
 | LRC-SS-MUSIC | Slideshow music | P2 | ⬜ | | |
 | LRC-SS-PLAYBACK | Slideshow playback | P2 | ⬜ | | |
 | LRC-SS-EXPORT | Slideshow export | P2 | ⬜ | | |
-| LRC-PRINT-LAYOUTSTYLE | Print layout styles | P2 | 🟡 | `cmd:print.set`, `cmd:print.get`, `cmd:print.exportPdf`, `cmd:export.contactSheet`, `crates/engine/src/print/layout.rs` | Single Image, Contact Sheet, Picture Package and Custom Package are print layout styles reachable from commands, the CLI, control channel and MCP; no Print module UI yet (File → Contact Sheet PDF still the only dialog) |
-| LRC-PRINT-IMAGESETTINGS | Print image settings | P2 | 🟡 | `cmd:print.set`, `crates/engine/src/print/compose.rs` | Zoom to Fill, Rotate to Fit, Photo Border (package styles), Inner Stroke (width in points, colour) through `print.set {image}`; pixel-tested; no panel yet |
-| LRC-PRINT-LAYOUT | Print layout | P2 | 🟡 | `cmd:print.set`, `cmd:print.layout.autoLayout`, `cmd:print.layout.newPage`, `cmd:print.layout.clear`, `cmd:export.contactSheet`, `crates/engine/src/print/layout.rs` | A3/A4/A5/Letter/Legal/Tabloid/4x6/5x7/8x10/13x19 and custom paper, portrait/landscape, per-side margins, grid with column/row spacing and square cells, 72–720 ppi; commands only, no panel yet |
-| LRC-PRINT-GUIDES | Print guides | P2 | ⬜ | `cmd:print.set` | guide options (ruler units in/cm/mm/pt, snap off/cells/grid, grid size, show margins/bleed/page grid/cells/dimensions) are stored and used by snapping in `print.cell.move`/`resize`; nothing is drawn until the Print UI lands |
-| LRC-PRINT-CELLS | Picture-package cells | P2 | 🟡 | `cmd:print.cell.add`, `cmd:print.cell.move`, `cmd:print.cell.resize`, `cmd:print.cell.delete`, `cmd:print.cell.stack`, `cmd:print.cell.photo`, `cmd:print.cell.page`, `cmd:print.layout.autoLayout` | add/move/resize/delete cells of any size, stacking order, per-cell photos (Custom Package), deterministic Auto Layout packer, snapping to cells or grid; no UI (drag placement) yet |
-| LRC-PRINT-PAGE | Print page options | P2 | 🟡 | `cmd:print.set`, `cmd:export.contactSheet`, `crates/engine/src/contact_sheet.rs` | page background colour and margins through `print.set`; optional filename captions in the contact-sheet PDF; no identity plates, watermarks, page numbers or crop marks |
+| LRC-PRINT-LAYOUTSTYLE | Print layout styles | P2 | ✅ | `cmd:dialog.print`, `cmd:print.set`, `cmd:print.get`, `cmd:print.exportPdf`, `cmd:export.contactSheet`, `crates/ui-egui/src/print_view.rs` | File → Print… (⌘P): Single Image, Contact Sheet, Picture Package and Custom Package, one page preview each; also `print.*` commands for the CLI, control channel and MCP; the older File → Contact Sheet PDF stays |
+| LRC-PRINT-IMAGESETTINGS | Print image settings | P2 | ✅ | `cmd:print.set`, `crates/engine/src/print/compose.rs`, `crates/ui-egui/src/print_view.rs` | Zoom to Fill Frame, Rotate to Fit, Photo Border (width, colour; package styles) and Inner Stroke (width in points, colour) in the dialog, drawn in the preview and in the PDF; pixel-tested |
+| LRC-PRINT-LAYOUT | Print layout | P2 | 🟡 | `cmd:print.set`, `cmd:print.layout.autoLayout`, `cmd:print.layout.newPage`, `cmd:print.layout.clear`, `cmd:app.print`, `cmd:export.contactSheet`, `crates/engine/src/print/layout.rs` | A3/A4/A5/Letter/Legal/Tabloid/4x6/5x7/8x10/13x19 and custom paper, portrait/landscape, per-side margins, grid with column/row spacing and square cells, 72–720 ppi, in a Print dialog with a scaled page preview; no printer-driver Page Setup, no cell size / alignment presets |
+| LRC-PRINT-GUIDES | Print guides | P2 | ✅ | `cmd:print.set`, `cmd:print.cell.move`, `crates/ui-egui/src/print_view.rs` | rulers in in/cm/mm/pt, snap off/cells/grid with a grid size, and Page Margins / Page Bleed (a fixed 0.125 in outline) / Page Grid / Image Cells / Dimensions guides drawn on the preview |
+| LRC-PRINT-CELLS | Picture-package cells | P2 | ✅ | `cmd:print.cell.add`, `cmd:print.cell.move`, `cmd:print.cell.resize`, `cmd:print.cell.delete`, `cmd:print.cell.stack`, `cmd:print.cell.photo`, `cmd:print.cell.page`, `cmd:print.layout.autoLayout`, `crates/ui-egui/src/print_view.rs` | add cells at standard or custom sizes, drag and resize them on the page preview (snap to cells, grid or off), Send to Back / Backward / Forward / Bring to Front, a photo per cell (Custom Package), Auto Layout packing, New Page, Clear Layout; no Auto Layout for Custom Package |
+| LRC-PRINT-PAGE | Print page options | P2 | 🟡 | `cmd:print.set`, `cmd:export.contactSheet`, `crates/engine/src/print/compose.rs`, `crates/ui-egui/src/print_view.rs` | page background colour and margins in the Print dialog; filename captions in the contact-sheet PDF; no identity plate, watermark, page numbers, crop marks or photo info |
 | LRC-PRINT-JOB | Print job & colour management | P2 | 🟡 | `cmd:export.contactSheet`, `cmd:app.contactSheet`, `crates/ui-egui/src/export_task.rs` | PDF export at fixed 150 dpi in sRGB, current edits, background progress/cancel and original protection; no native printer integration, ICC soft proof/print profiles or selectable resolution |
-| LRC-PRINT-TEMPLATES | Print templates | P2 | 🟡 | `cmd:print.template.save`, `cmd:print.template.apply`, `cmd:print.template.list`, `cmd:print.template.delete` | named templates of layout, image settings, page and job saved with the library (prefs.json); no built-in templates, no UI, no template import/export |
+| LRC-PRINT-TEMPLATES | Print templates | P2 | 🟡 | `cmd:print.template.save`, `cmd:print.template.apply`, `cmd:print.template.list`, `cmd:print.template.delete`, `crates/ui-egui/src/print_view.rs` | save, apply and delete named templates (layout, image settings, page, job) at the top of the Print dialog, kept with the library; no built-in templates, no folders, no import / export of template files |
 | LRC-WEB-LAYOUT | Web gallery layouts | OOS | 🚫 | | |
 | LRC-WEB-SITEINFO | Web gallery site info | OOS | 🚫 | | |
 | LRC-WEB-COLOR | Web gallery colours | OOS | 🚫 | | |
@@ -787,6 +787,7 @@ Latin stays upright. Advanced Japanese composition remains open. Regression cove
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-12 | minor | LRC-PRINT-GUIDES, LRC-PRINT-CELLS, LRC-PRINT-LAYOUTSTYLE, LRC-PRINT-IMAGESETTINGS (✅), LRC-PRINT-LAYOUT, LRC-PRINT-PAGE, LRC-PRINT-TEMPLATES (🟡): File → Print… opens the Print dialog with a scaled page preview, rulers and guides, cells dragged and resized with snapping, image settings, page setup and templates, and prints to PDF in the background |
 | 2026-10-12 | minor | LRC-PRINT-LAYOUTSTYLE, LRC-PRINT-IMAGESETTINGS, LRC-PRINT-LAYOUT, LRC-PRINT-CELLS, LRC-PRINT-PAGE, LRC-PRINT-TEMPLATES: the Print module is reachable as 18 `print.*` commands (settings, cells, Auto Layout, PDF, templates saved in prefs.json) from the CLI, control channel and MCP; 🟡 until the Print UI lands, LRC-PRINT-GUIDES stays ⬜ |
 | 2026-10-12 | minor | LRC-PRINT-IMAGESETTINGS: `print/compose.rs` composes pages (Zoom to Fill, Rotate to Fit, Photo Border, Inner Stroke, background) from the layout model into 16-bit Rec. 2020 `PageRaster`s, with an interim sRGB PDF writer in `print/output.rs`; rows stay until commands and UI reach them |
 | 2026-10-12 | minor | LRC-PRINT-LAYOUT: the Print layout model (paper, margins, grid, package cells, Auto Layout packer, snapping) lands in `print/layout.rs`; no row changes status until commands and UI follow |