diff --git a/ROADMAP.md b/ROADMAP.md
index f5de8044e1..91e8bf1ece 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,6 +2,7 @@
 
 **Stage: alpha** · next: beta, ~25% (ready for real work 50% → 75%) and ~400–700 h away
 
+> **Last reviewed:** 2026-10-28 | **Last updated:** 2026-10-28 | **Change:** minor (M10, #4119 partial: Enhance scanned file cleans scanned pages in place: background removal, edge shadow removal, despeckle; estimates unchanged)
 > **Last reviewed:** 2026-10-27 | **Last updated:** 2026-10-27 | **Change:** minor (M10: OCR model downloads use verified ONNX pairs with legacy discovery fallback; estimates unchanged)
 > **Last reviewed:** 2026-10-25 | **Last updated:** 2026-10-25 | **Change:** minor (M14 localization current state: Arabic logical catalog, explicit RTL label direction and mirrored stock chrome; native/browser RTL workflows unqualified. Native release Hans face via LXGW WenKai Lite; estimates unchanged)
 > **Last reviewed:** 2026-10-23 · **Last updated:** 2026-10-23 · **Change:** minor (M7, #2636 partial: pasting added text boxes and images in the engine and through `content_copy`; estimates unchanged)
@@ -200,6 +201,7 @@ Ranked; detail and the full milestone table in [docs/roadmap.md](docs/roadmap.md
 
 ## Progress log
 
+- **2026-10-28 (M10, #4119 partial):** Scan & OCR ▸ Enhance scanned file cleans scanned pages in place: background removal (level 0–100, as the camera clean-up), edge shadow removal (book gutters, copier borders) and despeckle. Each scan image is decoded, cleaned and written back into its own object at the same size and colour space (JPEG stays JPEG, others lossless, 1-bit stays 1-bit), so the OCR text layer, comments and links stay; one undo step, shared images once, unsupported images (CMYK, indexed, JPEG 2000, JBIG2, CCITT, broken data) reported. `page_enhance_scan` drives it headlessly. Not yet an option of Recognize text. Estimates unchanged.
 - **2026-10-27 (M10, OCR models):** Model staging downloads and verifies the ONNX pair after the upstream RTEN URL brownout; runtime discovery prefers complete ONNX pairs per directory, retains complete RTEN fallback and preserves directory precedence.
 - **2026-10-24 (M10, #4158 partial):** Word, HTML, RTF and PowerPoint export keep a block that continues another on its line (an italic case name, a link, a superscript) as a run in its own style inside that paragraph, with the source's word space, instead of a paragraph of its own. Style changes that wrap onto the next line still split paragraphs (the reading blocks keep style boundaries). Estimates unchanged.
 - **2026-10-24 (M3, window move on Wayland, #3970 follow-up):** After a move or resize by PdfCraft's own title bar or edges, the button release given back to egui goes before the pointer leaving the window, so hover no longer sticks at the old place until the pointer moves. Found by CodeRabbit in review of #3970; a unit test covers it. Estimates unchanged.
diff --git a/crates/automation/src/dispatch.rs b/crates/automation/src/dispatch.rs
index 87f47e8ebe..b8dfd36388 100644
--- a/crates/automation/src/dispatch.rs
+++ b/crates/automation/src/dispatch.rs
@@ -106,6 +106,35 @@ impl Automation {
                 out["detected"] = json!(given.is_none());
                 out
             }
+            "page_enhance_scan" => {
+                let pages = match a.opt_ints("pages")? {
+                    Some(_) => self.pages(&a, "pages")?,
+                    None => Vec::new(),
+                };
+                let level = match a.opt_int("level")? {
+                    None => pdfcraft_engine::scan_clean::ScanCleanSettings::default().level,
+                    Some(l @ 0..=100) => l as u8,
+                    Some(l) => return Err(ToolError::InvalidArgs(format!("level must be between 0 and 100, not {l}"))),
+                };
+                let mut settings = pdfcraft_engine::scan_clean::ScanCleanSettings::at(level);
+                if let Some(on) = a.opt_bool("edge_shadows")? {
+                    settings.edge_shadows = on;
+                }
+                if let Some(on) = a.opt_bool("despeckle")? {
+                    settings.despeckle = on;
+                }
+                let id = self.doc(&a)?.id;
+                let report = self.session.enhance_scanned_pages(id, &pages, settings).map_err(failed)?;
+                let numbered = |p: &[usize]| p.iter().map(|p| p + 1).collect::<Vec<_>>();
+                let skipped: Vec<Value> =
+                    report.skipped.iter().map(|k| json!({ "pages": numbered(&k.pages), "name": k.name, "reason": k.reason })).collect();
+                let mut out = summary(self.doc(&a)?);
+                out["pages_cleaned"] = json!(numbered(&report.pages));
+                out["images"] = json!(report.images);
+                out["not_scanned"] = json!(numbered(&report.not_scanned));
+                out["skipped"] = json!(skipped);
+                out
+            }
             "page_delete" => {
                 let pages = self.pages(&a, "pages")?;
                 self.apply(&a, Edit::DeletePages { pages })?
diff --git a/crates/automation/src/tools.rs b/crates/automation/src/tools.rs
index 4b4ac8873b..0d34911154 100644
--- a/crates/automation/src/tools.rs
+++ b/crates/automation/src/tools.rs
@@ -225,6 +225,18 @@ pub fn tools() -> Vec<ToolDef> {
                 }),
                 &["doc", "page"],
             )),
+        t("page_enhance_scan", "Enhance scanned file", "Clean up scanned pages in place (Scan & OCR ▸ Enhance ▸ Scanned document). A page is a scan when its pictures cover at least half of it; the pictures covering at least a tenth of it are cleaned and written back into the same image objects at the same size and colour space (a JPEG stays a JPEG at quality 90, other grey/RGB images are stored losslessly, a 1-bit image stays 1-bit), so the page's invisible OCR text, comments, links and other content stay as they were, and an image drawn on several pages is cleaned once. level (0–100, default 50) is background removal: the paper's illumination is evened out so a grey, yellowed or unevenly lit background turns white, then the contrast is raised so faint strokes darken; colour ink stays colour. edge_shadows (default: on unless level is 0) lightens shadows along the scan's edges (book gutters, a copier's dark border). despeckle (default: from level 60) turns isolated dark specks white; it is the only change a 1-bit scan takes. Returns pages_cleaned (1-based), images (rewritten), not_scanned (pages that are no scan) and skipped ([{pages, name, reason}]: CMYK, indexed, JPEG 2000, JBIG2 or CCITT images, broken data, or nothing to change). One undoable step; none when nothing changed.")
+            .cmd("ocr.enhance")
+            .with(schema(
+                json!({
+                    "doc": doc(),
+                    "pages": pages("to clean up (default: all)"),
+                    "level": { "type": "integer", "minimum": 0, "maximum": 100 },
+                    "edge_shadows": { "type": "boolean" },
+                    "despeckle": { "type": "boolean" },
+                }),
+                &["doc"],
+            )),
         t("page_delete", "Delete pages", "Delete pages. Undoable until saved.")
             .destructive()
             .cmd("page.delete")
diff --git a/crates/automation/tests/it/automation.rs b/crates/automation/tests/it/automation.rs
index 78038d8ebd..c6616f11f3 100644
--- a/crates/automation/tests/it/automation.rs
+++ b/crates/automation/tests/it/automation.rs
@@ -3376,6 +3376,62 @@ fn enhance_camera_image_through_tools() {
     ));
 }
 
+#[test]
+fn enhance_scanned_file_cleans_the_scan_in_place_through_tools() {
+    let dir = workdir("enhance-scan");
+    // A 300 × 400 grey scan: dull paper, a dark gutter at the left, text bars and a speck.
+    let img = image::GrayImage::from_fn(300, 400, |x, y| {
+        let light = 0.55 + 0.45 * (x as f32 / 60.0).min(1.0);
+        let ink = if ((60..360).contains(&y) && (y - 60) % 40 < 6 && (60..240).contains(&x)) || (x, y) == (150, 25) { 0.12 } else { 0.78 };
+        image::Luma([(ink * light * 255.0) as u8])
+    });
+    img.save(dir.join("scan.jpg")).unwrap();
+    let mut a = auto(&dir);
+    let scan = ok(&mut a, "doc_create", json!({ "from": "images", "paths": ["scan.jpg"] }))["doc"].as_u64().unwrap();
+    ok(&mut a, "image_save", json!({ "doc": scan, "page": 1, "image": 1, "path": "before.jpg" }));
+
+    let r = ok(&mut a, "page_enhance_scan", json!({ "doc": scan, "level": 100 }));
+    assert_eq!(r["undo"], "Enhance scanned file");
+    assert_eq!((r["pages_cleaned"].clone(), r["images"].clone(), r["not_scanned"].clone()), (json!([1]), json!(1), json!([])));
+    assert_eq!(r["skipped"], json!([]));
+    // In place: still one picture of the same size, still a JPEG, now with white paper.
+    let images = ok(&mut a, "page_images", json!({ "doc": scan, "page": 1 }));
+    assert_eq!((images["count"].clone(), images["images"][0]["pixels"].clone()), (json!(1), json!([300, 400])));
+    let saved = ok(&mut a, "image_save", json!({ "doc": scan, "page": 1, "image": 1, "path": "after" }));
+    assert_eq!(saved["format"], "jpg");
+    let (before, after) = (image::open(dir.join("before.jpg")).unwrap().to_luma8(), image::open(dir.join("after.jpg")).unwrap().to_luma8());
+    for (x, y) in [(150, 40), (3, 40), (3, 380), (150, 25)] {
+        assert!(
+            before.get_pixel(x, y)[0] < 200 && after.get_pixel(x, y)[0] >= 230,
+            "({x}, {y}): {:?} → {:?}",
+            before.get_pixel(x, y),
+            after.get_pixel(x, y)
+        );
+    }
+    assert!(after.get_pixel(150, 62)[0] <= 60, "a stroke stays dark");
+    // Undo puts the scan back as it was.
+    ok(&mut a, "edit_undo", json!({ "doc": scan }));
+    ok(&mut a, "image_save", json!({ "doc": scan, "page": 1, "image": 1, "path": "undone.jpg" }));
+    assert_eq!(std::fs::read(dir.join("undone.jpg")).unwrap(), std::fs::read(dir.join("before.jpg")).unwrap());
+
+    // Switches: despeckle alone leaves everything but the speck.
+    let r = ok(&mut a, "page_enhance_scan", json!({ "doc": scan, "pages": [1], "level": 0, "despeckle": true, "edge_shadows": false }));
+    assert_eq!(r["images"], 1);
+    // A document of text pages has no scans: nothing changes, and it says so.
+    let text = ok(&mut a, "doc_open", json!({ "path": "a.pdf" }))["doc"].as_u64().unwrap();
+    let r = ok(&mut a, "page_enhance_scan", json!({ "doc": text }));
+    assert_eq!((r["images"].clone(), r["not_scanned"].clone(), r["undo"].clone()), (json!(0), json!([1, 2, 3]), Value::Null));
+    // Bad arguments are refused before anything changes.
+    for bad in [
+        json!({ "doc": scan, "level": 101 }),
+        json!({ "doc": scan, "pages": [9] }),
+        json!({ "doc": scan, "despeckle": "yes" }),
+        json!({ "doc": scan, "pages": [] }),
+    ] {
+        assert!(matches!(a.call("page_enhance_scan", &bad), Err(ToolError::InvalidArgs(_))), "{bad}");
+    }
+}
+
 #[test]
 fn enhance_camera_image_finds_the_edges_by_itself() {
     let dir = workdir("enhance-camera-auto");
diff --git a/crates/engine/src/camera_clean.rs b/crates/engine/src/camera_clean.rs
index 9c4120be56..d1768a2a83 100644
--- a/crates/engine/src/camera_clean.rs
+++ b/crates/engine/src/camera_clean.rs
@@ -1,6 +1,8 @@
-//! Clean up a straightened camera photo (Enhance ▸ Camera image ▸ enhancement level): even out
-//! the lighting so the paper turns white (room-light colour casts, a hand's shadow, darker
-//! edges go with it), then raise the contrast and drop isolated specks. Colour ink stays colour.
+//! Clean up a straightened camera photo (Enhance ▸ Camera image ▸ enhancement level) or a
+//! scanned page's picture (Enhance ▸ Scanned document, [`crate::scan_clean`]): even out the
+//! lighting so the paper turns white (room-light colour casts, a hand's shadow, darker edges and
+//! book gutters go with it), then raise the contrast and drop isolated specks. Colour ink stays
+//! colour.
 //!
 //! The paper's illumination is estimated per channel on a coarse grid of blocks, from each
 //! block's bright end (the paper, not the ink), smoothed into a continuous map and divided out.
@@ -8,6 +10,8 @@
 
 /// The strongest a level can be.
 pub const MAX_LEVEL: u8 = 100;
+/// The level from which [`clean`] also drops isolated specks.
+pub const DESPECKLE_FROM: u8 = 60;
 
 /// How an enhanced camera page looks.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
@@ -66,34 +70,158 @@ pub fn apply(rgb: &[u8], width: u32, height: u32, look: Look, level: u8) -> Opti
             let even = clean(rgb, width, height, 50)?;
             let t = 0.45 + 0.4 * level.min(MAX_LEVEL) as f32 / MAX_LEVEL as f32;
             let mut grey: Vec<u8> = even.as_chunks::<3>().0.iter().map(|p| if (lum(p) as f32 / 255.0) < t { 0 } else { 255 }).collect();
-            despeckle_grey(&mut grey, w, h);
+            despeckle(&mut grey, 1, w, h);
             Pixels::Grey(grey)
         }
     })
 }
 
-/// Clean `rgb` (RGB8, `width` × `height`) at `level` (0 = unchanged … 100 = strongest).
-/// Returns `None` when the buffer doesn't match the size.
+/// Clean `rgb` (RGB8, `width` × `height`) at `level` (0 = unchanged … 100 = strongest), from
+/// [`DESPECKLE_FROM`] without isolated specks. Returns `None` when the buffer doesn't match the
+/// size.
 pub fn clean(rgb: &[u8], width: u32, height: u32, level: u8) -> Option<Vec<u8>> {
+    clean_samples(rgb, 3, width, height, CleanUp { level, edge_shadows: false, despeckle: level >= DESPECKLE_FROM })
+}
+
+/// What [`clean_samples`] does.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct CleanUp {
+    /// 0 (unchanged) … 100: even out the paper's illumination and raise the contrast, as
+    /// [`clean`]'s level.
+    pub level: u8,
+    /// Even out shadows along the picture's edges first (a book's gutter, a copier's dark edge):
+    /// lightened line by line to the paper beside them, within the outer fifth of each side.
+    pub edge_shadows: bool,
+    /// Drop isolated dark specks.
+    pub despeckle: bool,
+}
+
+/// [`clean`] for samples of `n` components (1: grey, 3: RGB), with each step chosen apart (each
+/// works at level 0 too). Returns `None` when `n` is neither or the buffer doesn't match the size.
+pub fn clean_samples(px: &[u8], n: usize, width: u32, height: u32, how: CleanUp) -> Option<Vec<u8>> {
     let (w, h) = (width as usize, height as usize);
-    if w == 0 || h == 0 || w.checked_mul(h)?.checked_mul(3)? != rgb.len() {
+    if !(n == 1 || n == 3) || w == 0 || h == 0 || w.checked_mul(h)?.checked_mul(n)? != px.len() {
         return None;
     }
-    let level = level.min(MAX_LEVEL);
-    if level == 0 {
-        return Some(rgb.to_vec());
+    let level = how.level.min(MAX_LEVEL);
+    let mut out = px.to_vec();
+    if how.edge_shadows {
+        even_edges(&mut out, n, w, h);
     }
+    if level > 0 {
+        out = even_out(&out, n, w, h, level);
+    }
+    if how.despeckle {
+        despeckle(&mut out, n, w, h);
+    }
+    Some(out)
+}
+
+/// The share of the width (and of the height) at each side where [`even_edges`] works.
+const EDGE_BAND: f32 = 0.2;
+/// The most [`even_edges`] lightens a line by; a darker line (a scanner's black border, a
+/// picture) is not taken for shadowed paper and stays as it is.
+const MAX_EDGE_GAIN: f32 = 3.0;
+
+/// Even out shadows that run along the picture's edges, in place: a book's gutter, a copier's
+/// dark border, a page that curved away from the glass. Within the outer [`EDGE_BAND`] of each
+/// side, each column (then each row) gets the paper's level along it (per channel, its 90th
+/// percentile, so the text across it doesn't count), and is lightened to the brightest paper of
+/// that band. The block grid of [`background`] is too coarse for such a narrow shadow: its
+/// blocks borrow the brighter paper next to them.
+fn even_edges(px: &mut [u8], n: usize, w: usize, h: usize) {
+    for vertical in [true, false] {
+        // Columns: lines across the width, each running down the height; rows the other way.
+        let (lines, along) = if vertical { (w, h) } else { (h, w) };
+        let band = ((lines as f32 * EDGE_BAND) as usize).min(lines / 2);
+        if band == 0 {
+            continue;
+        }
+        let at = |line: usize, i: usize| if vertical { i * w + line } else { line * w + i };
+        // The paper's level of every line in the bands and a few beyond them.
+        let reach = band.saturating_add(3).min(lines);
+        let measured = |line: usize| line < reach || line >= lines.saturating_sub(reach);
+        let mut level: Vec<Option<[f32; 3]>> = vec![None; lines];
+        let mut hist = [[0u32; 256]; 3];
+        for (line, slot) in level.iter_mut().enumerate().filter(|(line, _)| measured(*line)) {
+            hist.iter_mut().for_each(|hh| hh.fill(0));
+            for i in 0..along {
+                let p = at(line, i) * n;
+                for (c, hh) in hist.iter_mut().enumerate().take(n) {
+                    if let Some(v) = px.get(p + c)
+                        && let Some(count) = hh.get_mut(*v as usize)
+                    {
+                        *count += 1;
+                    }
+                }
+            }
+            let want = (along as f32 * 0.9) as u32;
+            *slot = Some(std::array::from_fn(|c| {
+                let mut seen = 0;
+                let v = hist.get(c).and_then(|hh| {
+                    hh.iter().position(|&count| {
+                        seen += count;
+                        seen > want
+                    })
+                });
+                v.unwrap_or(255) as f32 / 255.0
+            }));
+        }
+        // Smoothed: the median of five neighbouring lines (fewer at the very edge, centred all
+        // the same, so a gradient isn't shifted), so one odd line (a rule, a fold) doesn't stand
+        // out.
+        let smooth: Vec<Option<[f32; 3]>> = (0..lines)
+            .map(|line| {
+                level.get(line).copied().flatten()?;
+                let r = line.min(lines - 1 - line).min(2);
+                Some(std::array::from_fn(|c| {
+                    let mut near: Vec<f32> = (line - r..=line + r).filter_map(|l| level.get(l).copied().flatten()).map(|v| v[c]).collect();
+                    near.sort_by(f32::total_cmp);
+                    near.get(near.len() / 2).copied().unwrap_or(1.0)
+                }))
+            })
+            .collect();
+        // Each side's band, and the lines its paper is measured on (the band and a few beyond).
+        for (shadowed, measured) in [(0..band, 0..reach), (lines - band..lines, lines.saturating_sub(reach)..lines)] {
+            // The brightest paper there: what the shadow is lightened to.
+            let paper: [f32; 3] =
+                std::array::from_fn(|c| measured.clone().filter_map(|l| smooth.get(l).copied().flatten()).map(|v| v[c]).fold(0.0, f32::max));
+            for line in shadowed {
+                let Some(own) = smooth.get(line).copied().flatten() else { continue };
+                let gain: [f32; 3] = std::array::from_fn(|c| {
+                    let g = paper[c] / own[c].max(1e-3);
+                    if (1.0..=MAX_EDGE_GAIN).contains(&g) { g } else { 1.0 }
+                });
+                if gain.iter().take(n).all(|&g| g == 1.0) {
+                    continue;
+                }
+                for i in 0..along {
+                    let p = at(line, i) * n;
+                    for (c, g) in gain.iter().enumerate().take(n) {
+                        if let Some(v) = px.get_mut(p + c) {
+                            *v = (*v as f32 * g).round().clamp(0.0, 255.0) as u8;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// The lighting evened out and the contrast raised at `level` (1–100); `px` holds `w` × `h`
+/// pixels of `n` components.
+fn even_out(px: &[u8], n: usize, w: usize, h: usize, level: u8) -> Vec<u8> {
     let k = level as f32 / MAX_LEVEL as f32;
-    let background = background(rgb, w, h);
+    let background = background(px, n, w, h);
     // Lighting is evened out fully from half strength on; contrast keeps growing to the top.
     let flatten = (2.0 * k).min(1.0);
     let white = 1.0 - 0.12 * k; // what reaches white
     let black = 0.30 * k; // what reaches black
-    let mut out = Vec::with_capacity(rgb.len());
-    for (i, px) in rgb.as_chunks::<3>().0.iter().enumerate() {
+    let mut out = Vec::with_capacity(px.len());
+    for (i, p) in px.chunks_exact(n).enumerate() {
         let (x, y) = (i % w, i / w);
         let bg = background.at(x, y);
-        for (c, &v) in px.iter().enumerate() {
+        for (c, &v) in p.iter().enumerate() {
             let v = v as f32 / 255.0;
             let b = bg.get(c).copied().unwrap_or(1.0).max(0.05);
             let even = (v / b).min(1.0);
@@ -102,10 +230,7 @@ pub fn clean(rgb: &[u8], width: u32, height: u32, level: u8) -> Option<Vec<u8>>
             out.push((stretched * 255.0).round() as u8);
         }
     }
-    if level >= 60 {
-        despeckle(&mut out, w, h);
-    }
-    Some(out)
+    out
 }
 
 /// The paper's illumination: a grid of per-channel values, read back with bilinear
@@ -140,9 +265,10 @@ impl Background {
     }
 }
 
-/// Estimate the paper's illumination: per block, the 90th percentile of each channel (bright
-/// paper, not dark ink); blocks that are mostly ink borrow from their neighbours; then smoothed.
-fn background(rgb: &[u8], w: usize, h: usize) -> Background {
+/// Estimate the paper's illumination: per block, the 90th percentile of each of the `n` channels
+/// (bright paper, not dark ink); blocks that are mostly ink borrow from their neighbours; then
+/// smoothed. Channels past `n` stay white.
+fn background(px: &[u8], n: usize, w: usize, h: usize) -> Background {
     let block = (w.min(h) / 16).clamp(8, 128);
     let (cols, rows) = (w.div_ceil(block), h.div_ceil(block));
     let mut cells = Vec::with_capacity(cols * rows);
@@ -150,20 +276,20 @@ fn background(rgb: &[u8], w: usize, h: usize) -> Background {
     for by in 0..rows {
         for bx in 0..cols {
             hist.iter_mut().for_each(|hh| hh.fill(0));
-            let mut n = 0u32;
+            let mut count = 0u32;
             for y in by * block..((by + 1) * block).min(h) {
                 for x in bx * block..((bx + 1) * block).min(w) {
-                    if let Some(p) = rgb.get((y * w + x) * 3..(y * w + x) * 3 + 3) {
+                    if let Some(p) = px.get((y * w + x) * n..(y * w + x) * n + n) {
                         for (c, &v) in p.iter().enumerate() {
                             if let Some(slot) = hist.get_mut(c).and_then(|hh| hh.get_mut(v as usize)) {
                                 *slot += 1;
                             }
                         }
-                        n += 1;
+                        count += 1;
                     }
                 }
             }
-            let want = (n as f32 * 0.9) as u32;
+            let want = (count as f32 * 0.9) as u32;
             cells.push(std::array::from_fn(|c| {
                 let mut seen = 0;
                 let v = hist.get(c).and_then(|hh| {
@@ -219,19 +345,15 @@ fn background(rgb: &[u8], w: usize, h: usize) -> Background {
     Background { cols, rows, block: block as f32, cells }
 }
 
-/// [`despeckle`] for one grey byte per pixel.
-fn despeckle_grey(grey: &mut [u8], w: usize, h: usize) {
-    let mut rgb: Vec<u8> = grey.iter().flat_map(|&v| [v, v, v]).collect();
-    despeckle(&mut rgb, w, h);
-    for (g, p) in grey.iter_mut().zip(rgb.as_chunks::<3>().0.iter()) {
-        *g = p[0];
-    }
-}
-
-/// Lighten dark pixels with at most one dark neighbour (specks), in place.
-fn despeckle(rgb: &mut [u8], w: usize, h: usize) {
-    let lum = |p: &[u8; 3]| (p[0] as u32 * 299 + p[1] as u32 * 587 + p[2] as u32 * 114) / 1000;
-    let dark: Vec<bool> = rgb.as_chunks::<3>().0.iter().map(|p| lum(p) < 128).collect();
+/// Lighten dark pixels with at most one dark neighbour (specks), in place; `px` holds `w` × `h`
+/// pixels of `n` components (1 or 3).
+fn despeckle(px: &mut [u8], n: usize, w: usize, h: usize) {
+    let lum = |p: &[u8]| match p {
+        [r, g, b] => (*r as u32 * 299 + *g as u32 * 587 + *b as u32 * 114) / 1000,
+        [v, ..] => *v as u32,
+        [] => 255,
+    };
+    let dark: Vec<bool> = px.chunks_exact(n.max(1)).map(|p| lum(p) < 128).collect();
     let is_dark = |x: isize, y: isize| {
         x >= 0 && y >= 0 && (x as usize) < w && (y as usize) < h && dark.get(y as usize * w + x as usize).copied().unwrap_or(false)
     };
@@ -243,7 +365,7 @@ fn despeckle(rgb: &mut [u8], w: usize, h: usize) {
             let neighbours =
                 (-1..=1).flat_map(|dy| (-1..=1).map(move |dx| (dx, dy))).filter(|&(dx, dy)| (dx, dy) != (0, 0) && is_dark(x + dx, y + dy)).count();
             if neighbours <= 1
-                && let Some(p) = rgb.get_mut((y as usize * w + x as usize) * 3..(y as usize * w + x as usize) * 3 + 3)
+                && let Some(p) = px.get_mut((y as usize * w + x as usize) * n..(y as usize * w + x as usize) * n + n)
             {
                 p.fill(255);
             }
@@ -388,5 +510,40 @@ mod tests {
         assert_eq!(clean(&[], 0, 0, 50), None);
         assert_eq!(clean(&[0; 12], 2, 3, 50), None);
         assert_eq!(clean(&[9; 3], 1, 1, 255).map(|v| v.len()), Some(3));
+        let every = CleanUp { level: 100, edge_shadows: true, despeckle: true };
+        assert_eq!(clean_samples(&[0; 12], 2, 2, 3, every), None, "two components");
+        assert_eq!(clean_samples(&[0; 5], 1, 2, 3, every), None);
+        for (w, h) in [(1, 1), (1, 9), (9, 1), (2, 2), (5, 3)] {
+            assert_eq!(clean_samples(&vec![100; w * h], 1, w as u32, h as u32, every).map(|v| v.len()), Some(w * h));
+        }
+    }
+
+    #[test]
+    fn edge_shadows_lighten_shadowed_paper_but_not_a_black_border_or_the_middle() {
+        // Grey paper (200) with a shadow darkening the left 20 columns to 120, a black scanner
+        // border in the right 8 columns, and a dark block in the middle.
+        let (w, h) = (100usize, 60usize);
+        let mut grey = vec![200u8; w * h];
+        for y in 0..h {
+            for x in 0..w {
+                let v = if x >= w - 8 {
+                    5
+                } else if (40..60).contains(&x) && (20..40).contains(&y) {
+                    30
+                } else if x < 20 {
+                    120 + (80 * x / 20) as u8
+                } else {
+                    200
+                };
+                grey[y * w + x] = v;
+            }
+        }
+        let out = clean_samples(&grey, 1, w as u32, h as u32, CleanUp { level: 0, edge_shadows: true, despeckle: false }).unwrap();
+        for x in [0, 5, 19] {
+            assert!(out[30 * w + x].abs_diff(200) <= 3, "column {x}: {} → {}", grey[30 * w + x], out[30 * w + x]);
+        }
+        assert_eq!(out[30 * w + w - 3], 5, "a black border is no shadow");
+        assert_eq!(out[30 * w + 50], 30, "the middle is untouched");
+        assert_eq!(out[30 * w + 30], 200);
     }
 }
diff --git a/crates/engine/src/catalog.rs b/crates/engine/src/catalog.rs
index e479232bbb..47394a7bb5 100644
--- a/crates/engine/src/catalog.rs
+++ b/crates/engine/src/catalog.rs
@@ -265,7 +265,7 @@ pub static TOOL_GROUPS: &[ToolGroup] = &[
             items: &[
                 item("In this file", "scan-text", "ocr.recognize", Ready),
                 item("In multiple files", "files", "ocr.recognize_batch", Ready),
-                item("Enhance scanned file", "sparkles", "ocr.enhance", Planned("M10")),
+                item("Enhance scanned file", "sparkles", "ocr.enhance", Ready),
                 item("Enhance camera image", "camera", "ocr.enhance_camera", Ready),
                 item("Correct recognized text", "text-select", "ocr.correct", Planned("M10")),
             ],
diff --git a/crates/engine/src/commands.rs b/crates/engine/src/commands.rs
index 1f25c23c98..8c83996c6d 100644
--- a/crates/engine/src/commands.rs
+++ b/crates/engine/src/commands.rs
@@ -352,6 +352,7 @@ pub const COMMANDS: &[CommandSpec] = &[
     c("tools.document_js", "Document JavaScripts…", None, None, Modification, "file-code"),
     c("ocr.recognize", "Recognize text…", None, None, Modification, "scan-text"),
     c("ocr.enhance_camera", "Enhance camera image", None, None, Modification, "camera"),
+    c("ocr.enhance", "Enhance scanned file…", None, None, Modification, "sparkles"),
     c("ocr.recognize_batch", "Recognize text in multiple files…", None, None, Nothing, "files"),
     c("a11y.check", "Check for accessibility…", None, None, Document, "accessibility"),
     c("a11y.find_untagged", "Find untagged content", None, None, Document, "search"),
diff --git a/crates/engine/src/edit.rs b/crates/engine/src/edit.rs
index c31984ca19..655a1ce558 100644
--- a/crates/engine/src/edit.rs
+++ b/crates/engine/src/edit.rs
@@ -375,6 +375,13 @@ pub enum Edit {
         page: usize,
         words: Vec<pdfcraft_ocr::PlacedWord>,
     },
+    /// Scan & OCR ▸ Enhance ▸ Scanned document: put the scan images
+    /// [`ScanCleanJob::run`](crate::scan_clean::ScanCleanJob::run) cleaned in place of the old
+    /// ones (each object must still be an image). Built by
+    /// [`Session::apply_scan_clean`](crate::Session::apply_scan_clean).
+    EnhanceScan {
+        images: Vec<(pdfcraft_cos::ObjRef, pdfcraft_cos::Stream)>,
+    },
     /// Edit a PDF ▸ Edit text: replace the text of line `line` (from `Document::text_lines`) on
     /// `page`, in its own font when it can show it, else in Helvetica.
     EditTextLine {
diff --git a/crates/engine/src/edit/labels.rs b/crates/engine/src/edit/labels.rs
index ea25898068..ff86f21a08 100644
--- a/crates/engine/src/edit/labels.rs
+++ b/crates/engine/src/edit/labels.rs
@@ -98,6 +98,7 @@ pub const EDIT_LABELS: &[&str] = &[
     "Set alternate text",
     "Mark figure as decorative",
     "Recognize text",
+    "Enhance scanned file",
     "Run JavaScript",
     "Run form script",
     "Save as {level}",
@@ -239,6 +240,7 @@ impl Edit {
             Edit::MarkDecorative { .. } => Label::of("Mark figure as decorative"),
             Edit::MarkTagArtifact { .. } => Label::of("Mark content as artifact"),
             Edit::AddOcrText { .. } => Label::of("Recognize text"),
+            Edit::EnhanceScan { .. } => Label::of("Enhance scanned file"),
             Edit::ApplyScriptChanges { .. } => Label::of("Run JavaScript"),
             Edit::XfaEvent { .. } => Label::of("Run form script"),
             // The level is the standard's own name ("PDF/A-2b"), so it goes in as it stands.
diff --git a/crates/engine/src/edit/run.rs b/crates/engine/src/edit/run.rs
index 49f19fa637..e2a99665aa 100644
--- a/crates/engine/src/edit/run.rs
+++ b/crates/engine/src/edit/run.rs
@@ -121,6 +121,7 @@ pub(crate) fn check_permission(edit: &Edit, p: &pdfcraft_cos::Permissions) -> Re
         | Edit::MarkDecorative { .. }
         | Edit::MarkTagArtifact { .. }
         | Edit::AddOcrText { .. }
+        | Edit::EnhanceScan { .. }
         | Edit::SetDocumentScript { .. }
         | Edit::SetFieldScript { .. }
         | Edit::RemoveStandardId { .. }
@@ -491,6 +492,7 @@ pub(crate) fn run_edit(doc: &mut pdfcraft_cos::Document, edit: &Edit, cx: &mut E
         Edit::AddOcrText { page, words } => {
             pdfcraft_edit::stamp(doc, *page, "OCR", pdfcraft_ocr::text_layer(words))?;
         }
+        Edit::EnhanceScan { images } => crate::scan_clean::write_back(doc, images)?,
         Edit::EditPageImage { page, index, change } => {
             let img = pdfcraft_edit::page_images(doc, *page)?
                 .into_iter()
diff --git a/crates/engine/src/history.rs b/crates/engine/src/history.rs
index fafa65b4c2..0fe874e711 100644
--- a/crates/engine/src/history.rs
+++ b/crates/engine/src/history.rs
@@ -77,6 +77,7 @@ pub(crate) fn scope_of(edit: &Edit) -> Scope {
         | Edit::EditTextLine { .. }
         | Edit::EditTextBlock { .. }
         | Edit::EditPageImage { .. }
+        | Edit::EnhanceScan { .. }
         | Edit::AddText { .. }
         | Edit::AddImage { .. }
         | Edit::UpdateContent { .. }
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 889b839368..9e2eb54389 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -43,6 +43,7 @@ mod pictures;
 pub mod print_raster;
 pub mod printcheck;
 mod protection;
+pub mod scan_clean;
 mod scan_colours;
 mod scan_fields;
 mod session;
diff --git a/crates/engine/src/scan_clean.rs b/crates/engine/src/scan_clean.rs
new file mode 100644
index 0000000000..bfc8188b29
--- /dev/null
+++ b/crates/engine/src/scan_clean.rs
@@ -0,0 +1,276 @@
+//! Scan & OCR ▸ Enhance ▸ Scanned document: clean up the pictures scanned pages are made of.
+//!
+//! Unlike Enhance ▸ Camera image, the page is not rendered and replaced: each scan image is
+//! decoded, cleaned ([`crate::camera_clean::clean_samples`]) and written back **into the same
+//! image object**, at the same size and in the same colour space. So everything else on the
+//! page stays as it was: an invisible OCR text layer, comments, links, form fields, other
+//! content, and the image's own soft mask, `/Interpolate` and other entries. A JPEG stays a JPEG
+//! (at quality 90), any other grey or RGB image is stored losslessly (Flate), and a black and
+//! white (1-bit) image stays 1-bit. An image several pages draw is cleaned once.
+//!
+//! A page is a scan when its pictures cover at least half of it (as for Recognize text); the
+//! pictures each covering at least a tenth of the page are its scan. What is not cleaned is
+//! reported, never skipped silently: pages that are no scan, and scan images in a form PdfCraft
+//! can't rewrite yet (CMYK, indexed, JPEG 2000, JBIG2, CCITT fax, a stencil mask, a remapping
+//! decode array) or whose data is broken.
+//!
+//! Like Optimize, the work is a job: [`Session::scan_clean_job`] captures the document,
+//! [`ScanCleanJob::run`] cleans anywhere (a worker thread), and [`Session::apply_scan_clean`]
+//! makes the result one undoable step, "Enhance scanned file" (the name the Scan & OCR tool has).
+
+use pdfcraft_cos::{ObjRef, Object, Stream};
+
+use crate::camera_clean::{CleanUp, MAX_LEVEL, clean_samples};
+use crate::edit::check_permission;
+use crate::{DocId, Edit, EditError, Session, guard, optimize};
+
+pub use crate::camera_clean::DESPECKLE_FROM;
+
+/// The JPEG quality a cleaned JPEG scan is written back at (as Enhance camera image).
+const QUALITY: u8 = 90;
+/// On a scanned page, an image covering at least this share of the page is part of the scan;
+/// smaller ones (a logo or a signature pasted on) are left alone.
+const PART_OF_SCAN: f64 = 0.1;
+
+/// How scanned pages are cleaned up.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ScanCleanSettings {
+    /// Background removal, 0 (off) … 100 (strongest), as Enhance camera image's clean-up level:
+    /// the paper's illumination is evened out (fully from 50), so a grey, yellowed or unevenly lit
+    /// background turns white; then the contrast is raised so faint strokes darken. Colour ink
+    /// stays colour.
+    pub level: u8,
+    /// Edge shadow removal: shadows along the scan's edges (a book's gutter, a copier's dark
+    /// border) are lightened to the paper next to them, line by line, before the level applies.
+    pub edge_shadows: bool,
+    /// Despeckle: isolated dark specks (dust, scanner noise), dark pixels with at most one dark
+    /// neighbour, turn white. The only change a black and white (1-bit) scan takes.
+    pub despeckle: bool,
+}
+
+impl ScanCleanSettings {
+    /// The level `level` (capped at 100) with edge shadow removal (unless the level is 0), and
+    /// despeckling from [`DESPECKLE_FROM`] as the camera tool does.
+    pub fn at(level: u8) -> Self {
+        let level = level.min(MAX_LEVEL);
+        Self { level, edge_shadows: level > 0, despeckle: level >= DESPECKLE_FROM }
+    }
+
+    /// Whether these settings change anything at all.
+    pub fn changes_something(self) -> bool {
+        self.level > 0 || self.edge_shadows || self.despeckle
+    }
+}
+
+impl Default for ScanCleanSettings {
+    fn default() -> Self {
+        Self::at(50)
+    }
+}
+
+/// What a clean-up did.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct ScanCleanReport {
+    /// Pages (0-based) whose scan was cleaned, in order.
+    pub pages: Vec<usize>,
+    /// Images rewritten. One drawn on several pages counts once.
+    pub images: usize,
+    /// Pages left alone because no picture covers most of them.
+    pub not_scanned: Vec<usize>,
+    /// Scan images left as they were, and why.
+    pub skipped: Vec<SkippedImage>,
+}
+
+/// A scan image that was not cleaned.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SkippedImage {
+    /// The pages (0-based) that draw it, among those asked for.
+    pub pages: Vec<usize>,
+    /// Its resource name on the first of them.
+    pub name: String,
+    /// Why, in a sentence that follows "skipped because".
+    pub reason: String,
+}
+
+/// One image to clean: its object, its name and the pages that draw it.
+struct Target {
+    object: ObjRef,
+    name: String,
+    pages: Vec<usize>,
+}
+
+/// What cleaning scanned pages needs, independent of the session.
+pub struct ScanCleanJob {
+    cos: pdfcraft_cos::Document,
+    targets: Vec<Target>,
+    settings: ScanCleanSettings,
+    /// The document's edit generation it was taken at: a result is for that state only.
+    generation: u64,
+    report: ScanCleanReport,
+}
+
+/// The cleaned images, ready for [`Session::apply_scan_clean`], and the report.
+pub struct ScanCleaned {
+    images: Vec<(ObjRef, Stream)>,
+    generation: u64,
+    pub report: ScanCleanReport,
+}
+
+impl Session {
+    /// Capture what cleaning up the scans on `pages` (0-based; empty = all) of document `id`
+    /// needs. Errors when the document can't be changed (read-only, or its permissions forbid
+    /// changes) or a page doesn't exist.
+    pub fn scan_clean_job(&self, id: DocId, pages: &[usize], settings: ScanCleanSettings) -> Result<ScanCleanJob, EditError> {
+        let doc = self.get(id).ok_or(EditError::NoDocument)?;
+        if let Some(why) = &doc.read_only_reason {
+            return Err(EditError::ReadOnly(why.clone()));
+        }
+        let editor = doc.editor.as_ref().ok_or_else(|| EditError::ReadOnly(String::new()))?;
+        if let Some(p) = editor.cos.permissions() {
+            check_permission(&Edit::EnhanceScan { images: Vec::new() }, &p)?;
+        }
+        let all = doc.info.pages.len();
+        let mut wanted: Vec<usize> = if pages.is_empty() { (0..all).collect() } else { pages.to_vec() };
+        if let Some(p) = wanted.iter().find(|p| **p >= all) {
+            return Err(EditError::Invalid(format!("there is no page {}: the document has {all}", p.saturating_add(1))));
+        }
+        wanted.sort_unstable();
+        wanted.dedup();
+        let mut report = ScanCleanReport::default();
+        let mut targets: Vec<Target> = Vec::new();
+        for page in wanted {
+            let Some(info) = doc.info.pages.get(page) else { continue };
+            let Some(images) = crate::scan_fields::scan_images(doc, page, info) else {
+                report.not_scanned.push(page);
+                continue;
+            };
+            for (image, _) in images.into_iter().filter(|(_, share)| *share >= PART_OF_SCAN) {
+                let Some(object) = image.object else {
+                    report.skipped.push(SkippedImage {
+                        pages: vec![page],
+                        name: image.name,
+                        reason: "it is stored inside the page's resources rather than as an object of its own".into(),
+                    });
+                    continue;
+                };
+                match targets.iter_mut().find(|t| t.object == object) {
+                    Some(t) if !t.pages.contains(&page) => t.pages.push(page),
+                    Some(_) => {}
+                    None => targets.push(Target { object, name: image.name, pages: vec![page] }),
+                }
+            }
+        }
+        Ok(ScanCleanJob { cos: editor.cos.clone(), targets, settings, generation: doc.edit_generation(), report })
+    }
+
+    /// Write the images [`ScanCleanJob::run`] cleaned into document `id` as one undoable step,
+    /// "Enhance scanned file" (none when nothing was cleaned), and return the report. Refused
+    /// when the document changed since the job was taken.
+    pub fn apply_scan_clean(&mut self, id: DocId, cleaned: ScanCleaned) -> Result<ScanCleanReport, EditError> {
+        let doc = self.get(id).ok_or(EditError::NoDocument)?;
+        if doc.edit_generation() != cleaned.generation {
+            return Err(EditError::Invalid("the document changed while its scans were being cleaned up; nothing was changed, try again".into()));
+        }
+        if !cleaned.images.is_empty() {
+            self.apply(id, Edit::EnhanceScan { images: cleaned.images })?;
+        }
+        Ok(cleaned.report)
+    }
+
+    /// Enhance ▸ Scanned document in one call: [`Self::scan_clean_job`], run, then
+    /// [`Self::apply_scan_clean`] (the CLI and agents use this).
+    pub fn enhance_scanned_pages(&mut self, id: DocId, pages: &[usize], settings: ScanCleanSettings) -> Result<ScanCleanReport, EditError> {
+        let job = self.scan_clean_job(id, pages, settings)?;
+        let cleaned = job.run(|_, _| true)?;
+        self.apply_scan_clean(id, cleaned)
+    }
+}
+
+impl ScanCleanJob {
+    /// The images to clean (one drawn on several pages counts once).
+    pub fn total(&self) -> usize {
+        self.targets.len()
+    }
+
+    /// Clean every scan image. `progress(done, total)` is called before each image; returning
+    /// `false` stops with [`EditError::Cancelled`]. A panic is returned as an error, so a worker
+    /// thread always reports back.
+    pub fn run(self, mut progress: impl FnMut(usize, usize) -> bool) -> Result<ScanCleaned, EditError> {
+        guard(move || self.work(&mut progress)).map_err(|m| EditError::Invalid(format!("cleaning up the scans failed unexpectedly ({m})")))?
+    }
+
+    fn work(self, progress: &mut dyn FnMut(usize, usize) -> bool) -> Result<ScanCleaned, EditError> {
+        let ScanCleanJob { cos, targets, settings, generation, mut report } = self;
+        let total = targets.len();
+        let mut images = Vec::new();
+        let mut changed_pages: Vec<usize> = Vec::new();
+        for (done, target) in targets.into_iter().enumerate() {
+            if !progress(done, total) {
+                return Err(EditError::Cancelled);
+            }
+            let mut skip = |reason: String| report.skipped.push(SkippedImage { pages: target.pages.clone(), name: target.name.clone(), reason });
+            match clean_image(&cos, target.object, settings) {
+                Ok(Some(stream)) => {
+                    images.push((target.object, stream));
+                    changed_pages.extend(target.pages.iter().copied());
+                }
+                Ok(None) => skip("it is already clean: nothing changes at these settings".into()),
+                Err(reason) => skip(reason),
+            }
+        }
+        changed_pages.sort_unstable();
+        changed_pages.dedup();
+        report.images = images.len();
+        report.pages = changed_pages;
+        report.skipped.sort_by_key(|s| s.pages.first().copied());
+        Ok(ScanCleaned { images, generation, report })
+    }
+}
+
+/// Image `object` cleaned with `settings`: the new stream, `None` when nothing changes, or why it
+/// can't be cleaned.
+fn clean_image(cos: &pdfcraft_cos::Document, object: ObjRef, settings: ScanCleanSettings) -> Result<Option<Stream>, String> {
+    let obj = cos.get(object);
+    let Object::Stream(s) = &*obj else { return Err("it is not an image".into()) };
+    if s.dict.name(b"Subtype") != Some(b"Image") {
+        return Err("it is not an image".into());
+    }
+    // A colour-key mask names sample values to leave unpainted: cleaned samples would match others.
+    if matches!(s.dict.get(b"Mask").map(|m| cos.resolve(m)).as_deref(), Some(Object::Array(_))) {
+        return Err("it has a colour-key mask, which cleaning would change".into());
+    }
+    let samples = optimize::decode_samples(cos, s).map_err(|e| e.to_string())?;
+    let cleaned = if samples.bilevel {
+        if !settings.despeckle {
+            return Err("it is black and white, which only Despeckle changes, and Despeckle is off".into());
+        }
+        clean_samples(&samples.data, 1, samples.width, samples.height, CleanUp { level: 0, edge_shadows: false, despeckle: true })
+    } else {
+        if !settings.changes_something() {
+            return Ok(None);
+        }
+        let how = CleanUp { level: settings.level, edge_shadows: settings.edge_shadows, despeckle: settings.despeckle };
+        clean_samples(&samples.data, samples.components, samples.width, samples.height, how)
+    }
+    .ok_or("its samples don't match its size")?;
+    if cleaned == samples.data {
+        return Ok(None);
+    }
+    let cleaned = optimize::Samples { data: cleaned, ..samples };
+    optimize::encode_samples(s, &cleaned, QUALITY).map(Some).ok_or_else(|| "it could not be written back".into())
+}
+
+/// [`Edit::EnhanceScan`]: put the cleaned images in place. Each object must still be an image.
+pub(crate) fn write_back(doc: &mut pdfcraft_cos::Document, images: &[(ObjRef, Stream)]) -> Result<(), EditError> {
+    for (object, stream) in images {
+        let is_image = matches!(&*doc.get(*object), Object::Stream(s) if s.dict.name(b"Subtype") == Some(b"Image"));
+        if !is_image {
+            return Err(EditError::Invalid(format!("object {} is no longer an image; the scan was not changed", object.num)));
+        }
+        doc.set(*object, Object::Stream(stream.clone()));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/engine/src/scan_clean/tests.rs b/crates/engine/src/scan_clean/tests.rs
new file mode 100644
index 0000000000..561ba9e2e4
--- /dev/null
+++ b/crates/engine/src/scan_clean/tests.rs
@@ -0,0 +1,338 @@
+use std::sync::Arc;
+
+use pdfcraft_testkit::Pdf;
+
+use super::*;
+
+const W: usize = 300;
+const H: usize = 400;
+/// Isolated specks on the paper, away from the text rows.
+const SPECKS: [(usize, usize); 3] = [(150, 25), (200, 85), (120, 125)];
+
+/// The light falling on the paper at `x`: full in the middle, darker towards a shadowed left
+/// edge (as a book's gutter) and a little at the right edge.
+fn light(x: usize) -> f32 {
+    let left = (x as f32 / 60.0).min(1.0);
+    let right = ((W - 1 - x) as f32 / 30.0).min(1.0);
+    (0.55 + 0.45 * left) * (0.8 + 0.2 * right)
+}
+
+fn is_stroke(x: usize, y: usize) -> bool {
+    (60..360).contains(&y) && (y - 60) % 40 < 6 && (60..240).contains(&x)
+}
+
+/// A synthetic scan, `n` components (1 grey, 3 RGB): greyish yellowed paper, a shadowed gutter,
+/// dark text strokes and a few specks.
+fn scan_pixels(n: usize) -> Vec<u8> {
+    let mut out = Vec::with_capacity(W * H * n);
+    for y in 0..H {
+        for x in 0..W {
+            let ink = if is_stroke(x, y) || SPECKS.contains(&(x, y)) { 0.12 } else { 0.8 };
+            let v = ink * light(x);
+            let px = [v, v, v * 0.85];
+            for c in px.iter().take(n) {
+                out.push((c * 255.0).round().clamp(0.0, 255.0) as u8);
+            }
+        }
+    }
+    out
+}
+
+fn jpeg(px: &[u8], n: usize) -> Vec<u8> {
+    let mut out = Vec::new();
+    let ty = if n == 1 { image::ExtendedColorType::L8 } else { image::ExtendedColorType::Rgb8 };
+    image::ImageEncoder::write_image(image::codecs::jpeg::JpegEncoder::new_with_quality(&mut out, 95), px, W as u32, H as u32, ty).unwrap();
+    out
+}
+
+/// Three pages: 1 a scan (the image `image_dict`/`data` as object 4) with an invisible text
+/// layer and a comment, 2 a page of real text, 3 the same scan image drawn again.
+fn scan_pdf(image_dict: &str, data: &[u8]) -> Vec<u8> {
+    let resources = "/Resources << /XObject << /Im0 4 0 R >> /Font << /F1 5 0 R >> >>";
+    Pdf::new()
+        .obj("<< /Type /Catalog /Pages 2 0 R >>")
+        .obj("<< /Type /Pages /Kids [3 0 R 8 0 R 9 0 R] /Count 3 >>")
+        .obj(format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {W} {H}] {resources} /Contents 6 0 R /Annots [7 0 R] >>"))
+        .stream(&format!("/Type /XObject /Subtype /Image {image_dict}"), data)
+        .obj("<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>")
+        .stream("", format!("q {W} 0 0 {H} 0 0 cm /Im0 Do Q BT 3 Tr /F1 12 Tf 20 380 Td (Invisible OCR words) Tj ET"))
+        .obj("<< /Type /Annot /Subtype /Square /Rect [10 10 50 50] /C [1 0 0] /Contents (A comment) >>")
+        .obj(format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {W} {H}] {resources} /Contents 10 0 R >>"))
+        .obj(format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {W} {H}] {resources} /Contents 11 0 R >>"))
+        .stream("", "BT /F1 12 Tf 20 380 Td (Real text) Tj ET")
+        .stream("", format!("q {W} 0 0 {H} 0 0 cm /Im0 Do Q"))
+        .build()
+}
+
+fn grey_scan() -> Vec<u8> {
+    scan_pdf(&format!("/Width {W} /Height {H} /ColorSpace /DeviceGray /BitsPerComponent 8 /Interpolate true"), &scan_pixels(1))
+}
+
+fn open(bytes: Vec<u8>) -> (Session, DocId) {
+    let mut s = Session::new().with_clock(|| 1_700_000_000);
+    let id = s.open("scan.pdf", None, Arc::new(bytes), None).unwrap();
+    (s, id)
+}
+
+fn object(s: &Session, id: DocId, num: u32) -> Arc<Object> {
+    s.get(id).unwrap().editor.as_ref().unwrap().cos.get(ObjRef::new(num, 0))
+}
+
+/// The samples of the image page 1 draws, now.
+fn samples(s: &Session, id: DocId) -> optimize::Samples {
+    let doc = s.get(id).unwrap();
+    let object = doc.page_images(0)[0].object.unwrap();
+    let cos = &doc.editor.as_ref().unwrap().cos;
+    let Object::Stream(img) = &*cos.get(object) else { panic!("the image") };
+    optimize::decode_samples(cos, img).unwrap()
+}
+
+fn grey_at(px: &optimize::Samples, x: usize, y: usize) -> u8 {
+    px.data[(y * W + x) * px.components]
+}
+
+#[test]
+fn a_scan_gets_white_paper_even_edges_dark_strokes_and_no_specks_in_place() {
+    let (mut s, id) = open(grey_scan());
+    let before = samples(&s, id);
+    let kept: Vec<Arc<Object>> = [3, 5, 6, 7, 8, 10, 11].iter().map(|&n| object(&s, id, n)).collect();
+    let text_before = s.get(id).unwrap().text_lines(0);
+    let original = s.get(id).unwrap().bytes.clone();
+
+    let report = s.enhance_scanned_pages(id, &[], ScanCleanSettings::at(100)).unwrap();
+    assert_eq!(report.pages, vec![0, 2], "the shared image counts for both its pages");
+    assert_eq!(report.images, 1);
+    assert_eq!(report.not_scanned, vec![1], "the text page is no scan");
+    assert!(report.skipped.is_empty(), "{:?}", report.skipped);
+    assert_eq!(s.get(id).unwrap().can_undo(), Some("Enhance scanned file"));
+
+    let after = samples(&s, id);
+    assert_eq!((after.width, after.height, after.components, after.jpeg), (W as u32, H as u32, 1, false));
+    // Paper, also in the shadowed gutter and at the right edge, turns (nearly) white.
+    for (x, y) in [(150, 40), (150, 380), (3, 40), (3, 380), (30, 200), (W - 2, 40)] {
+        assert!(grey_at(&before, x, y) < 210, "the fixture's paper is grey at ({x}, {y})");
+        assert!(grey_at(&after, x, y) >= 235, "paper at ({x}, {y}): {} → {}", grey_at(&before, x, y), grey_at(&after, x, y));
+    }
+    // The edge is evened out: the gutter is as white as the middle.
+    assert!(grey_at(&after, 150, 40).abs_diff(grey_at(&after, 3, 40)) <= 12);
+    // Strokes stay dark (darker, with the contrast), also in the gutter's light.
+    for (x, y) in [(150, 62), (61, 102), (238, 342)] {
+        assert!(grey_at(&after, x, y) <= 40, "stroke at ({x}, {y}): {}", grey_at(&after, x, y));
+    }
+    for (x, y) in SPECKS {
+        assert!(grey_at(&before, x, y) < 60);
+        assert!(grey_at(&after, x, y) >= 200, "speck at ({x}, {y}): {}", grey_at(&after, x, y));
+    }
+    // Everything but the image is as it was: the page, its invisible text layer, the comment, the
+    // font, the other pages. The image keeps its entries.
+    let now: Vec<Arc<Object>> = [3, 5, 6, 7, 8, 10, 11].iter().map(|&n| object(&s, id, n)).collect();
+    assert_eq!(kept, now);
+    assert_eq!(s.get(id).unwrap().info.pages.len(), 3);
+    let text_after = s.get(id).unwrap().text_lines(0);
+    assert!(text_after.iter().any(|l| l.text.contains("Invisible OCR words")), "{text_after:?}");
+    assert_eq!(text_before.len(), text_after.len());
+    let Object::Stream(img) = &*object(&s, id, 4) else { panic!("the image") };
+    assert_eq!(img.dict.get(b"Interpolate"), Some(&Object::Bool(true)));
+    assert_eq!(img.dict.name(b"ColorSpace"), Some(&b"DeviceGray"[..]));
+
+    // Undo brings the original image, and the original file, back.
+    s.undo(id).unwrap();
+    assert_eq!(samples(&s, id), before);
+    assert_eq!(s.get(id).unwrap().bytes, original);
+    assert_eq!(s.get(id).unwrap().can_undo(), None);
+}
+
+#[test]
+fn a_jpeg_scan_stays_a_jpeg_in_colour() {
+    let px = scan_pixels(3);
+    let (mut s, id) = open(scan_pdf(&format!("/Width {W} /Height {H} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode"), &jpeg(&px, 3)));
+    let report = s.enhance_scanned_pages(id, &[0], ScanCleanSettings::at(80)).unwrap();
+    // Only page 1 was asked for; the image it shares with page 3 is changed for both.
+    assert_eq!((report.pages.as_slice(), report.images), (&[0][..], 1));
+    let after = samples(&s, id);
+    assert!(after.jpeg && after.components == 3);
+    let Object::Stream(img) = &*object(&s, id, 4) else { panic!("the image") };
+    assert_eq!(img.dict.name(b"Filter"), Some(&b"DCTDecode"[..]));
+    // Yellowed paper becomes white; the strokes stay dark.
+    let at = |x: usize, y: usize| after.data[(y * W + x) * 3..][..3].to_vec();
+    for (x, y) in [(150, 40), (5, 300)] {
+        assert!(at(x, y).iter().all(|&v| v >= 230), "paper at ({x}, {y}): {:?}", at(x, y));
+    }
+    assert!(at(150, 63).iter().all(|&v| v <= 60), "stroke: {:?}", at(150, 63));
+    // The file still renders.
+    let doc = s.get(id).unwrap();
+    let shot = pdfcraft_render::PageRenderer::new(doc.bytes.clone(), doc.config.clone()).render(pdfcraft_render::RenderRequest {
+        page: 0,
+        scale: 1.0,
+        ..Default::default()
+    });
+    assert!(shot.error.is_none(), "{:?}", shot.error);
+}
+
+#[test]
+fn despeckle_is_its_own_switch() {
+    let speck = |settings: ScanCleanSettings| {
+        let (mut s, id) = open(grey_scan());
+        s.enhance_scanned_pages(id, &[0], settings).unwrap();
+        let after = samples(&s, id);
+        SPECKS.iter().map(|&(x, y)| grey_at(&after, x, y)).max().unwrap_or(0)
+    };
+    assert!(speck(ScanCleanSettings { despeckle: false, ..ScanCleanSettings::at(80) }) < 100, "kept without despeckle");
+    assert!(speck(ScanCleanSettings::at(80)) >= 200);
+    // Despeckle alone, at level 0, changes nothing but the specks.
+    let (mut s, id) = open(grey_scan());
+    let before = samples(&s, id);
+    s.enhance_scanned_pages(id, &[], ScanCleanSettings { level: 0, edge_shadows: false, despeckle: true }).unwrap();
+    let after = samples(&s, id);
+    let changed: Vec<usize> = before.data.iter().zip(&after.data).enumerate().filter(|(_, (a, b))| a != b).map(|(i, _)| i).collect();
+    let mut specks: Vec<usize> = SPECKS.iter().map(|&(x, y)| y * W + x).collect();
+    specks.sort_unstable();
+    assert_eq!(changed, specks);
+    // Nothing to do: no undo step, and the report says why.
+    let (mut s, id) = open(grey_scan());
+    let report = s.enhance_scanned_pages(id, &[], ScanCleanSettings { level: 0, edge_shadows: false, despeckle: false }).unwrap();
+    assert_eq!(report.images, 0);
+    assert!(report.pages.is_empty());
+    assert_eq!(report.skipped.len(), 1);
+    assert!(report.skipped[0].reason.contains("already clean"), "{:?}", report.skipped);
+    assert_eq!(s.get(id).unwrap().can_undo(), None);
+    assert!(!s.get(id).unwrap().dirty);
+}
+
+#[test]
+fn a_black_and_white_scan_stays_one_bit_and_loses_its_specks() {
+    // 64 × 64, one bit per pixel, 1 = white: a black bar and two specks.
+    let (w, h) = (64usize, 64usize);
+    let mut bits = vec![0xFFu8; w / 8 * h];
+    let mut black = |x: usize, y: usize| bits[y * w / 8 + x / 8] &= !(0x80 >> (x % 8));
+    for y in 20..30 {
+        for x in 10..50 {
+            black(x, y);
+        }
+    }
+    black(5, 5);
+    black(58, 58);
+    let bytes = Pdf::new()
+        .obj("<< /Type /Catalog /Pages 2 0 R >>")
+        .obj("<< /Type /Pages /Kids [3 0 R] /Count 1 >>")
+        .obj("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 64 64] /Resources << /XObject << /Im0 4 0 R >> >> /Contents 5 0 R >>")
+        .stream("/Type /XObject /Subtype /Image /Width 64 /Height 64 /ColorSpace /DeviceGray /BitsPerComponent 1", &bits)
+        .stream("", "q 64 0 0 64 0 0 cm /Im0 Do Q")
+        .build();
+    let (mut s, id) = open(bytes);
+    // Only Despeckle changes a black and white scan: without it the image is reported.
+    let report = s.enhance_scanned_pages(id, &[], ScanCleanSettings { despeckle: false, ..ScanCleanSettings::at(100) }).unwrap();
+    assert_eq!(report.images, 0);
+    assert!(report.skipped.first().is_some_and(|k| k.reason.contains("black and white")), "{:?}", report.skipped);
+    let report = s.enhance_scanned_pages(id, &[], ScanCleanSettings::at(100)).unwrap();
+    assert_eq!(report.images, 1);
+    let Object::Stream(img) = &*object(&s, id, 4) else { panic!("the image") };
+    assert_eq!(img.dict.int(b"BitsPerComponent"), Some(1));
+    let px = samples(&s, id);
+    assert!(px.bilevel);
+    let at = |x: usize, y: usize| px.data[y * w + x];
+    assert_eq!((at(5, 5), at(58, 58)), (255, 255), "specks gone");
+    assert_eq!((at(10, 20), at(30, 25), at(49, 29)), (0, 0, 0), "the bar stays");
+    assert_eq!(px.data.iter().filter(|&&v| v == 0).count(), 40 * 10);
+}
+
+#[test]
+fn hostile_images_are_reported_not_a_panic() {
+    // Each page draws one image over the whole page.
+    let images: [(&str, Vec<u8>); 6] = [
+        ("/Width 100000 /Height 100000 /ColorSpace /DeviceGray /BitsPerComponent 8", vec![0; 64]),
+        ("/Width 300 /Height 400 /ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /DCTDecode", vec![0xFF, 0xD8, 0xFF, 0xE0, 0, 3, 9]),
+        ("/Width 300 /Height 400 /ColorSpace /DeviceGray /BitsPerComponent 8", vec![200; 1000]),
+        ("/Width 1 /Height 1 /ColorSpace /DeviceGray /BitsPerComponent 8", vec![128]),
+        ("/Width 8 /Height 8 /ColorSpace /DeviceCMYK /BitsPerComponent 8", vec![0; 256]),
+        ("/Width 300 /Height 400 /ColorSpace /DeviceGray /BitsPerComponent 8 /Mask [250 255]", vec![200; 300 * 400]),
+    ];
+    let n = images.len();
+    let kids: String = (0..n).map(|i| format!("{} 0 R ", 3 + 3 * i)).collect();
+    let mut pdf = Pdf::new().obj("<< /Type /Catalog /Pages 2 0 R >>").obj(format!("<< /Type /Pages /Kids [{kids}] /Count {n} >>"));
+    for (i, (dict, data)) in images.iter().enumerate() {
+        let (img, contents) = (4 + 3 * i, 5 + 3 * i);
+        pdf = pdf
+            .obj(format!(
+                "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 400] /Resources << /XObject << /Im0 {img} 0 R >> >> /Contents {contents} 0 R >>"
+            ))
+            .stream(&format!("/Type /XObject /Subtype /Image {dict}"), data)
+            .stream("", "q 300 0 0 400 0 0 cm /Im0 Do Q");
+    }
+    let (mut s, id) = open(pdf.build());
+    let report = s.enhance_scanned_pages(id, &[], ScanCleanSettings::at(100)).unwrap();
+    assert_eq!(report.images, 0);
+    assert_eq!(report.not_scanned, vec![3], "a 1 × 1 image is no scan");
+    let why: Vec<(usize, &str)> = report.skipped.iter().map(|k| (k.pages[0], k.reason.as_str())).collect();
+    assert_eq!(why.len(), 5, "{why:?}");
+    assert!(why[0].0 == 0 && why[0].1.contains("80 million"), "{why:?}");
+    assert!(why[1].0 == 1 && why[1].1.contains("could not be decoded"), "{why:?}");
+    assert!(why[2].0 == 2 && why[2].1.contains("shorter"), "{why:?}");
+    assert!(why[3].0 == 4 && why[3].1.contains("colour space"), "{why:?}");
+    assert!(why[4].0 == 5 && why[4].1.contains("colour-key mask"), "{why:?}");
+    assert_eq!(s.get(id).unwrap().can_undo(), None);
+    // Pages that don't exist are an error, not a panic.
+    assert!(matches!(s.enhance_scanned_pages(id, &[99], ScanCleanSettings::default()), Err(EditError::Invalid(_))));
+}
+
+#[test]
+fn protected_documents_keep_their_encryption_and_restrictions() {
+    let protect = |user: &str, permissions: i32| {
+        let mut doc = pdfcraft_cos::Document::open(Arc::new(grey_scan())).unwrap();
+        doc.set_encryption(&pdfcraft_cos::NewEncryption {
+            algorithm: pdfcraft_cos::Algorithm::Aes256,
+            user_password: user,
+            owner_password: "owner",
+            permissions,
+            encrypt_metadata: true,
+            seed: [7; 32],
+        })
+        .unwrap();
+        Arc::new(pdfcraft_cos::write_full(&doc, &Default::default()).unwrap())
+    };
+    // Opened with the password: cleaned, saved still encrypted, and the clean scan reads back.
+    let mut s = Session::new();
+    let id = s.open("x.pdf", None, protect("pw", -1), Some("pw")).unwrap();
+    assert_eq!(s.enhance_scanned_pages(id, &[], ScanCleanSettings::at(100)).unwrap().images, 1);
+    let saved = s.save_bytes(id).unwrap();
+    assert!(pdfcraft_cos::Document::open(saved.clone()).is_err(), "still protected");
+    let id2 = s.open("y.pdf", None, saved, Some("pw")).unwrap();
+    assert!(grey_at(&samples(&s, id2), 3, 40) >= 235);
+    // Changes withheld: refused before any work.
+    let id = s.open("r.pdf", None, protect("", 0b0100), None).unwrap();
+    assert_eq!(s.enhance_scanned_pages(id, &[], ScanCleanSettings::default()).unwrap_err(), EditError::NotPermitted("changes to the document"));
+    assert!(!s.get(id).unwrap().dirty);
+}
+
+#[test]
+fn a_result_for_an_older_state_is_refused() {
+    let (mut s, id) = open(grey_scan());
+    let job = s.scan_clean_job(id, &[], ScanCleanSettings::at(70)).unwrap();
+    assert_eq!(job.total(), 1);
+    let cleaned = job.run(|_, _| true).unwrap();
+    s.apply(id, Edit::RotatePages { pages: vec![1], degrees: 90 }).unwrap();
+    assert!(matches!(s.apply_scan_clean(id, cleaned), Err(EditError::Invalid(_))));
+    assert_eq!(s.get(id).unwrap().can_undo(), Some("Rotate page"));
+    // Cancelled from the progress callback.
+    let job = s.scan_clean_job(id, &[], ScanCleanSettings::at(70)).unwrap();
+    assert!(matches!(job.run(|_, _| false), Err(EditError::Cancelled)));
+}
+
+#[test]
+fn edge_shadow_removal_whitens_the_gutter_background_removal_alone_leaves() {
+    let gutter = |edge_shadows: bool| {
+        let (mut s, id) = open(grey_scan());
+        s.enhance_scanned_pages(id, &[0], ScanCleanSettings { edge_shadows, ..ScanCleanSettings::at(100) }).unwrap();
+        let after = samples(&s, id);
+        [(3, 40), (3, 380), (10, 200)].map(|(x, y)| grey_at(&after, x, y))
+    };
+    assert!(gutter(false).iter().any(|&v| v < 200), "{:?}", gutter(false));
+    assert!(gutter(true).iter().all(|&v| v >= 235), "{:?}", gutter(true));
+    // On its own, at level 0, it lightens the gutter's paper to the paper beside it.
+    let (mut s, id) = open(grey_scan());
+    let before = samples(&s, id);
+    s.enhance_scanned_pages(id, &[0], ScanCleanSettings { level: 0, edge_shadows: true, despeckle: false }).unwrap();
+    let after = samples(&s, id);
+    assert!(grey_at(&after, 3, 40).abs_diff(grey_at(&before, 150, 40)) <= 4, "{} vs {}", grey_at(&after, 3, 40), grey_at(&before, 150, 40));
+    assert_eq!(grey_at(&after, 150, 40), grey_at(&before, 150, 40), "the middle is left alone");
+}
diff --git a/crates/engine/src/scan_fields.rs b/crates/engine/src/scan_fields.rs
index 8287743fc5..769beaefca 100644
--- a/crates/engine/src/scan_fields.rs
+++ b/crates/engine/src/scan_fields.rs
@@ -25,24 +25,33 @@ const MIN_WORD_HEIGHT: f64 = 4.0;
 
 /// Whether `page` is a picture of a page: images cover most of it.
 pub(crate) fn is_scan(doc: &Document, page: usize, info: &PageInfo) -> bool {
+    scan_images(doc, page, info).is_some()
+}
+
+/// The raster images (larger than one pixel) `page` draws, each with the share of the page (its
+/// crop box) it covers, when together they cover most of it ([`is_scan`]); `None` otherwise.
+/// Enhance ▸ Scanned document cleans these up ([`crate::scan_clean`]).
+pub(crate) fn scan_images(doc: &Document, page: usize, info: &PageInfo) -> Option<Vec<(pdfcraft_edit::PageImage, f64)>> {
     let [cx0, cy0, cx1, cy1] = info.crop.map(f64::from);
     let page_area = (cx1 - cx0) * (cy1 - cy0);
     if !page_area.is_finite() || page_area <= 0.0 {
-        return false;
+        return None;
     }
-    let covered: f64 = doc
+    let images: Vec<(pdfcraft_edit::PageImage, f64)> = doc
         .page_images(page)
-        .iter()
+        .into_iter()
         .filter(|i| !i.is_form && i.width > 1 && i.height > 1)
         .map(|i| {
             let r = i.visible_rect.unwrap_or(i.rect);
             let w = (r[2].min(cx1) - r[0].max(cx0)).max(0.0);
             let h = (r[3].min(cy1) - r[1].max(cy0)).max(0.0);
-            w * h
+            let share = w * h / page_area;
+            (i, share)
         })
-        .filter(|a| a.is_finite())
-        .sum();
-    covered >= COVERED * page_area
+        .filter(|(_, share)| share.is_finite())
+        .collect();
+    let covered: f64 = images.iter().map(|(_, share)| share).sum();
+    (covered >= COVERED).then_some(images)
 }
 
 /// The page as displayed, in points with y up: where detection on a scan works.
diff --git a/crates/optimize/src/images.rs b/crates/optimize/src/images.rs
index b9761b85fc..f19d7d8fc7 100644
--- a/crates/optimize/src/images.rs
+++ b/crates/optimize/src/images.rs
@@ -8,7 +8,7 @@ use pdfcraft_cos::{DecodeBudget, Dict, Document, ObjRef, Object, Stream};
 use crate::{Compression, ImageSettings, OptimizeError, Report, Settings, Stage};
 
 /// Images with more pixels than this are left alone (memory).
-const MAX_PIXELS: u64 = 80_000_000;
+pub(crate) const MAX_PIXELS: u64 = 80_000_000;
 
 /// The resources of a page, inherited from the page tree if the page has none.
 pub(crate) fn page_resources(doc: &Document, page: ObjRef) -> Option<Dict> {
@@ -203,7 +203,7 @@ pub(crate) fn components(doc: &Document, cs: &Object) -> Option<usize> {
     }
 }
 
-fn is_dct(s: &Stream) -> Option<bool> {
+pub(crate) fn is_dct(s: &Stream) -> Option<bool> {
     match s.dict.get(b"Filter") {
         None => Some(false),
         Some(Object::Name(n)) => match n.as_slice() {
@@ -288,7 +288,7 @@ pub(crate) fn pixels(doc: &Document, s: &Stream, n: usize) -> Option<Vec<u8>> {
 /// /ColorTransform contradict each other (PdfCraft's renderer lets /ColorTransform 0 win where
 /// the standard lets the marker win), either holds a value other than 0 or 1, or the parameters
 /// or the JPEG's segments can't be read.
-fn ycc_encoded(doc: &Document, s: &Stream) -> Option<bool> {
+pub(crate) fn ycc_encoded(doc: &Document, s: &Stream) -> Option<bool> {
     let entry = color_transform(doc, s)?;
     match adobe_transform(&s.raw)? {
         Some(t @ (0 | 1)) => entry.is_none_or(|c| c == i64::from(t)).then_some(t == 1),
@@ -412,7 +412,7 @@ pub(crate) fn resample(px: &[u8], n: usize, w: u32, h: u32, nw: u32, nh: u32) ->
     })
 }
 
-fn jpeg(px: &[u8], n: usize, w: u32, h: u32, quality: u8) -> Option<Vec<u8>> {
+pub(crate) fn jpeg(px: &[u8], n: usize, w: u32, h: u32, quality: u8) -> Option<Vec<u8>> {
     let mut out = Vec::new();
     let mut enc = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut out, quality.clamp(1, 100));
     let ty = if n == 1 { image::ExtendedColorType::L8 } else { image::ExtendedColorType::Rgb8 };
@@ -435,7 +435,7 @@ pub(crate) fn decodable(doc: &Document, s: &Stream) -> Option<bool> {
 
 /// Whether `decode` is the default decode array for `n` components ([0 1] each), which changes
 /// nothing. Scanners write it on page images (#490).
-fn is_identity_decode(doc: &Document, decode: &Object, n: usize) -> bool {
+pub(crate) fn is_identity_decode(doc: &Document, decode: &Object, n: usize) -> bool {
     let decode = doc.resolve(decode);
     let Some(a) = decode.as_array() else { return false };
     a.len() == 2 * n && a.chunks(2).all(|p| matches!(p, [lo, hi] if doc.resolve(lo).as_f64() == Some(0.0) && doc.resolve(hi).as_f64() == Some(1.0)))
diff --git a/crates/optimize/src/lib.rs b/crates/optimize/src/lib.rs
index 9f9fcdf2be..cb6b537115 100644
--- a/crates/optimize/src/lib.rs
+++ b/crates/optimize/src/lib.rs
@@ -27,6 +27,7 @@ mod audit;
 pub mod fragments;
 mod images;
 mod links;
+mod samples;
 mod unused;
 
 pub use audit::{SpaceCategory, SpaceUse, audit_space};
@@ -35,6 +36,7 @@ use pdfcraft_cos::{Dict, Document, MAX_PAGE_DECODED, ObjRef, Object, Stream, ser
 use pdfcraft_filters::{Filter, Params};
 
 pub use images::effective_resolutions;
+pub use samples::{NotDecoded, Samples, decode_samples, encode_samples};
 
 #[derive(Debug, thiserror::Error)]
 pub enum OptimizeError {
diff --git a/crates/optimize/src/samples.rs b/crates/optimize/src/samples.rs
new file mode 100644
index 0000000000..7f402b51b8
--- /dev/null
+++ b/crates/optimize/src/samples.rs
@@ -0,0 +1,273 @@
+//! An image's samples read out and written back at the same size, for tools that change the
+//! pixels of an image in place (Scan & OCR ▸ Enhance ▸ Scanned document). The image dictionary
+//! stays as it was apart from the encoding: its size, colour space, masks, `/Interpolate`,
+//! `/Intent`, `/Metadata` and every other entry are kept.
+
+use pdfcraft_cos::{Document, Object, Stream};
+
+use crate::images::{MAX_PIXELS, components, is_dct, is_identity_decode, jpeg, pixels, ycc_encoded};
+
+/// An image's samples, one byte each, row-major.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Samples {
+    pub width: u32,
+    pub height: u32,
+    /// 1 (grey) or 3 (RGB).
+    pub components: usize,
+    /// The samples. A bi-level image's are 0 (black) or 255 (white) as drawn, whatever its
+    /// decode array.
+    pub data: Vec<u8>,
+    /// Stored as a JPEG (written back as one); otherwise written back losslessly (Flate).
+    pub jpeg: bool,
+    /// One bit per pixel (written back as one).
+    pub bilevel: bool,
+    /// A bi-level image whose 1 bits are black (decode array `[1 0]`): written back the same way,
+    /// so its decode array stays true.
+    pub inverted: bool,
+}
+
+/// Why an image's samples were not read. Each says what the image is, so a report can name it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
+pub enum NotDecoded {
+    #[error("it is a stencil mask, not a picture")]
+    StencilMask,
+    #[error("its colour space is not grey or RGB (CMYK, indexed and special colours are not supported yet)")]
+    ColourSpace,
+    #[error("it has {0} bits per sample (8, and 1 for black and white, are supported)")]
+    BitDepth(i64),
+    #[error("its decode array remaps the samples")]
+    Decode,
+    #[error("it is compressed in a format PdfCraft cannot read back yet (JPEG 2000, JBIG2 or CCITT fax)")]
+    Filter,
+    #[error("its JPEG colour transform is ambiguous, so readers may disagree about its colours")]
+    Ambiguous,
+    #[error("it is larger than 80 million pixels")]
+    TooLarge,
+    #[error("its data could not be decoded, or is shorter than its size says")]
+    Corrupt,
+}
+
+/// Read the samples of image stream `s` (a dictionary with `/Subtype /Image`).
+pub fn decode_samples(doc: &Document, s: &Stream) -> Result<Samples, NotDecoded> {
+    let d = &s.dict;
+    if matches!(d.get(b"ImageMask").map(|v| doc.resolve(v)).as_deref(), Some(Object::Bool(true))) {
+        return Err(NotDecoded::StencilMask);
+    }
+    let n = d.get(b"ColorSpace").and_then(|cs| components(doc, cs)).ok_or(NotDecoded::ColourSpace)?;
+    let bpc = d.get(b"BitsPerComponent").map(|v| doc.resolve(v)).and_then(|v| v.as_int()).unwrap_or(0);
+    let bilevel = match bpc {
+        8 => false,
+        1 if n == 1 => true,
+        other => return Err(NotDecoded::BitDepth(other)),
+    };
+    let jpeg = is_dct(s).ok_or(NotDecoded::Filter)?;
+    let width = d.get(b"Width").map(|v| doc.resolve(v)).and_then(|v| v.as_int()).and_then(|v| u32::try_from(v).ok()).unwrap_or(0);
+    let height = d.get(b"Height").map(|v| doc.resolve(v)).and_then(|v| v.as_int()).and_then(|v| u32::try_from(v).ok()).unwrap_or(0);
+    if width == 0 || height == 0 {
+        return Err(NotDecoded::Corrupt);
+    }
+    if u64::from(width) * u64::from(height) > MAX_PIXELS {
+        return Err(NotDecoded::TooLarge);
+    }
+    if bilevel {
+        if jpeg {
+            // A JPEG has 8 bits per sample: the dictionary contradicts the data.
+            return Err(NotDecoded::Corrupt);
+        }
+        let inverted = match d.get(b"Decode") {
+            None => false,
+            Some(a) if is_identity_decode(doc, a, 1) => false,
+            Some(a) if is_inverted_decode(doc, a) => true,
+            Some(_) => return Err(NotDecoded::Decode),
+        };
+        let data = unpack_bits(s, width, height, inverted).ok_or(NotDecoded::Corrupt)?;
+        return Ok(Samples { width, height, components: 1, data, jpeg: false, bilevel: true, inverted });
+    }
+    if d.get(b"Decode").is_some_and(|a| !is_identity_decode(doc, a, n)) {
+        return Err(NotDecoded::Decode);
+    }
+    if jpeg && n == 3 && ycc_encoded(doc, s).is_none() {
+        return Err(NotDecoded::Ambiguous);
+    }
+    let data = pixels(doc, s, n).ok_or(NotDecoded::Corrupt)?;
+    Ok(Samples { width, height, components: n, data, jpeg, bilevel: false, inverted: false })
+}
+
+/// `[1 0]`: a bi-level image whose 1 bits are black.
+fn is_inverted_decode(doc: &Document, decode: &Object) -> bool {
+    let decode = doc.resolve(decode);
+    matches!(decode.as_array().map(Vec::as_slice), Some([a, b]) if doc.resolve(a).as_f64() == Some(1.0) && doc.resolve(b).as_f64() == Some(0.0))
+}
+
+/// The bytes a `w` × `h` bi-level image takes: each row padded to whole bytes.
+fn packed_len(w: u32, h: u32) -> Option<usize> {
+    usize::try_from(w).ok()?.div_ceil(8).checked_mul(usize::try_from(h).ok()?)
+}
+
+/// A bi-level image's pixels, 0 (black) or 255 (white) as drawn.
+fn unpack_bits(s: &Stream, w: u32, h: u32, inverted: bool) -> Option<Vec<u8>> {
+    let stride = usize::try_from(w).ok()?.div_ceil(8);
+    let need = packed_len(w, h)?;
+    // Some writers pad the data; anything far longer than the image needs is not this image.
+    let bits = s.decoded_within(need.saturating_add(need / 2).saturating_add(4096)).ok()?;
+    let bits = bits.get(..need)?;
+    let (w, h) = (usize::try_from(w).ok()?, usize::try_from(h).ok()?);
+    let mut out = Vec::with_capacity(w.checked_mul(h)?);
+    for row in bits.chunks(stride).take(h) {
+        for x in 0..w {
+            let byte = row.get(x / 8).copied().unwrap_or(0);
+            let one = byte & (0x80 >> (x % 8)) != 0;
+            // Without a decode array 0 is black and 1 white; [1 0] swaps them.
+            out.push(if one != inverted { 255 } else { 0 });
+        }
+    }
+    Some(out)
+}
+
+/// The pixels (0 black … 255 white, threshold at half) packed back to bits.
+fn pack_bits(px: &[u8], w: u32, h: u32, inverted: bool) -> Option<Vec<u8>> {
+    let stride = usize::try_from(w).ok()?.div_ceil(8);
+    let mut out = vec![0u8; packed_len(w, h)?];
+    let (w, h) = (usize::try_from(w).ok()?, usize::try_from(h).ok()?);
+    if px.len() != w.checked_mul(h)? {
+        return None;
+    }
+    for (y, row) in px.chunks(w.max(1)).enumerate() {
+        for (x, &v) in row.iter().enumerate() {
+            let white = v >= 128;
+            if white != inverted
+                && let Some(b) = out.get_mut(y * stride + x / 8)
+            {
+                *b |= 0x80 >> (x % 8);
+            }
+        }
+    }
+    Some(out)
+}
+
+/// Image stream `old` with its samples replaced by `samples` (same size and components): a JPEG
+/// stays a JPEG (at `quality`, 1–100), anything else becomes Flate, and a bi-level image stays
+/// one bit per pixel with its decode array. Filter parameters go (the new data needs none); every
+/// other entry stays. `None` if the samples don't fit the image.
+pub fn encode_samples(old: &Stream, samples: &Samples, quality: u8) -> Option<Stream> {
+    let Samples { width, height, components: n, data, jpeg: as_jpeg, bilevel, inverted } = samples;
+    let (w, h, n) = (*width, *height, *n);
+    if !(n == 1 || n == 3) || data.len() != usize::try_from(w).ok()?.checked_mul(usize::try_from(h).ok()?)?.checked_mul(n)? {
+        return None;
+    }
+    let mut d = old.dict.clone();
+    for k in [&b"Filter"[..], b"DecodeParms", b"Length", b"DL"] {
+        d.remove(k);
+    }
+    if *bilevel {
+        if n != 1 {
+            return None;
+        }
+        d.set(b"BitsPerComponent".to_vec(), Object::Int(1));
+        return Some(Stream::flate(d, &pack_bits(data, w, h, *inverted)?));
+    }
+    d.set(b"BitsPerComponent".to_vec(), Object::Int(8));
+    if *as_jpeg {
+        let bytes = jpeg(data, n, w, h, quality)?;
+        d.set(b"Filter".to_vec(), Object::name("DCTDecode"));
+        Some(Stream::from_raw(d, bytes))
+    } else {
+        Some(Stream::flate(d, data))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pdfcraft_cos::Dict;
+
+    fn image(dict: &[(&str, Object)], raw: Vec<u8>) -> Stream {
+        let mut d = Dict::new();
+        d.set(b"Type".to_vec(), Object::name("XObject"));
+        d.set(b"Subtype".to_vec(), Object::name("Image"));
+        for (k, v) in dict {
+            d.set(k.as_bytes().to_vec(), v.clone());
+        }
+        Stream::from_raw(d, raw)
+    }
+
+    fn doc() -> Document {
+        let pdf = b"%PDF-1.7\n1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n2 0 obj\n<< /Type /Pages /Kids [] /Count 0 >>\nendobj\ntrailer\n<< /Root 1 0 R >>\n%%EOF\n";
+        Document::open(std::sync::Arc::new(pdf.to_vec())).unwrap()
+    }
+
+    #[test]
+    fn grey_samples_round_trip_losslessly_and_keep_the_other_entries() {
+        let px: Vec<u8> = (0..12 * 5).map(|i| (i * 4) as u8).collect();
+        let s = image(
+            &[
+                ("Width", Object::Int(12)),
+                ("Height", Object::Int(5)),
+                ("ColorSpace", Object::name("DeviceGray")),
+                ("BitsPerComponent", Object::Int(8)),
+                ("Interpolate", Object::Bool(true)),
+            ],
+            px.clone(),
+        );
+        let got = decode_samples(&doc(), &s).unwrap();
+        assert_eq!((got.width, got.height, got.components, got.jpeg, got.bilevel), (12, 5, 1, false, false));
+        assert_eq!(got.data, px);
+        let back = encode_samples(&s, &got, 90).unwrap();
+        assert_eq!(back.dict.name(b"Filter"), Some(&b"FlateDecode"[..]));
+        assert_eq!(back.dict.get(b"Interpolate"), Some(&Object::Bool(true)));
+        assert_eq!(decode_samples(&doc(), &back).unwrap().data, px);
+    }
+
+    #[test]
+    fn bilevel_samples_keep_their_decode_array_and_bits() {
+        // 10 × 2: first row black on the left half, second row all white; [1 0] makes 1 black.
+        let raw = vec![0b1111_1000, 0b0000_0000, 0, 0];
+        let s = image(
+            &[
+                ("Width", Object::Int(10)),
+                ("Height", Object::Int(2)),
+                ("ColorSpace", Object::name("DeviceGray")),
+                ("BitsPerComponent", Object::Int(1)),
+                ("Decode", Object::Array(vec![Object::Int(1), Object::Int(0)])),
+            ],
+            raw.clone(),
+        );
+        let got = decode_samples(&doc(), &s).unwrap();
+        assert!(got.bilevel);
+        assert_eq!(&got.data[..10], &[0, 0, 0, 0, 0, 255, 255, 255, 255, 255]);
+        assert!(got.data[10..].iter().all(|&v| v == 255));
+        assert!(got.inverted);
+        let back = encode_samples(&s, &got, 90).unwrap();
+        assert_eq!(back.dict.int(b"BitsPerComponent"), Some(1));
+        assert!(back.dict.get(b"Decode").is_some());
+        assert_eq!(back.decoded().unwrap(), raw);
+    }
+
+    #[test]
+    fn what_is_not_supported_says_why_and_never_panics() {
+        let base = |extra: &[(&str, Object)], raw: Vec<u8>| {
+            let mut d: Vec<(&str, Object)> = vec![
+                ("Width", Object::Int(4)),
+                ("Height", Object::Int(4)),
+                ("ColorSpace", Object::name("DeviceGray")),
+                ("BitsPerComponent", Object::Int(8)),
+            ];
+            d.extend(extra.iter().cloned());
+            decode_samples(&doc(), &image(&d, raw))
+        };
+        assert_eq!(base(&[("ColorSpace", Object::name("DeviceCMYK"))], vec![0; 64]), Err(NotDecoded::ColourSpace));
+        assert_eq!(base(&[("BitsPerComponent", Object::Int(4))], vec![0; 8]), Err(NotDecoded::BitDepth(4)));
+        assert_eq!(base(&[("Filter", Object::name("JBIG2Decode"))], vec![0; 8]), Err(NotDecoded::Filter));
+        assert_eq!(base(&[("ImageMask", Object::Bool(true))], vec![0; 8]), Err(NotDecoded::StencilMask));
+        assert_eq!(base(&[("Decode", Object::Array(vec![Object::Int(1), Object::Int(0)]))], vec![0; 16]), Err(NotDecoded::Decode));
+        // Too short, a huge size, a broken JPEG, no size at all.
+        assert_eq!(base(&[], vec![0; 5]), Err(NotDecoded::Corrupt));
+        assert_eq!(base(&[("Width", Object::Int(1 << 30)), ("Height", Object::Int(1 << 30))], vec![0; 16]), Err(NotDecoded::TooLarge));
+        assert_eq!(base(&[("Filter", Object::name("DCTDecode"))], vec![0xFF, 0xD8, 1, 2, 3]), Err(NotDecoded::Corrupt));
+        assert_eq!(base(&[("Width", Object::Int(-3))], vec![0; 16]), Err(NotDecoded::Corrupt));
+        // Samples that don't fit the image are refused when written back.
+        let s = image(&[("Width", Object::Int(4)), ("Height", Object::Int(4))], vec![0; 16]);
+        let wrong = Samples { width: 4, height: 4, components: 1, data: vec![0; 15], jpeg: false, bilevel: false, inverted: false };
+        assert!(encode_samples(&s, &wrong, 90).is_none());
+    }
+}
diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
index 8925a0dca1..1fd46a956f 100644
--- a/crates/ui-egui/src/app.rs
+++ b/crates/ui-egui/src/app.rs
@@ -179,6 +179,8 @@ impl PdfCraftApp {
             stamp_draft: Default::default(),
             optimize_draft: OptimizeDraft::default(),
             optimize_run: None,
+            scan_clean_draft: scan_clean_ui::ScanCleanDraft::default(),
+            scan_clean_run: None,
             progress_notice: None,
             page_clipboard: None,
             grid_drop: None,
@@ -508,6 +510,7 @@ impl eframe::App for PdfCraftApp {
         self.auto_ocr_scanned_page();
         self.poll_ocr();
         self.poll_optimize();
+        self.poll_scan_clean();
         self.poll_action();
         self.process_file_requests();
         #[cfg(not(target_arch = "wasm32"))]
diff --git a/crates/ui-egui/src/app/control.rs b/crates/ui-egui/src/app/control.rs
index bb5a65cb34..3fe737b40b 100644
--- a/crates/ui-egui/src/app/control.rs
+++ b/crates/ui-egui/src/app/control.rs
@@ -101,6 +101,7 @@ impl PdfCraftApp {
                     "export-all-images" => Some(Dialog::Export(export_ui::ExportKind::AllImages)),
                     "accessibility-options" => Some(Dialog::AccessibilityOptions),
                     "recognize-text" => Some(Dialog::RecognizeText),
+                    "enhance-scan" => Some(Dialog::EnhanceScan),
                     "js-console" => Some(Dialog::JsConsole),
                     "document-js" => Some(Dialog::DocumentJs),
                     "preferences" => Some(Dialog::Preferences),
diff --git a/crates/ui-egui/src/app/frame.rs b/crates/ui-egui/src/app/frame.rs
index e0a8370c60..3d6f493e10 100644
--- a/crates/ui-egui/src/app/frame.rs
+++ b/crates/ui-egui/src/app/frame.rs
@@ -5,6 +5,7 @@ impl PdfCraftApp {
     pub(super) fn show_progress(&mut self, ctx: &egui::Context) {
         if widgets::progress_notice(self, ctx) {
             self.cancel_optimize();
+            self.cancel_scan_clean();
         }
     }
 
diff --git a/crates/ui-egui/src/commands.rs b/crates/ui-egui/src/commands.rs
index acccbcc55a..dec99e8b58 100644
--- a/crates/ui-egui/src/commands.rs
+++ b/crates/ui-egui/src/commands.rs
@@ -500,6 +500,7 @@ impl PdfCraftApp {
             "export.image" => self.dialog = Some(Dialog::Export(crate::export_ui::ExportKind::Image)),
             "export.text" => self.dialog = Some(Dialog::Export(crate::export_ui::ExportKind::Text)),
             "ocr.recognize" => self.dialog = Some(Dialog::RecognizeText),
+            "ocr.enhance" => self.dialog = Some(Dialog::EnhanceScan),
             "ocr.recognize_batch" => self.ocr_files_dialog(),
             "edit.edit_text" => {
                 self.quick_tool = crate::QuickTool::EditText;
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index c21604a4da..a77b0e4d19 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -56,6 +56,7 @@ struct Pending {
     open_revision: Option<usize>,
     a11y_now: bool,
     ocr_now: bool,
+    scan_clean_now: bool,
     compare_now: bool,
     images_now: bool,
     stamp_now: bool,
@@ -372,6 +373,12 @@ fn dialog_body(ui: &mut egui::Ui, app: &mut PdfCraftApp, dialog: Dialog, req: &m
             req.close = go || cancel;
             return false;
         }
+        Dialog::EnhanceScan => {
+            let (go, cancel) = crate::scan_clean_ui::body(ui, app, &t);
+            req.scan_clean_now = go;
+            req.close = go || cancel;
+            return false;
+        }
         Dialog::AccessibilityOptions => {
             let (start, cancel) = crate::a11y_ui::options_body(ui, app, &t);
             req.a11y_now = start;
@@ -1818,6 +1825,9 @@ fn finish_close(app: &mut PdfCraftApp, dialog: Dialog, modal_closed: bool, req:
     if req.ocr_now {
         app.start_ocr();
     }
+    if req.scan_clean_now {
+        app.start_scan_clean();
+    }
     if req.compare_now {
         app.run_compare();
     }
diff --git a/crates/ui-egui/src/i18n/de.tsv b/crates/ui-egui/src/i18n/de.tsv
index 8586a21d43..076fb6bf66 100644
--- a/crates/ui-egui/src/i18n/de.tsv
+++ b/crates/ui-egui/src/i18n/de.tsv
@@ -2558,3 +2558,22 @@ animation effects	Off	Aus
 	Rotate the selected pages clockwise	Ausgewählte Seiten im Uhrzeigersinn drehen
 	Extract the selected pages…	Ausgewählte Seiten extrahieren…
 	Delete the selected pages	Ausgewählte Seiten löschen
+	Enhance scanned file…	Gescannte Datei verbessern…
+	Enhance Scanned File	Gescannte Datei verbessern
+	Cleans up the scanned pictures in place: recognized text, comments and links on the pages stay as they are.	Bereinigt die gescannten Bilder an Ort und Stelle: erkannter Text, Kommentare und Links auf den Seiten bleiben erhalten.
+	Filters	Filter
+	Background removal	Hintergrund entfernen
+	Evens out the paper so a grey or yellowed background turns white, and darkens faint strokes. 0 is off.	Gleicht das Papier aus, sodass ein grauer oder vergilbter Hintergrund weiß wird, und dunkelt blasse Striche nach. 0 ist aus.
+	Edge shadow removal	Randschatten entfernen
+	Lightens shadows along the edges of the scan, such as a book's gutter or a copier's dark border	Hellt Schatten an den Rändern des Scans auf, etwa den Bundsteg eines Buchs oder den dunklen Rand eines Kopierers
+	Despeckle	Flecken entfernen
+	Removes isolated dark specks such as dust and scanner noise. The only filter black and white scans take.	Entfernt einzelne dunkle Flecken wie Staub und Scannerrauschen. Der einzige Filter für Schwarzweiß-Scans.
+	Enhance	Verbessern
+	No scanned pages were cleaned up.	Es wurden keine gescannten Seiten bereinigt.
+	Scanned pages are already being enhanced	Gescannte Seiten werden bereits verbessert
+	Couldn't enhance the scanned pages	Die gescannten Seiten konnten nicht verbessert werden
+	Enhancing scans… image {d} of {t}	Scans werden verbessert… Bild {d} von {t}
+	Enhancing the scanned pages was cancelled	Das Verbessern der gescannten Seiten wurde abgebrochen
+@plural	Cleaned up the scan on {n} page.|Cleaned up the scans on {n} pages.	Scan auf {n} Seite bereinigt.|Scans auf {n} Seiten bereinigt.
+@plural	{n} page is not a scan.|{n} pages are not scans.	{n} Seite ist kein Scan.|{n} Seiten sind keine Scans.
+@plural	{n} image was left as it was (page {p}: {why}).|{n} images were left as they were (page {p}: {why}, …).	{n} Bild blieb unverändert (Seite {p}: {why}).|{n} Bilder blieben unverändert (Seite {p}: {why}, …).
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 65bc7e4b1b..e61e3827a5 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -162,6 +162,7 @@ use workflows::js_ui;
 use workflows::ocr_ui;
 use workflows::optimize_ui;
 use workflows::print_ui;
+use workflows::scan_clean_ui;
 use workflows::web_print;
 
 /// Files dropped on a document's page grid or its Pages panel.
@@ -494,6 +495,9 @@ pub struct PdfCraftApp {
     pub optimize_draft: OptimizeDraft,
     /// The running optimization (Optimize PDF ▸ Advanced optimization).
     pub optimize_run: Option<optimize_ui::OptimizeRun>,
+    /// Scan & OCR ▸ Enhance scanned file: the dialog's choices and the running clean-up.
+    pub scan_clean_draft: scan_clean_ui::ScanCleanDraft,
+    pub scan_clean_run: Option<scan_clean_ui::ScanCleanRun>,
     /// A background job's progress card (see [`widgets::progress_notice`]).
     pub progress_notice: Option<widgets::ProgressNotice>,
     /// Pages copied or cut in Organize Pages, ready to paste (into any document).
diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs
index dd3b3e90aa..72d3b6ddf2 100644
--- a/crates/ui-egui/src/state.rs
+++ b/crates/ui-egui/src/state.rs
@@ -162,6 +162,8 @@ pub enum Dialog {
     AccessibilityOptions,
     /// Scan & OCR ▸ Recognize text.
     RecognizeText,
+    /// Scan & OCR ▸ Enhance scanned file.
+    EnhanceScan,
     /// The JavaScript console (⌘J).
     JsConsole,
     /// Document JavaScripts.
diff --git a/crates/ui-egui/src/workflows.rs b/crates/ui-egui/src/workflows.rs
index 63686a70cc..9314914ec4 100644
--- a/crates/ui-egui/src/workflows.rs
+++ b/crates/ui-egui/src/workflows.rs
@@ -11,4 +11,5 @@ pub(super) mod js_ui;
 pub(super) mod ocr_ui;
 pub(super) mod optimize_ui;
 pub(super) mod print_ui;
+pub(super) mod scan_clean_ui;
 pub(super) mod web_print;
diff --git a/crates/ui-egui/src/workflows/scan_clean_ui.rs b/crates/ui-egui/src/workflows/scan_clean_ui.rs
new file mode 100644
index 0000000000..a275b5af20
--- /dev/null
+++ b/crates/ui-egui/src/workflows/scan_clean_ui.rs
@@ -0,0 +1,253 @@
+//! Scan & OCR ▸ Enhance scanned file: the dialog (pages, background removal level, edge
+//! shadows, despeckle) and the background run with its progress card. The scans are cleaned
+//! on a worker thread ([`pdfcraft_engine::scan_clean`]); the result is applied as one undoable
+//! step when it is done, unless the document changed meanwhile.
+
+use std::sync::{Arc, Mutex};
+
+use egui::{Align, Layout};
+use pdfcraft_engine::scan_clean::{ScanCleanReport, ScanCleanSettings, ScanCleaned};
+use pdfcraft_engine::{DocId, EditError};
+
+use crate::ocr_ui::OcrPages;
+use crate::theme::{self, Tokens};
+use crate::{PdfCraftApp, widgets};
+
+/// The dialog's choices (kept between runs).
+#[derive(Clone, Debug, PartialEq)]
+pub struct ScanCleanDraft {
+    pub pages: OcrPages,
+    pub from: usize,
+    pub to: usize,
+    pub settings: ScanCleanSettings,
+}
+
+impl Default for ScanCleanDraft {
+    fn default() -> Self {
+        ScanCleanDraft { pages: OcrPages::All, from: 1, to: 1, settings: ScanCleanSettings::default() }
+    }
+}
+
+/// Progress of a run: images done, total, the result once finished, and a cancel request.
+#[derive(Default)]
+pub struct ScanCleanProgress {
+    pub done: usize,
+    pub total: usize,
+    pub result: Option<Result<ScanCleaned, EditError>>,
+    pub cancel: bool,
+}
+
+pub struct ScanCleanRun {
+    pub doc: DocId,
+    pub progress: Arc<Mutex<ScanCleanProgress>>,
+}
+
+pub(crate) fn body(ui: &mut egui::Ui, app: &mut PdfCraftApp, t: &Tokens) -> (bool, bool) {
+    let pages = app.active_ids().and_then(|(_, id)| app.session.get(id)).map_or(1, |d| d.info.pages.len().max(1));
+    let d = &mut app.scan_clean_draft;
+    d.to = d.to.clamp(1, pages);
+    d.from = d.from.clamp(1, d.to);
+    ui.label(egui::RichText::new(tl!("Enhance Scanned File")).font(theme::semibold(18.0)));
+    ui.add_space(4.0);
+    ui.label(
+        egui::RichText::new(tl!("Cleans up the scanned pictures in place: recognized text, comments and links on the pages stay as they are."))
+            .small()
+            .color(t.text_muted),
+    );
+    ui.add_space(8.0);
+    let group = |ui: &mut egui::Ui, title: &str, body: &mut dyn FnMut(&mut egui::Ui)| {
+        ui.label(egui::RichText::new(tl!(title)).font(theme::semibold(13.0)));
+        egui::Frame::new().fill(t.hover).corner_radius(egui::CornerRadius::same(6)).inner_margin(egui::Margin::same(10)).show(ui, |ui| {
+            ui.set_width(ui.available_width());
+            body(ui);
+        });
+        ui.add_space(8.0);
+    };
+    group(ui, "Pages", &mut |ui| {
+        widgets::radio_value(ui, &mut d.pages, OcrPages::All, tl!("All pages"));
+        widgets::radio_value(ui, &mut d.pages, OcrPages::Current, tl!("Current page"));
+        ui.horizontal(|ui| {
+            let from = widgets::radio_value(ui, &mut d.pages, OcrPages::Range, tl!("From"));
+            let on = d.pages == OcrPages::Range;
+            ui.add_enabled(on, egui::DragValue::new(&mut d.from).range(1..=pages)).labelled_by(from.id);
+            let to = ui.label(tl!("to"));
+            ui.add_enabled(on, egui::DragValue::new(&mut d.to).range(1..=pages)).labelled_by(to.id);
+        });
+    });
+    group(ui, "Filters", &mut |ui| {
+        ui.horizontal(|ui| {
+            let label = ui.label(tl!("Background removal"));
+            ui.spacing_mut().slider_width = 220.0;
+            ui.add(egui::Slider::new(&mut d.settings.level, 0..=pdfcraft_engine::camera_clean::MAX_LEVEL).trailing_fill(true))
+                .labelled_by(label.id)
+                .on_hover_text(tl!("Evens out the paper so a grey or yellowed background turns white, and darkens faint strokes. 0 is off."));
+        });
+        ui.add(widgets::checkbox(&mut d.settings.edge_shadows, tl!("Edge shadow removal")))
+            .on_hover_text(tl!("Lightens shadows along the edges of the scan, such as a book's gutter or a copier's dark border"));
+        ui.add(widgets::checkbox(&mut d.settings.despeckle, tl!("Despeckle")))
+            .on_hover_text(tl!("Removes isolated dark specks such as dust and scanner noise. The only filter black and white scans take."));
+    });
+    ui.add_space(6.0);
+    let (mut go, mut cancel) = (false, false);
+    ui.horizontal(|ui| {
+        ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
+            let ready = d.settings.changes_something();
+            if ui.add_enabled_ui(ready, |ui| widgets::pill_button(ui, tl!("Enhance"), true)).inner.clicked() {
+                go = true;
+            }
+            if widgets::pill_button(ui, tl!("Cancel"), false).clicked() {
+                cancel = true;
+            }
+        })
+    });
+    (go, cancel)
+}
+
+/// What a finished run says: what was cleaned, what was not a scan, and what was left and why.
+fn summary(r: &ScanCleanReport) -> String {
+    let lang = crate::i18n::current();
+    let mut out = if r.pages.is_empty() {
+        tl!("No scanned pages were cleaned up.").to_string()
+    } else {
+        crate::i18n::trn(lang, r.pages.len() as u64, "Cleaned up the scan on {n} page.", "Cleaned up the scans on {n} pages.")
+    };
+    if !r.not_scanned.is_empty() {
+        out.push(' ');
+        out.push_str(&crate::i18n::trn(lang, r.not_scanned.len() as u64, "{n} page is not a scan.", "{n} pages are not scans."));
+    }
+    if let Some(first) = r.skipped.first() {
+        out.push(' ');
+        let page = first.pages.first().map_or_else(String::new, |p| (p + 1).to_string());
+        // The reason is the engine's own sentence, in English.
+        out.push_str(&crate::i18n::fmt(
+            &crate::i18n::trn(
+                lang,
+                r.skipped.len() as u64,
+                "{n} image was left as it was (page {p}: {why}).",
+                "{n} images were left as they were (page {p}: {why}, …).",
+            ),
+            &[("p", &page), ("why", &first.reason)],
+        ));
+    }
+    out
+}
+
+impl PdfCraftApp {
+    /// Clean up the scans on the pages chosen in the dialog, in the background.
+    pub fn start_scan_clean(&mut self) {
+        let Some((vi, id)) = self.active_ids() else { return };
+        if self.scan_clean_run.is_some() {
+            self.notify_tr("Scanned pages are already being enhanced");
+            return;
+        }
+        // What's typed in a form field is part of the document (#166).
+        if !self.commit_form_typing() {
+            return;
+        }
+        let d = &self.scan_clean_draft;
+        let pages: Vec<usize> = match d.pages {
+            OcrPages::All => Vec::new(),
+            OcrPages::Current => self.views.get(vi).map(|v| vec![v.current]).unwrap_or_default(),
+            OcrPages::Range => (d.from.saturating_sub(1)..d.to).collect(),
+        };
+        let job = match self.session.scan_clean_job(id, &pages, d.settings) {
+            Ok(job) => job,
+            Err(e) => return self.notify(e.to_string()),
+        };
+        let progress = Arc::new(Mutex::new(ScanCleanProgress { total: job.total(), ..Default::default() }));
+        let p = progress.clone();
+        let work = move || {
+            let result = job.run(|done, total| {
+                let Ok(mut s) = p.lock() else { return false };
+                s.done = done;
+                s.total = total;
+                !s.cancel
+            });
+            if let Ok(mut s) = p.lock() {
+                s.result = Some(result);
+            }
+        };
+        #[cfg(not(target_arch = "wasm32"))]
+        if self.run_inline {
+            work();
+        } else if let Err(e) = std::thread::Builder::new().name("pdfcraft-scan-clean".into()).spawn(work) {
+            // No worker: report the failure instead of waiting for a result that never comes.
+            if let Ok(mut s) = progress.lock() {
+                s.result = Some(Err(EditError::Invalid(e.to_string())));
+            }
+        }
+        #[cfg(target_arch = "wasm32")]
+        work();
+        self.scan_clean_run = Some(ScanCleanRun { doc: id, progress });
+        self.poll_scan_clean();
+    }
+
+    /// Stop a running clean-up (nothing changes).
+    pub fn cancel_scan_clean(&mut self) {
+        if let Some(r) = &self.scan_clean_run
+            && let Ok(mut s) = r.progress.lock()
+        {
+            s.cancel = true;
+        }
+    }
+
+    /// Show progress; apply the result once the worker is done.
+    pub(crate) fn poll_scan_clean(&mut self) {
+        let Some(run) = self.scan_clean_run.as_ref() else { return };
+        let (doc, progress) = (run.doc, run.progress.clone());
+        let Ok(mut s) = progress.lock() else {
+            // The worker panicked while holding the lock: it will never report back.
+            self.scan_clean_run = None;
+            self.progress_notice = None;
+            self.notify_tr("Couldn't enhance the scanned pages");
+            return;
+        };
+        let Some(result) = s.result.take() else {
+            let (cancelling, done, total) = (s.cancel, s.done, s.total);
+            drop(s);
+            let label = if cancelling {
+                tl!("Cancelling…").to_string()
+            } else {
+                crate::i18n::fmt(
+                    tl!("Enhancing scans… image {d} of {t}"),
+                    &[("d", &(done + 1).min(total.max(1)).to_string()), ("t", &total.max(1).to_string())],
+                )
+            };
+            let fraction = if total == 0 { 1.0 } else { done.min(total) as f32 / total as f32 };
+            self.progress_notice = Some(crate::widgets::ProgressNotice { label, fraction, cancellable: !cancelling });
+            if let Some(ctx) = &self.ctx {
+                ctx.request_repaint_after(std::time::Duration::from_millis(50));
+            }
+            return;
+        };
+        drop(s);
+        self.scan_clean_run = None;
+        self.progress_notice = None;
+        match result.and_then(|cleaned| self.session.apply_scan_clean(doc, cleaned)) {
+            Ok(report) => {
+                let msg = summary(&report);
+                self.notify(msg);
+            }
+            Err(EditError::Cancelled) => self.notify_tr("Enhancing the scanned pages was cancelled"),
+            Err(e) => self.notify(e.to_string()),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pdfcraft_engine::scan_clean::SkippedImage;
+
+    #[test]
+    fn the_summary_says_what_was_done_and_what_was_left() {
+        let r = ScanCleanReport {
+            pages: vec![0, 2],
+            images: 1,
+            not_scanned: vec![1],
+            skipped: vec![SkippedImage { pages: vec![3], name: "Im0".into(), reason: "it is CMYK".into() }],
+        };
+        assert_eq!(summary(&r), "Cleaned up the scans on 2 pages. 1 page is not a scan. 1 image was left as it was (page 4: it is CMYK).");
+        assert_eq!(summary(&ScanCleanReport::default()), "No scanned pages were cleaned up.");
+    }
+}
diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs
index a5c3192358..2df736c14c 100644
--- a/crates/ui-egui/tests/it/main.rs
+++ b/crates/ui-egui/tests/it/main.rs
@@ -68,6 +68,7 @@ mod reading_colors;
 mod recovery;
 mod redact;
 mod reload;
+mod scan_clean;
 mod side_panels;
 mod signing;
 mod stamps;
diff --git a/crates/ui-egui/tests/it/scan_clean.rs b/crates/ui-egui/tests/it/scan_clean.rs
new file mode 100644
index 0000000000..afb4a4f75c
--- /dev/null
+++ b/crates/ui-egui/tests/it/scan_clean.rs
@@ -0,0 +1,77 @@
+//! Scan & OCR ▸ Enhance scanned file in the real shell (egui_kittest): the dialog, the run and
+//! its report, and that the page keeps its comment while its scan is cleaned in place.
+
+use egui_kittest::Harness;
+use egui_kittest::kittest::Queryable;
+use pdfcraft_engine::{Edit, NewAnnotation, NoteIcon, Session, Shape, Style};
+use pdfcraft_ui_egui::PdfCraftApp;
+
+/// A two-page PDF: page 1 a grey scan with a darker gutter and text bars (and a sticky note),
+/// page 2 the same scan again.
+fn scan() -> Vec<u8> {
+    let img = image::GrayImage::from_fn(300, 400, |x, y| {
+        let light = 0.55 + 0.45 * (x as f32 / 60.0).min(1.0);
+        let ink = if (60..360).contains(&y) && (y - 60) % 40 < 6 && (60..240).contains(&x) { 0.12 } else { 0.78 };
+        image::Luma([(ink * light * 255.0) as u8])
+    });
+    let mut png = Vec::new();
+    img.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let mut s = Session::new();
+    let bytes = s.create_from_images(&[("a.png".into(), png.clone()), ("b.png".into(), png)]).unwrap();
+    let id = s.open("scan.pdf", None, bytes, None).unwrap();
+    let shape = Shape::Note { at: [20.0, 20.0], icon: NoteIcon::Comment };
+    let note = NewAnnotation { page: 0, style: Style::default_for(&shape), shape, contents: "Keep me".into(), author: "Tester".into() };
+    s.apply(id, Edit::AddAnnotation(note)).unwrap();
+    s.save_bytes(id).unwrap().to_vec()
+}
+
+fn harness() -> Harness<'static, PdfCraftApp> {
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).build_eframe(|_cc| {
+        let mut app = PdfCraftApp::new();
+        app.set_option("language", "en").unwrap();
+        app.open_bytes("scan.pdf", None, scan()).unwrap();
+        app.run_inline = true;
+        app
+    });
+    h.run_steps(4);
+    h
+}
+
+#[test]
+fn enhance_scanned_file_cleans_the_chosen_pages_and_says_what_it_did() {
+    let mut h = harness();
+    let id = h.state().active_ids().unwrap().1;
+    assert!(h.state().session.get(id).unwrap().comment_props(0, 0).is_some());
+    assert!(h.state_mut().execute("ocr.enhance"));
+    h.run_steps(2);
+    assert_eq!(h.query_all_by_label("Background removal").count(), 2, "the label and the slider it names");
+    h.get_by_label("Edge shadow removal");
+    h.get_by_label("Despeckle");
+    h.get_by_role_and_label(egui::accesskit::Role::RadioButton, "Current page").click();
+    h.run_steps(1);
+    h.get_by_label("Enhance").click();
+    h.run_steps(3);
+    let app = h.state();
+    assert!(app.scan_clean_run.is_none() && app.dialog.is_none(), "finished and closed");
+    let toast = app.toast.clone().unwrap().0;
+    assert_eq!(toast, "Cleaned up the scan on 1 page.");
+    let doc = app.session.get(id).unwrap();
+    assert_eq!(doc.can_undo(), Some("Enhance scanned file"));
+    assert_eq!(doc.info.pages.len(), 2);
+    assert_eq!(doc.comment_props(0, 0).map(|p| p.author), Some("Tester".to_string()), "the sticky note stays");
+}
+
+#[test]
+fn nothing_to_enhance_is_said_not_done() {
+    let mut h = harness();
+    let id = h.state().active_ids().unwrap().1;
+    h.state_mut().scan_clean_draft.settings = pdfcraft_engine::scan_clean::ScanCleanSettings { level: 0, edge_shadows: false, despeckle: false };
+    assert!(h.state_mut().execute("ocr.enhance"));
+    h.run_steps(2);
+    // With every filter off the button is disabled; starting anyway changes nothing.
+    h.state_mut().start_scan_clean();
+    h.run_steps(2);
+    let app = h.state();
+    assert!(app.toast.clone().unwrap().0.starts_with("No scanned pages were cleaned up."), "{:?}", app.toast);
+    assert_eq!(app.session.get(id).unwrap().can_undo(), None);
+}
diff --git a/docs/gaps.md b/docs/gaps.md
index 56ec3ae748..ab6f083ab1 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,5 +1,6 @@
 # Where PdfCraft falls short of Acrobat Pro
 
+> **Last reviewed:** 2026-10-28 | **Last updated:** 2026-10-28 | **Change:** minor (M10, #4119 partial: Enhance scanned file cleans scanned pages in place: background removal, edge shadow removal, despeckle; estimates unchanged)
 > **Last reviewed:** 2026-10-25 · **Last updated:** 2026-10-25 · **Change:** minor (gaps 5 and 14 current state: native release Hans face via LXGW WenKai Lite; Arabic logical catalog, explicit RTL direction and mirrored stock chrome, with native/browser/IME workflows unqualified; no readiness re-estimate)
 
 > **Last reviewed:** 2026-10-15 · **Last updated:** 2026-10-19 · **Change:** minor (gap 2: composite fonts with `/ToUnicode /Identity-H` read as Unicode, hayro-interpret patch 44; estimates unchanged) · **Target:** Adobe Acrobat Pro (Acrobat DC, continuous track 26.002.21931, macOS)
@@ -164,7 +165,9 @@ update the numbers.
 ### 7. OCR reads only unaccented Latin
 
 - **Missing:** every other script and accented Latin; editable-text output; deskew, rotation,
-  despeckle, background and camera clean-up; MRC compression; pluggable engines; OCR in the
+  despeckle and background clean-up as options of Recognize text (Enhance scanned file does them
+  on grey, RGB and 1-bit scans, not CMYK, indexed, JBIG2 or CCITT ones); MRC compression;
+  pluggable engines; OCR in the
   browser; scanner input.
 - **Evidence:** `ocr.ocr-languages` partial ("the models read only the Latin alphabet without
   accents"); 19 of 26 OCR features planned; [#744](https://github.com/storytold/pdfcraft/issues/744)
diff --git a/docs/roadmap.md b/docs/roadmap.md
index 25205e92c1..6d910fc795 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -1,5 +1,6 @@
 # PdfCraft roadmap: milestones and what's next
 
+> **Last reviewed:** 2026-10-28 | **Last updated:** 2026-10-28 | **Change:** minor (M10, #4119 partial: Enhance scanned file cleans scanned pages in place: background removal, edge shadow removal, despeckle; estimates unchanged)
 > **Last reviewed:** 2026-10-27 | **Last updated:** 2026-10-27 | **Change:** minor (M10: OCR model downloads use verified ONNX pairs with legacy discovery fallback; estimates unchanged)
 > **Last reviewed:** 2026-10-25 | **Last updated:** 2026-10-25 | **Change:** minor (M14 localization current state: Arabic logical catalog, explicit RTL label direction and mirrored stock chrome; native/browser RTL workflows unqualified. Native release Hans face via LXGW WenKai Lite; estimates unchanged)
 > **Last reviewed:** 2026-10-23 · **Last updated:** 2026-10-23 · **Change:** minor (M7, #2636 partial: pasting added text boxes and images in the engine and through `content_copy`; estimates unchanged)
@@ -194,7 +195,7 @@ total matches the parity estimate.
 | M7 | Content editing (text, images, header/footer, watermark) | 250–500 | 20% | 100–180 | Done: header & footer, watermarks, backgrounds, Bates; added text and images that stay editable (move, resize, format, rotate, flip, crop, replace); links (Link tool, Link Properties, create from URLs, remove all). Missing: editing existing text and images in place (the longest pole), image/PDF watermarks |
 | M8 | Security + redaction | 100–180 | 68% | 15–30 | Done: opening protected documents, permissions, Protect Using Password, Remove security; redaction (mark text/areas/pages, Search & Redact with patterns, apply removing glyphs, image pixels, vectors, XObject content, annotations and fields, verification, full rewrite on save); Remove hidden information and Sanitize.<br>Done since: redaction codes (U.S. FOIA and Privacy Act sets as overlay text, in Redaction properties and `redact_mark`). Redaction cleans indirect and form structure references, preserving surviving form tags. Redaction retires inherited resource dictionaries, so a parent `/Pages` can't keep a removed XObject reachable; unredacted pages are left untouched. Image redaction removes alternate images and unsupported masks only on affected images. Changed marked-content spans lose replacement descriptions; untouched spans keep theirs. Hidden-text cleanup retires unused named descriptions across inherited/shared page and form resources (64 focused tests and scoped Rust 1.96 Clippy/wasm checks pass; publication CI pending). The redaction audit counts a filled cover that hides half of any one word of a long line (#2662), applied or not. Phone-pattern redaction also matches labelled Italian geographic numbers with `+39` and a slash after the area code (#3205 follow-up); unlabelled international slash numbers remain unsupported. Missing: certificate security, custom redaction code sets and pattern locales, DCT re-encoding |
 | M9 | Signatures (PAdES, validation) | 160–280 | 60% | 40–70 | Done: new `sign` crate (DER, X.509, CMS, PKCS #12 on RustCrypto; aws-lc-rs for RSA private keys); PAdES B-B signing (visible, invisible, existing fields, certification with DocMDP); validation with trust store and changes-after-signing classification; self-signed digital IDs; Signatures panel, message bar, sign dialogs; agent tools. Checked with pdfsig and OpenSSL.<br>Done since: macOS Keychain and Windows Current User Personal store signing (software-backed CNG keys), certificate viewer, signed documents protected from rewrites, page validation overlays separate from original signature artwork (baked Not Verified captions remain; #79 open), snapshot tabs that reuse instead of multiplying. Missing: timestamps (B-T), LTV (DSS, OCSP, CRL), FieldMDP, smart cards, PKCS #11 |
-| M10 | OCR, create, export, print | 200–350 | 33% | 120–215 | Done: create from blank/text/PNG/JPEG/TIFF (multi-page)/GIF/BMP; export PNG/JPEG/TIFF and text; Print (Acrobat's sizing, n-up, booklet, poster, comments & forms, preview, the CUPS and Windows spoolers, print-ready PDF).<br>Done since: embedded/72/custom DPI choices for image imports; export all images; OCR (searchable image for pages, ranges and multiple files); single-sided cut-and-stack imposition with cut marks, through Print and doc_print; architectural/ANSI/large ISO sheet presets, Match page at 100% and PDF-scale preview (#599 follow-up); Create PDF from multiple files (PDFs, images and text, edited as pages in the grid); OCR can also read pictures on pages that have text, without adding that text twice (#1028). Model staging fetches SHA-256-verified ONNX detection/recognition files after the upstream RTEN URL brownout; runtime discovery prefers complete ONNX pairs per directory, then complete legacy RTEN pairs, without mixing formats or changing directory precedence. Done since: Word invoice export uses borderless inferred tables, floating positioned text/artwork only where text overlaps an image or is rotated, and per-page sizes, covered by synthetic invoice automation regressions (#773); printing on the web through the browser's print dialog, sheets drawn by PdfCraft (gap 4). Lossless image export applies per-component Decode, including Indexed mapping (#1201 partial). Existing 16-bit precision and color-management limits remain. #3532 partial: vector printing retains existing appearances with absent Subtype through a print-owned Form copy; source artwork stays unchanged. #3120: Office export reads form XObjects 50 levels deep, as the renderer does, and up to 50 000 a page; pages past that are listed in `truncated_pages`. Word table cells use the grid columns they span, including cells after a merged cell. Done since: text in a table slot covered by another cell's span remains as paragraph text in Word, HTML, RTF and PowerPoint. Missing: OCR languages beyond Latin, editable-text OCR output, full Office layout fidelity/import. Done since: dotted-leader contents entries stay in separate complete paragraphs (#1757) #2156 candidate: last selected print paper persists across sessions; other print preferences unchanged. Image export applies soft-mask Decode opacity intervals before resizing, including indirect entries and inverted ranges. Vector printing gives annotation appearances unoccupied XObject names so existing page artwork survives. |
+| M10 | OCR, create, export, print | 200–350 | 33% | 120–215 | Done: create from blank/text/PNG/JPEG/TIFF (multi-page)/GIF/BMP; export PNG/JPEG/TIFF and text; Print (Acrobat's sizing, n-up, booklet, poster, comments & forms, preview, the CUPS and Windows spoolers, print-ready PDF).<br>Done since: embedded/72/custom DPI choices for image imports; export all images; OCR (searchable image for pages, ranges and multiple files); single-sided cut-and-stack imposition with cut marks, through Print and doc_print; architectural/ANSI/large ISO sheet presets, Match page at 100% and PDF-scale preview (#599 follow-up); Create PDF from multiple files (PDFs, images and text, edited as pages in the grid); OCR can also read pictures on pages that have text, without adding that text twice (#1028). Model staging fetches SHA-256-verified ONNX detection/recognition files after the upstream RTEN URL brownout; runtime discovery prefers complete ONNX pairs per directory, then complete legacy RTEN pairs, without mixing formats or changing directory precedence. Done since: Word invoice export uses borderless inferred tables, floating positioned text/artwork only where text overlaps an image or is rotated, and per-page sizes, covered by synthetic invoice automation regressions (#773); printing on the web through the browser's print dialog, sheets drawn by PdfCraft (gap 4). Lossless image export applies per-component Decode, including Indexed mapping (#1201 partial). Existing 16-bit precision and color-management limits remain. #3532 partial: vector printing retains existing appearances with absent Subtype through a print-owned Form copy; source artwork stays unchanged. #3120: Office export reads form XObjects 50 levels deep, as the renderer does, and up to 50 000 a page; pages past that are listed in `truncated_pages`. Word table cells use the grid columns they span, including cells after a merged cell. Done since: text in a table slot covered by another cell's span remains as paragraph text in Word, HTML, RTF and PowerPoint. Missing: OCR languages beyond Latin, editable-text OCR output, full Office layout fidelity/import. Done since: dotted-leader contents entries stay in separate complete paragraphs (#1757) #2156 candidate: last selected print paper persists across sessions; other print preferences unchanged. Image export applies soft-mask Decode opacity intervals before resizing, including indirect entries and inverted ranges. Vector printing gives annotation appearances unoccupied XObject names so existing page artwork survives. Done since: Enhance scanned file cleans scanned pages in place (background removal, edge shadow removal, despeckle; the OCR text layer and comments stay; #4119 partial). |
 | M11 | Optimize, preflight, PDF/A/X/UA, print production | 200–350 | 18% | 80–140 | Done: new `optimize` crate: Reduce File Size and the PDF Optimizer (images measured where drawn, bicubic downsampling, JPEG/ZIP recompression only when smaller, discard objects and user data, Flate clean-up, resource merging, object streams). Target-version compatibility is partial: newer content is not detected or converted. Content stream boundaries preserve comments, split operands and graphics state when image fragments merge. Image downsampling includes page-local `/UserUnit` scaling when measuring physical resolution. Done since: reject invalid image and soft-mask dimensions with checked sizing (#2178). Missing: fonts and transparency panels, space audit, preflight, PDF/A/X/UA |
 | M12 | Accessibility, compare, measure, search, XFA | 200–380 | 30% | 90–160 | Done: new `a11y` crate with the Accessibility Checker (all 32 rules, report, Fix/Skip/Explain, options dialog and results panel, agent tools). Locatable figure, annotation and form findings highlight their page bounds. Character encoding accepts Identity-H/V with Adobe CJK collections and predefined CJK CMaps independently (#3673); per-glyph validation and embedded-font extraction remain separate.<br>Done since: 2D distance, perimeter and area measurements with persistent viewport calibration, snapping, live information and CSV export; a bounded, text-only auto-tag proposal tool for one page. Marking a figure decorative rewrites only that stream (#1324). An XFA radio item whose value contains a space is written back unchanged (#1319). Done since: #2569: Growable multiline XFA text reflows after edits, with undo/redo, save/reopen and print coverage; oversized fields still become read-only page text. Structured-data synchronization warnings retain accepted whitespace without relayout from stale data. Done since: #2572: Every repeated page-master button resolves its own field to the shared XFA click script, including print buttons. Done since: #2570: Dynamic XFA rich-text fields carry exData/maxLength into AcroForm MaxLen for reported and enforced Unicode character limits, retained after save/reopen. Done since: #2589: Active XFA skips PDF-container fallback scripts while retaining requested messages and saved scripts; ordinary/static/unlaid-out documents and explicit console/field calls keep their existing behavior. Missing: writing proposed tags and parent tree, field autotag, visual Tags/Order/Content panels, Reading Order tool, compare, geospatial/3D measurement, search index, XFA<br>Reading colours: pending page backgrounds follow the configured colour (#2059). |
 | M13 | Automation (MCP, Action Wizard, CLI) + AI providers | 60–120 | 45% | 25–45 | Done: MCP resources (document info, text, page images); headless tool table (123 tools incl. signing, optimizing, initial view, links, stamps, data exchange, comment review, forms authoring and scripts, redaction, sanitize, print, add content), opt-in MCP server over stdio, CLI `run`/`tools` (closed stdout pipes exit cleanly), UI control channel with drag. Missing: Action Wizard, AI providers<br>Done since: CLI run and MCP reject missing, empty, repeated and option-valued --root arguments before any tool/script execution or MCP initialization. A single-hyphen directory name remains valid; synthetic CLI regressions preserve a would-be overwritten file. `text_find` also caps the per-page match ranges it materializes at the remaining result limit plus one continuation match. CLI robustness scans visit each directory once through overlapping roots and symlink aliases. |
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 6c7920e33c..3c77c491cb 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,5 +1,6 @@
 # PdfCraft parity with Adobe Acrobat Pro
 
+> **Last reviewed:** 2026-10-28 | **Last updated:** 2026-10-28 | **Change:** minor (M10, #4119 partial: Enhance scanned file cleans scanned pages in place: background removal, edge shadow removal, despeckle; estimates unchanged)
 > **Last reviewed:** 2026-10-25 · **Last updated:** 2026-10-25 · **Change:** minor (localization current state: Arabic logical catalog, explicit RTL direction and mirrored stock chrome; native/browser RTL workflows unqualified. Native release Hans face via LXGW WenKai Lite. Scores and estimates unchanged)
 
 > **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** minor (localization ≈59% → ≈68%; weighted readiness 49.25 → 49.7 ≈ 50%) · **Target:** Adobe Acrobat Pro (Acrobat DC, continuous track 26.002.21931, macOS)
@@ -206,7 +207,7 @@ full parity in that area.
 | F Forms and JavaScript | 79 | 58 | 8 | 78.5% | 65% | 40–75 | Fill and author every AcroForm field type, Acrobat's AF functions in Acrobat's event order, sandboxed JavaScript (boa), data exchange, Fill & Sign; XFA static/dynamic layout, FormCalc and XFA data (partial). CLI info, text and render use the laid-out dynamic pages (#1645). Missing: wider JavaScript object model, document actions, submit, debugger, barcode fields, XFA flattening and full dynamic fidelity |
 | G Protect, redact, sanitize | 41 | 23 | 2 | 58.5% | 55% | 15–30 | Passwords and permissions, Remove security, redaction that removes glyphs, pixels, vectors, annotations and tags, with verification; word lists, patterns, FOIA/Privacy Act codes; sanitize. Missing: certificate security, pattern locales, custom code sets, partial-word redaction, folder redaction, protected view |
 | H Digital signatures | 45 | 23 | 10 | 62.2% | 45% | 40–70 | PAdES B-B signing and validation (PKCS #12, macOS Keychain, Windows store with PIN prompts), certification, encrypted documents, certificate usage checks; B-T, LTV, OCSP/CRL with caller-supplied evidence. Missing: PKCS #11 and smart cards outside Windows, timestamp-server preferences, online revocation fetching, FieldMDP and field locking, OS trust store, EU Trusted Lists, compare signed version |
-| I Scan and OCR | 26 | 5 | 2 | 23.1% | 15% | 40–75 | Searchable image (ocrs, Latin script without accents) on pages, ranges and many files. Missing: every other language (#744 Dutch; accents, CJK, Cyrillic, Arabic), editable-text output, deskew, rotation, despeckle, camera images beyond straightening (found or placed corners): orientation, clean-up, MRC compression, scanners |
+| I Scan and OCR | 26 | 5 | 2 | 23.1% | 15% | 40–75 | Searchable image (ocrs, Latin script without accents) on pages, ranges and many files. Missing: every other language (#744 Dutch; accents, CJK, Cyrillic, Arabic), editable-text output, deskew, rotation, camera images beyond straightening (found or placed corners): orientation, clean-up, MRC compression, scanners. Background removal, edge shadow removal and despeckle work on scanned pages (Enhance scanned file) but not yet as options of Recognize text, nor on CMYK, indexed, JBIG2 or CCITT scans |
 | J Create and export | 34 | 12 | 3 | 39.7% | 25% | 55–100 | Create from images, multipage TIFF, text, clipboard, blank, many files at once; export PNG/JPEG/TIFF, text, RTF; Word and HTML partial. Missing: Office/HTML/web/PostScript to PDF, Excel and PowerPoint export, Word layout fidelity (#773), SVG/XML/EPS/PS/JPEG 2000 export, accessible text |
 | K Optimize and standards | 58 | 15 | 10 | 34.5% | 20% | 65–115 | Reduce File Size and the Optimizer (images, discards, clean-up, space audit); PDF/A-2b/3b verify and convert (partial). Missing: Preflight (profiles, fixups, reports), PDF/A-1/4 and a/u levels, PDF/X, PDF/UA, PDF/E, PDF/VT, transparency flattening, font unembedding, monochrome JBIG2/CCITT |
 | L Print | 39 | 15 | 1 | 39.7% | 35% | 30–55 | Acrobat's sizing, n-up, booklet, poster, comments & forms, preview, print-ready PDF, CUPS on macOS/Linux, the Windows spooler (#756) and the browser's print dialog on the web. Missing: print as image, PostScript, all print-production tools (output preview, separations, ink manager, printer marks, colour conversion) |
diff --git a/parity/acrobat-features.toml b/parity/acrobat-features.toml
index 47ac06fdd4..1ea04254aa 100644
--- a/parity/acrobat-features.toml
+++ b/parity/acrobat-features.toml
@@ -6674,10 +6674,10 @@ area = "I"
 tier = "P1"
 milestone = "M10"
 status = "partial"
-commands = ["ocr.enhance_camera"]
-tools = ["page_enhance_camera"]
-evidence = ["crates/engine/src/camera_clean.rs::a_shadow_and_a_yellow_cast_become_white_paper", "crates/engine/src/tests.rs::enhance_camera_page_at_a_level_whitens_a_shadowed_sheet", "crates/ui-egui/tests/it/camera.rs::the_clean_up_level_enhances_again_from_the_photo_and_keeps_the_turn"]
-notes = "Camera images only: from clean-up level 60, isolated dark pixels are removed. Missing: for scanned pages and as an OCR option."
+commands = ["ocr.enhance_camera", "ocr.enhance"]
+tools = ["page_enhance_camera", "page_enhance_scan"]
+evidence = ["crates/engine/src/camera_clean.rs::a_shadow_and_a_yellow_cast_become_white_paper", "crates/engine/src/tests.rs::enhance_camera_page_at_a_level_whitens_a_shadowed_sheet", "crates/ui-egui/tests/it/camera.rs::the_clean_up_level_enhances_again_from_the_photo_and_keeps_the_turn", "crates/engine/src/scan_clean/tests.rs::despeckle_is_its_own_switch", "crates/automation/tests/it/automation.rs::enhance_scanned_file_cleans_the_scan_in_place_through_tools", "crates/ui-egui/tests/it/scan_clean.rs::enhance_scanned_file_cleans_the_chosen_pages_and_says_what_it_did"]
+notes = "Camera images, and scanned pages through Enhance scanned file (ocr.enhance, page_enhance_scan despeckle): isolated dark pixels (at most one dark neighbour) turn white, on grey, RGB and 1-bit scans, in place (the OCR text layer, comments and links stay). Missing: as an option of Recognize text; specks larger than two pixels; CMYK, indexed, JPEG 2000, JBIG2 and CCITT scans (reported, not changed)."
 
 [[feature]]
 id = "ocr.background-removal"
@@ -6686,10 +6686,10 @@ area = "I"
 tier = "P1"
 milestone = "M10"
 status = "partial"
-commands = ["ocr.enhance_camera"]
-tools = ["page_enhance_camera"]
-evidence = ["crates/engine/src/camera_clean.rs::a_shadow_and_a_yellow_cast_become_white_paper", "crates/engine/src/tests.rs::enhance_camera_page_at_a_level_whitens_a_shadowed_sheet", "crates/ui-egui/tests/it/camera.rs::the_clean_up_level_enhances_again_from_the_photo_and_keeps_the_turn"]
-notes = "Camera images only: Enhance camera image's clean-up level (and page_enhance_camera level) evens out the paper's illumination per channel, so the background turns white and colour casts go; colour ink stays. Missing: the same for scanned pages and as an OCR option."
+commands = ["ocr.enhance_camera", "ocr.enhance"]
+tools = ["page_enhance_camera", "page_enhance_scan"]
+evidence = ["crates/engine/src/camera_clean.rs::a_shadow_and_a_yellow_cast_become_white_paper", "crates/engine/src/tests.rs::enhance_camera_page_at_a_level_whitens_a_shadowed_sheet", "crates/ui-egui/tests/it/camera.rs::the_clean_up_level_enhances_again_from_the_photo_and_keeps_the_turn", "crates/engine/src/scan_clean/tests.rs::a_scan_gets_white_paper_even_edges_dark_strokes_and_no_specks_in_place", "crates/automation/tests/it/automation.rs::enhance_scanned_file_cleans_the_scan_in_place_through_tools", "crates/ui-egui/tests/it/scan_clean.rs::enhance_scanned_file_cleans_the_chosen_pages_and_says_what_it_did"]
+notes = "Camera images (Enhance camera image level) and scanned pages (Enhance scanned file ▸ Background removal, page_enhance_scan level): the paper's illumination is evened out per channel so a grey, yellowed or unevenly lit background turns white, then the contrast is raised; colour ink stays. Scans are cleaned in place in their own image objects (JPEG stays JPEG at quality 90, others lossless), so the OCR text layer, comments and links stay; one undo step. Missing: as an option of Recognize text; CMYK, indexed, JPEG 2000, JBIG2 and CCITT scans and scans inside form XObjects (reported, not changed); a preview."
 
 [[feature]]
 id = "ocr.descreen"
@@ -6722,10 +6722,10 @@ area = "I"
 tier = "P2"
 milestone = "M10"
 status = "partial"
-commands = ["ocr.enhance_camera"]
-tools = ["page_enhance_camera"]
-evidence = ["crates/engine/src/camera_clean.rs::a_shadow_and_a_yellow_cast_become_white_paper", "crates/engine/src/tests.rs::enhance_camera_page_at_a_level_whitens_a_shadowed_sheet", "crates/ui-egui/tests/it/camera.rs::the_clean_up_level_enhances_again_from_the_photo_and_keeps_the_turn"]
-notes = "Camera images only: the clean-up level divides out a smooth illumination estimate, which removes shadows and darker edges on the straightened photo. Missing: for scanned pages (book gutters) and as an OCR option."
+commands = ["ocr.enhance_camera", "ocr.enhance"]
+tools = ["page_enhance_camera", "page_enhance_scan"]
+evidence = ["crates/engine/src/camera_clean.rs::a_shadow_and_a_yellow_cast_become_white_paper", "crates/engine/src/tests.rs::enhance_camera_page_at_a_level_whitens_a_shadowed_sheet", "crates/ui-egui/tests/it/camera.rs::the_clean_up_level_enhances_again_from_the_photo_and_keeps_the_turn", "crates/engine/src/scan_clean/tests.rs::edge_shadow_removal_whitens_the_gutter_background_removal_alone_leaves", "crates/automation/tests/it/automation.rs::enhance_scanned_file_cleans_the_scan_in_place_through_tools", "crates/ui-egui/tests/it/scan_clean.rs::enhance_scanned_file_cleans_the_chosen_pages_and_says_what_it_did"]
+notes = "Camera images (the clean-up level divides out a smooth illumination estimate) and scanned pages (Enhance scanned file ▸ Edge shadow removal, page_enhance_scan edge_shadows): within the outer fifth of each side, every column and row is lightened to the brightest paper of that band, which removes book gutters and copier borders the coarse estimate misses; a black scanner border is left alone. Missing: as an option of Recognize text; curved gutters that also bend the text (no dewarping); the scan formats background removal also skips."
 
 [[feature]]
 id = "ocr.camera-perspective"