LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Merge remote-tracking branch 'upstream/main' into feat/brush-shift-click
Michael Andersondc562c654aef
diff --cc crates/engine/src/cmd/masks.rsindex 31470ede1,a53cc9ea7..0efb3b658--- a/crates/engine/src/cmd/masks.rs+++ b/crates/engine/src/cmd/masks.rs@@@ -150,49 -150,6 +150,55 @@@ fn masks_edit(s: &mut Session, c: &strOk(json!({"activeMask": active}))}+/// Most pieces a tapered ⇧-click segment is cut into.+const MAX_TAPER_STEPS: usize = 64;++/// The strokes a ⇧-click adds: `to` drawn on from point `from`, the last point of stroke `last` (a straight segment+/// to `to`'s first point, then the rest of `to`). When the brush's size, feather or flow changed since `last`, the+/// segment is cut into pieces whose values step from `last`'s to `to`'s, so the line tapers; strokes combine by their+/// maximum, so the pieces join without building up.+fn connected_strokes(from: Point, last: &BrushStroke, to: BrushStroke) -> Vec<BrushStroke> {+ let Some(&first) = to.points.first() else { return vec![to] };+ let same = |a: f64, b: f64| (a - b).abs() <= 1e-9;++ // pen pressure along the line: the last dab's at its start, the click's at its end (none when neither has any)++ let pressured = !last.pressure.is_empty() || !to.pressure.is_empty();++ let (p_from, p_to) = (last.pressure_at(0), to.pressure_at(0));+ if same(last.size, to.size) && same(last.feather, to.feather) && same(last.flow, to.flow) {+ let mut points = Vec::with_capacity(to.points.len() + 1);+ points.push(from);+ points.extend(to.points.iter().copied());- return vec![BrushStroke { points, ..to }];++ let pressure = if pressured { std::iter::once(p_from).chain((0..to.points.len()).map(|i| to.pressure_at(i))).collect() } else { Vec::new() };++ return vec![BrushStroke { points, pressure, ..to }];+ }+ // about 5% of size, or 2 points of feather or flow, per piece+ let ratio = if last.size > 0.0 && to.size > 0.0 { (to.size / last.size).ln().abs() / 1.05f64.ln() } else { 0.0 };+ let needed = [ratio, (to.feather - last.feather).abs() / 2.0, (to.flow - last.flow).abs() / 2.0]+ .into_iter()+ .filter(|v| v.is_finite())+ .fold(1.0f64, f64::max);+ let steps = (needed.ceil() as usize).clamp(1, MAX_TAPER_STEPS);+ let lerp = |a: f64, b: f64, t: f64| a + (b - a) * t;+ let at = |t: f64| Point::new(lerp(from.x, first.x, t), lerp(from.y, first.y, t));+ let mut out: Vec<BrushStroke> = (0..steps)+ .map(|i| {+ let (t0, t1) = (i as f64 / steps as f64, (i + 1) as f64 / steps as f64);++ let p = |t: f64| (f64::from(p_from) + (f64::from(p_to) - f64::from(p_from)) * t) as f32;+ BrushStroke {+ points: vec![at(t0), at(t1)],+ size: lerp(last.size, to.size, t1),+ feather: lerp(last.feather, to.feather, t1),+ flow: lerp(last.flow, to.flow, t1),++ pressure: if pressured { vec![p(t0), p(t1)] } else { Vec::new() },+ ..to.clone()+ }+ })+ .collect();+ if to.points.len() > 1 {+ out.push(to);+ }+ out+}+fn mask_id(p: &Value, active: Option<u32>, c: &str) -> Result<u32> {p.get("id").and_then(Value::as_u64).map(|v| v as u32).or(active).ok_or_else(|| bad(c, "no mask selected (give `id`)"))}@@@ -273,7 -233,7 +282,7 @@@ pub fn specs() -> Vec<CommandSpec>"Brush Stroke",[],None,- "{id?: maskId, points: [[x,y],…] normalized, size?: fraction of long edge (0.03), feather?, flow?, density?, erase?: bool, autoMask?: bool, connect?: bool — start from the last point of the mask's last stroke (⇧-click), size / feather / flow tapering from that stroke's to these} → {activeMask, connected}",- "{id?: maskId, points: [[x,y],…] normalized, size?: fraction of long edge (0.03), feather?, flow?, density?, erase?: bool, autoMask?: bool, pressure?: [p,…] pen pressure 0..1 per point (scales each dab's size and flow; omitted: full)}",++ "{id?: maskId, points: [[x,y],…] normalized, size?: fraction of long edge (0.03), feather?, flow?, density?, erase?: bool, autoMask?: bool, pressure?: [p,…] pen pressure 0..1 per point (scales each dab's size and flow; omitted: full), connect?: bool — start from the last point of the mask's last stroke (⇧-click), size / feather / flow tapering from that stroke's to these} → {activeMask, connected}",has_active,|s, p| {let pts: Vec<Point> = p@@@ -292,12 -253,12 +302,14 @@@density: f64_or(p, "density", d.density),erase: bool_or(p, "erase", false),auto_mask: bool_or(p, "autoMask", false),+ pressure: pressure_list(p.get("pressure"), pts_len)?,};+ let connect = bool_or(p, "connect", false);+ let mut connected = false;let next = s.active().and_then(|id| s.develop_of(id)).map(|d| d.next_mask_id()).unwrap_or(1);let want = p.get("id").and_then(Value::as_u64).map(|v| v as u32).or(s.active_mask);+ let adjust = super::mask_effects::new_mask_adjust(s, "brush");- masks_edit(s, "mask.brushStroke", "Brush", |masks, active| {+ let mut out = masks_edit(s, "mask.brushStroke", "Brush", |masks, active| {let i = match want.and_then(|m| masks.iter().position(|x| x.id == m)) {Some(i) => i,None => {@@@ -310,20 -271,7 +322,28 @@@if let Some(MaskComponent { shape: MaskShape::Brush { strokes }, .. }) =m.components.iter_mut().rev().find(|c| matches!(c.shape, MaskShape::Brush { .. })){- strokes.push(stroke);+ // the previous stroke's end and its brush values (not its points)+ let anchor = strokes.last().filter(|_| connect).and_then(|l| {+ Some((+ *l.points.last()?,- BrushStroke { points: Vec::new(), size: l.size, feather: l.feather, flow: l.flow, ..BrushStroke::default() },++ BrushStroke {++ points: Vec::new(),++ size: l.size,++ feather: l.feather,++ flow: l.flow,++ // the pressure the last dab was painted with, when the stroke recorded any++ pressure: if l.pressure.is_empty() { Vec::new() } else { vec![l.pressure_at(l.points.len().saturating_sub(1))] },++ ..BrushStroke::default()++ },+ ))+ });+ match anchor {+ Some((from, last)) => {+ strokes.extend(connected_strokes(from, &last, stroke));+ connected = true;+ }+ None => strokes.push(stroke),+ }} else {m.components.push(MaskComponent {name: None,diff --cc crates/engine/src/tests.rsindex e2cfee883,05ac3ee05..f4d18d055--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@@ -313,44 -313,23 +313,90 @@@ fn permanently_deleting_explicit_targetassert_eq!(s.catalog.to_snapshot(), snapshot);}+/// `mask.brushStroke {connect: true}` (a ⇧-click) starts from the last point of the mask's last stroke: one straight+/// stroke when the brush is unchanged, pieces whose size, feather and flow step from the last stroke's to the new+/// values when it changed, and a plain dab when there is nothing to connect to.+#[test]+fn connected_brush_strokes_start_where_the_last_one_ended() {+ use lightcraft_develop::MaskShape;+ use lightcraft_geom::Point;+ let mut s = demo();+ let id = s.active().unwrap();+ let r = s.execute("mask.brushStroke", &json!({"points": [[0.2, 0.5]], "size": 0.02, "connect": true})).unwrap();+ assert_eq!(r["connected"], false, "nothing to connect to: a dab");+ let strokes = |s: &Session| {+ let d = s.develop_of(id).unwrap();+ let MaskShape::Brush { strokes } = &d.masks[0].components[0].shape else { panic!("brush") };+ strokes.clone()+ };+ assert_eq!(strokes(&s)[0].points.len(), 1);+ let r = s.execute("mask.brushStroke", &json!({"points": [[0.6, 0.5]], "size": 0.02, "connect": true})).unwrap();+ assert_eq!(r["connected"], true);+ let line = strokes(&s);+ assert_eq!(line.len(), 2);+ assert_eq!(line[1].points, vec![Point::new(0.2, 0.5), Point::new(0.6, 0.5)]);+ // a bigger, softer brush: the segment tapers from the last stroke's values to the new ones+ let r = s.execute("mask.brushStroke", &json!({"points": [[0.6, 0.9]], "size": 0.04, "feather": 80, "connect": true})).unwrap();+ assert_eq!(r["connected"], true);+ let all = strokes(&s);+ let taper = &all[2..];+ assert!(taper.len() > 4, "{} pieces", taper.len());+ assert_eq!(taper[0].points[0], Point::new(0.6, 0.5), "from the last stroke's end");+ assert_eq!(*taper.last().unwrap().points.last().unwrap(), Point::new(0.6, 0.9), "to the click");+ assert!(taper.windows(2).all(|w| w[1].size >= w[0].size && w[1].feather >= w[0].feather && w[0].points[1] == w[1].points[0]));+ assert!((taper.last().unwrap().size - 0.04).abs() < 1e-12 && (taper.last().unwrap().feather - 80.0).abs() < 1e-9);+ assert!(taper[0].size > 0.02 && taper[0].size < 0.04);+ // all of it is one undo step+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(strokes(&s).len(), 2);+}++ #[test]+ fn brush_strokes_keep_pen_pressure_and_refuse_bad_lists() {+ let mut s = demo();+ s.execute("mask.add", &json!({"kind": "brush"})).unwrap();+ s.execute("mask.brushStroke", &json!({"points": [[0.2, 0.2], [0.3, 0.3]], "pressure": [0.25, 7.0]})).unwrap();+ let lightcraft_develop::MaskShape::Brush { strokes } = &active_dev(&s).masks[0].components[0].shape else { panic!("a brush") };+ assert_eq!(strokes[0].pressure, vec![0.25, 1.0], "kept, clamped to 0..1");+ for bad in [json!([0.5, 0.5, 0.5]), json!("hard"), json!([0.5, "x"])] {+ assert!(s.execute("mask.brushStroke", &json!({"points": [[0.2, 0.2], [0.3, 0.3]], "pressure": bad})).is_err(), "{bad}");+ }+ s.execute("mask.brushStroke", &json!({"points": [[0.4, 0.4]]})).unwrap();+ let lightcraft_develop::MaskShape::Brush { strokes } = &active_dev(&s).masks[0].components[0].shape else { panic!("a brush") };+ assert!(strokes[1].pressure.is_empty(), "a mouse stroke has no pressure data");+ let json = serde_json::to_string(&strokes[1]).unwrap();+ assert!(!json.contains("pressure"), "and stores none: {json}");+ }+++/// A ⇧-click line carries pen pressure: the last dab's at its start and the click's at its end, stepping along a++/// tapered line; with no pressure on either side there is none.++#[test]++fn connected_brush_strokes_carry_pen_pressure() {++ use lightcraft_develop::MaskShape;++ let mut s = demo();++ let id = s.active().unwrap();++ let strokes = |s: &Session| {++ let d = s.develop_of(id).unwrap();++ let MaskShape::Brush { strokes } = &d.masks[0].components[0].shape else { panic!("brush") };++ strokes.clone()++ };++ s.execute("mask.brushStroke", &json!({"points": [[0.2, 0.5]], "size": 0.02, "pressure": [0.4]})).unwrap();++ s.execute("mask.brushStroke", &json!({"points": [[0.6, 0.5]], "size": 0.02, "pressure": [1.0], "connect": true})).unwrap();++ assert_eq!(strokes(&s)[1].pressure, vec![0.4, 1.0]);++ s.execute("mask.brushStroke", &json!({"points": [[0.6, 0.9]], "size": 0.04, "pressure": [0.2], "connect": true})).unwrap();++ let taper = &strokes(&s)[2..];++ assert!(taper.iter().all(|t| t.pressure.len() == 2));++ assert!((taper[0].pressure[0] - 1.0).abs() < 1e-6 && (taper.last().unwrap().pressure[1] - 0.2).abs() < 1e-6);++ assert!(taper.windows(2).all(|w| w[1].pressure[0] <= w[0].pressure[0]));++ // a mouse: no pressure anywhere++ let mut m = demo();++ m.execute("mask.brushStroke", &json!({"points": [[0.2, 0.5]], "size": 0.02})).unwrap();++ m.execute("mask.brushStroke", &json!({"points": [[0.6, 0.5]], "size": 0.02, "connect": true})).unwrap();++ let d = m.develop_of(m.active().unwrap()).unwrap();++ let MaskShape::Brush { strokes } = &d.masks[0].components[0].shape else { panic!("brush") };++ assert!(strokes[1].pressure.is_empty());++}++#[test]fn masks_crop_and_render() {let mut s = demo();diff --cc crates/ui-egui/src/panels/detail.rsindex 23339445e,0f8803126..4f5bd8419--- a/crates/ui-egui/src/panels/detail.rs+++ b/crates/ui-egui/src/panels/detail.rs@@@ -1998,7 -2110,7 +2113,7 @@@ fn mask_overlay(app: &mut LightcraftApplet _ = app.run("mask.brushStroke",json!({"points": pts, "size": app.ui.brush_size, "feather": app.ui.brush_feather, "flow": app.ui.brush_flow,- "erase": erase, "autoMask": app.ui.brush_auto_mask, "connect": connect}),- "erase": erase, "autoMask": app.ui.brush_auto_mask, "pressure": pressure}),++ "erase": erase, "autoMask": app.ui.brush_auto_mask, "pressure": pressure, "connect": connect}),);}return;diff --cc docs/parity-checklist.mdindex 7f71e43bb,d5c62bc6f..5f6141d13--- a/docs/parity-checklist.md+++ b/docs/parity-checklist.md@@@ -1,6 -1,6 +1,6 @@@# Lightroom parity checklist- > **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (LR-MASK-BRUSH: ⇧-click draws a straight stroke from the last one; catalog import: persistent result, offline Local promotion and library-switch dismissal; integration batch 35: KEYC-SELECTONLYACTIVE, Select Only Active Photo ⌘⇧D; LR-BEHAV-AUTOSAVE, damaged snapshots repaired on open; LR-EDIT-OPTICS-PROFILE, Nikon Z 6II / Z 8 / Z f in-file distortion; LRC-LIB-CATALOG-IMPORT, WAL-only catalogs open; LR-EXP-DIM, enlargements stop at 512 MP; LR-IMP-CAMERA-COVERAGE, Canon EOS RP CR3 verified; model folder retry) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (integration batch 36: slideshow module, print-ready PDF fixes, local adjustment presets, Layout Image loupe overlay, Delete in an album removes from it, new languages Czech, Polish, Italian-ready catalogs; many rows' notes updated by their PRs) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6++> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-14 · **Change:** minor (LR-MASK-BRUSH: ⇧-click draws a straight stroke from the last one; integration batch 36: slideshow module, print-ready PDF fixes, local adjustment presets, Layout Image loupe overlay, Delete in an album removes from it, new languages Czech, Polish, Italian-ready catalogs; many rows' notes updated by their PRs) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6The measured, row-by-row checklist: one row per Lightroom feature, menu item and shortcut, what wehave and what is missing. It answers *does the feature exist?* (feature breadth). Whether it is good@@@ -292,11 -295,11 +295,11 @@@ differences and missing bindings are i| LR-MASK-OBJECTS | Object selection | P2 | 🟡 | `cmd:mask.add` (`object`, `prompt`), `cmd:mask.objectPoint`, `cmd:mask.refineDetail`, `cmd:segment.prepare`, `cmd:segment.model.status`, `cmd:segment.model.download`, `cmd:segment.model.cancel`, `cmd:app.openSamModelFolder`, `crates/segment`, `crates/engine/src/segment/mod.rs` | SAM 3 in pure Rust (candle; Metal on macOS, CPU elsewhere): Object tile → click to include, ⌥-click to leave out; Describe tile → a text prompt selects every instance ("sky", "the red car"); both also as Add/Subtract/Intersect components; + / − under the selected mask; comma lists (`car, road`); a zoomed-in detail pass for 5–10× finer edges on small objects; per-selection Edge (hard ↔ soft). The model runs on its own worker thread (the UI never waits; panics become errors), is unloaded after 10 min idle, and is optional: the segmentation is stored with the mask (288² logits), so renders and exports never need it. Weights are never bundled (SAM License): without them the app offers a consented background download (mirrors, resume, timeouts, SHA-256) — **but no default download location is configured yet** (users set `LIGHTCRAFT_SAM3_MIRRORS` or install by hand: the dialog names the three files, opens the configured model folder with the host opener, preserves setup on an open error, and links docs/ai-masks.md). Not verified against Lightroom's Select Object; no brush/box object mode; the first click on a photo waits for its analysis (~4 s on an M4 Pro, much longer on CPU) || LR-MASK-PEOPLE | People parts | P2 | ⬜ | | shape exists (no UI): uses the photo's person / skin / hair / teeth / glasses mattes when it carries them (DNG semantic masks), else the subject heuristic || LR-MASK-LANDSCAPE | Landscape classes | P2 | ⬜ | | shape exists, evaluates empty |- | LR-MASK-BRUSH | Brush mask | P0 | 🟡 | `cmd:tool.brush`, `cmd:mask.brushStroke` (`autoMask`), `crates/pipeline/src/masks.rs`, `crates/ui-egui/src/brush_live.rs` | size/feather/flow/density/erase; Create New Mask starts a separate brush in paint mode; the stroke shows while the button is held with the committed stroke's dab spacing, feather and flow, so fast strokes have no gaps (#517); coverage builds up by passes, not hold time (holding the brush still adds nothing, live or committed, #518); Auto Mask: dabs weighted by similarity to the colour under the dab centre, refined by a guided filter on luminance (CPU + GPU); ⇧-click draws a straight stroke from where the last stroke ended (`connect`), tapering size, feather and flow from that stroke's values when they changed; no A/B brushes, no pressure |-| LR-MASK-BRUSH | Brush mask | P0 | 🟡 | `cmd:tool.brush`, `cmd:mask.brushStroke` (`autoMask`), `crates/pipeline/src/masks.rs`, `crates/ui-egui/src/brush_live.rs` | size/feather/flow/density/erase; Create New Mask starts a separate brush in paint mode; the stroke shows while the button is held with the committed stroke's dab spacing, feather and flow, so fast strokes have no gaps (#517); coverage builds up by passes, not hold time (holding the brush still adds nothing, live or committed, #518); Auto Mask: dabs weighted by similarity to the colour under the dab centre, refined by a guided filter on luminance (CPU + GPU); no A/B brushes, no pressure; pen pressure (Brush ▸ Pen Pressure, on by default; `pressure` per point in `mask.brushStroke`) scales each dab's size (a tenth to all of it) and flow, live and committed alike, where winit reports a pen force (Windows; not macOS / Linux tablets yet); no tilt |++| LR-MASK-BRUSH | Brush mask | P0 | 🟡 | `cmd:tool.brush`, `cmd:mask.brushStroke` (`autoMask`), `crates/pipeline/src/masks.rs`, `crates/ui-egui/src/brush_live.rs` | size/feather/flow/density/erase; Create New Mask starts a separate brush in paint mode; the stroke shows while the button is held with the committed stroke's dab spacing, feather and flow, so fast strokes have no gaps (#517); coverage builds up by passes, not hold time (holding the brush still adds nothing, live or committed, #518); Auto Mask: dabs weighted by similarity to the colour under the dab centre, refined by a guided filter on luminance (CPU + GPU); ⇧-click draws a straight stroke from where the last stroke ended (`connect`), tapering size, feather and flow from that stroke's values when they changed (and pen pressure from the last dab's to the click's); no A/B brushes, no pressure; pen pressure (Brush ▸ Pen Pressure, on by default; `pressure` per point in `mask.brushStroke`) scales each dab's size (a tenth to all of it) and flow, live and committed alike, where winit reports a pen force (Windows; not macOS / Linux tablets yet); no tilt || LR-MASK-LINEAR | Linear gradient | P0 | ✅ | `cmd:tool.linear`, `cmd:mask.update` | || LR-MASK-RADIAL | Radial gradient | P0 | ✅ | `cmd:tool.radial`, `cmd:mask.update`, `crates/ui-egui/src/panels/detail.rs` | drag the selected ellipse's body or centre pin to move; edge grips resize, outer grip rotates; rotated and compound radial components, hidden pins, outside hit rejection and one-step undo tested |- | LR-MASK-COLORRANGE | Colour range | P1 | ✅ | `cmd:mask.add` (`colorRange`), `cmd:mask.sampleColor`, `cmd:mask.update`, `crates/pipeline/src/lib.rs` (`color_range_sample`) | Color tile → click the photo to sample (⇧-click adds, up to 5; samples taken in the space the mask compares in), Pick button, Refine slider |- | LR-MASK-LUMRANGE | Luminance range | P1 | ✅ | `cmd:mask.add` (`luminanceRange`), `cmd:mask.update`, `crates/ui-egui/src/panels/masking.rs` (`range_controls`) | range bar with two handles (one undo step per drag), Smoothness, Show Luminance Map (B&W photo with the range tinted) |+ | LR-MASK-COLORRANGE | Colour range | P1 | ✅ | `cmd:mask.add` (`colorRange`), `cmd:mask.sampleColor`, `cmd:mask.update`, `crates/pipeline/src/lib.rs` (`color_range_sample`) | Color tile → click the photo to sample (⇧-click adds, up to 5; samples taken in the space the mask compares in, respecting section eyes and the requested HDR/SDR rendition), Pick button, Refine slider |+ | LR-MASK-LUMRANGE | Luminance range | P1 | ✅ | `cmd:mask.add` (`luminanceRange`), `cmd:mask.update`, `crates/ui-egui/src/panels/masking.rs` (`range_controls`) | range bar with two handles (the pressed endpoint stays selected through fast/crossing drags; one undo step per drag), Smoothness, Show Luminance Map (B&W photo with the range tinted) || LR-MASK-DEPTHRANGE | Depth range | P2 | ⬜ | | shape exists, needs depth data || LR-MASK-COMBINE | Add / subtract / intersect | P0 | ✅ | `cmd:mask.addComponent`, `cmd:tool.brush` | Add/Subtract > Brush creates a component with the chosen operation; Erase removes paint within that brush component || LR-MASK-INVERT | Invert | P0 | ✅ | `cmd:mask.invert` | |@@@ -790,7 -795,14 +795,15 @@@ Latin stays upright. Advanced Japanese| Date | Change | Summary ||---|---|---|+ | 2026-10-14 | minor | LR-IMP-CAMERA-COVERAGE: 17 uncompressed Olympus and Samsung Adobe models verified on one CC0 file each; status unchanged (🟡) |+ | 2026-10-13 | minor | LR-EDIT-SECTION-SOLO: Solo Mode for Edit sections (Window ▸ Edit Sections, section-header menu, ⌥-click); KEYC-PANELS notes it |+ | 2026-10-14 | minor | LR-MERGE-HDR ✅ → 🟡: tested on real 67 MP Sony brackets; moving clipped highlights (black-hole stars) and dark-sky ghosts fixed, merge memory cut ~25 %; AI Denoise on merged DNGs, JPEG response curves and per-frame memory remain (gap 29). LR-MERGE-HEADLESS, MENU-PHOTO-MERGE: HDR for Each Bracket Set (`merge.hdrBatch`) |+ | 2026-10-15 | patch | LR-VIEW-BEFOREAFTER: side by side and stacked panes share click-zoom animation for whole-frame images, window tiles and input; render requests keep the final target (#1821); status unchanged |+ | 2026-10-14 | patch | LR-META-XMP: automatic sidecar writes that fail (folder offline or read-only) wait and are written again once the files are reachable, with a notice (`cmd:library.retrySidecars`); status unchanged |+ | 2026-10-13 | minor | LR-BEHAV-WINDOW (new, 🟡): the desktop app's window opens at the size it was left at, zoomed / maximized if it was; full screen and the place on the desktop are not remembered |+ | 2026-10-14 | minor | LR-IMP-CAMERA-COVERAGE: Nikon D600, D610 and D5000 NEFs drop the filler and noise columns on the right (a band), and the D600 and D610 measure their white level inside the image (#1627); status unchanged (🟡) |+ | 2026-10-15 | patch | LR-VIEW-BEFOREAFTER: side by side and stacked panes share click-zoom animation for whole-frame images, window tiles and input; render requests keep the final target (#1821); status unchanged |+| 2026-10-14 | patch | LR-MASK-BRUSH: ⇧-click with the brush draws a straight stroke from where the last stroke ended, tapering when the brush changed in between (`cmd:mask.brushStroke` `connect`); status unchanged || 2026-10-13 | patch | LR-VIEW-COMPARE, LRC-LIB-COMPARE: ⌘/Ctrl- and Shift-clicks on the filmstrip in Compare change the selection as in the grid; the two photos shown stay selected and the active photo is unchanged (#187); statuses unchanged || 2026-10-13 | minor | KEYC-SELECTONLYACTIVE: Edit → Select Only Active Photo (⌘⇧D) lands as a new row; status 🟡 (headless-tested, native macOS menu path unverified) || 2026-10-13 | patch | LRC-LIB-CATALOG-IMPORT: a catalog whose tables are all still in its `-wal` file (main file schema format 0) opens instead of failing as an unsupported schema format; status unchanged |diff --cc docs/whats-new.mdindex eab1353d7,3404dc978..0f3f45b65--- a/docs/whats-new.md+++ b/docs/whats-new.md@@@ -2,11 -2,121 +2,126 @@@## 2026-10-14+ ### Lightroom radial masks on the right side+ - Radial masks brought over from Lightroom Classic (catalog import, XMP sidecars, edits inside DNGs and presets) now+ apply their effect inside the circle, as Lightroom does, instead of outside it (issue #1815). A mask inverted in+ Lightroom stays inverted, and older Radial Filters keep their Effect Outside / Invert Mask setting. Photos imported+ before this keep the masks they got: Photo ▸ Read Metadata from File reads a sidecar's again.++ ### Delete in an album removes from the album only+ - In an album, the Delete key now takes the selected photos out of the album, as in Lightroom. It used to move them+ to Recently Deleted, so they also left their folder's view (issue #1805). They stay in the library and in their+ folder; Edit ▸ Undo puts them back in the album. Photo ▸ Remove from Album does the same and now shows the key.+ To delete photos from the library from an album, use Photo ▸ Delete Photo or right-click ▸ Delete Photo. In a smart+ album, Delete changes nothing: its rules decide what it shows.++ ### Local folders select a photo+ - Showing a Local folder now makes its first photo the active one, as albums and the other sources do (issue+ #1447), or keeps the photo you had when the folder holds it. Before, the photo from the previous view stayed active:+ Photo Grid marked nothing, and Detail, the histogram and the photo info showed a photo that isn't in the folder.++ ### HDR merges of moving lights, and many brackets at once+ - A star, the moon or a light that moves between the photos of a bracket (a night bracket on a tripod) no longer+ leaves a black hole where the middle photo had it clipped. With Deghost, the brightest photo's copy of it in a+ dark sky is now removed too.+ - Photo ▸ Photo Merge ▸ HDR for Each Bracket Set merges every bracket among the selected photos with the last HDR+ settings, one after the other: each stack, and photos taken less than a second apart at different exposures.+ From the command line: `lightcraft-cli merge hdr-batch FOLDER`.+ - Merging uses about a quarter less memory: three 67 MP raws need 3.8 GB instead of 4.8 GB.++ ### XMP sidecars catch up after a network share comes back+ - With automatic XMP writing on, an edit to a photo whose folder can't be written (a network share that dropped+ out, a folder that went read-only) used to be written only to the library, with a line in the log, so the sidecar+ stayed behind the edit. LightCraft now says once that the sidecars are waiting, tries again every few seconds once+ the files are reachable, and says when they're written. `library.retrySidecars` does it on request.++ ### Reliability+ - A damaged or crafted raw can no longer make LightCraft set aside gigabytes of memory before finding out the file is+ bad (issue #1512): a compressed PEF whose data is too short for the size it declares, an uncompressed TIFF-based+ raw whose tile claims far more samples than it holds, and an ARW6 with a broken tile are refused first. All 74+ files in the test corpus still decode.++ ### Reliability+ - Thumbnails and previews are written to the cache on disk by one background writer instead of a new thread for+ each image (issue #1522). When renders come in faster than the disk takes them, at most 128 MB of images wait;+ past that a write is skipped (the image stays in memory and is written by a later render), so a slow disk can't+ pile up threads and memory.++ ### Reliability+ - Saving the catalog and resuming a model download no longer write through a link left at the temporary file's+ name (`catalog.snap.tmp`, `model.onnx.part`): the link is removed and a new file made in its place, so the file it+ pointed to is never changed (issue #1502).++ ### Reliability+ - A photo whose file was replaced (Reload Changed Files after an outside edit) no longer keeps the faces recognition+ made from the old pixels: they are made again from the new file, and a scan still busy with the old file when it+ changed doesn't put its faces on the new one (issue #1524).++ ### Settings stays put when you change tabs+ - The Settings window keeps its top edge and width when you switch tabs, so the tab row no longer jumps around+ under the pointer. It used to be centred, so every tab of a different height moved it.++ ### Layout image over the loupe+ - View ▸ Loupe Overlay ▸ Choose Layout Image… draws a PNG with transparency over the photo in the loupe, such as+ a magazine cover's masthead and cover lines, so you can frame a shot for the page it is made for. It fits inside+ the photo, follows zoom and pan, and ⌥⌘O shows or hides it. The same menu sets its opacity and a matte that+ darkens the photo outside it. The layout stays chosen across launches.++ ### Smaller JPEG exports+ - JPEG exports are 12–14 % smaller at the same quality, with exactly the same pixels (issue #1373): each file now+ carries Huffman tables made for its own picture instead of the standard example tables. Every viewer opens them+ as before.++ ### Reliability+ - A photo whose Defringe amount was stored far past the sliders' 20 (in a damaged catalog or sidecar) no longer+ crashes LightCraft each time it renders: the amount acts as 20.++ ### Lens names for Nikon DSLR raws+ - Photos from Nikon DSLRs like the D700, D750, D80 or D5300 now show which lens they were taken with, for example+ "24.0-70.0 mm f/2.8". Those cameras don't write a lens name, so the lens field was empty and you couldn't filter or+ search by lens. LightCraft now reads the lens range Nikon keeps in its own maker note, the way Lightroom shows a+ lens it doesn't have a name for. Newly imported photos show it.++ ### Import when a card is connected+ - Settings → Import → Cameras and Cards has an option to open the import review as soon as a camera or memory card+ is connected, the same review File → Import from Device opens. It's off by default. A card that's already in when+ LightCraft starts doesn't ask, and if a dialog is open or an import is running it waits until that's done.++ ### Local folders+ - Photos deleted (or moved) by another app no longer stay in a Local folder, failing to load and logging an error+ each time you look (issue #1392): the next time you browse the folder, in a later session, they're left out. A photo you had rated, flagged or+ edited stays, marked missing, so its changes aren't lost; photos in My Photos are unchanged.++ ### Full-resolution panoramas+ - Panorama and HDR Panorama merges keep the resolution of their photos instead of stopping at 40 megapixels+ (issue #1455), up to 512 MP and 65,000 pixels on the long edge, as in Lightroom. When the full size needs more+ memory than the computer has, the panorama is made as large as fits (five 51 MP photos: up to 166 MP with+ 16 GB, 355 MP with 32 GB) and the message says so. The merge also frees each photo's pixels once they are+ projected, so it needs less memory than before at any size (an 81 MP stitch: 4.4 GB instead of 6.2 GB).++ ### Nikon D600, D610 and D5000+ - Raws from the Nikon D600, D610 and D5000 no longer show a bright line down the right edge (issue #1627). Their+ sensor data runs a few columns of filler past the picture, which stayed in the image; these bodies now develop+ at the camera JPEG's size (6016 × 4016 for the D600 and D610, 4288 × 2848 for the D5000, as the D90 already+ did). On the D600 and D610 the white level is also measured inside the picture, so the filler can't pass for+ clipped highlights.++ ### More Canon EOS R6 Mark II C-RAW files decode+ - Some EOS R6 Mark II C-RAW files (about 1 in 50 in one photographer's library) opened as their preview with+ "Canon CRX adaptive QP value 172" or "175". They now decode from the sensor data. Photos imported before this+ switch over with Photo ▸ Reload from Disk.++ ### Nikon raws without coloured edge bars+ - Raws from older Nikon bodies no longer show a thin coloured or dark bar along one edge (the right edge, or the top+ of a portrait photo): masked sensor columns were being developed as part of the picture (issues #976, #914,+ #1236). The D7000, D5100, D800, D800E, Df, D4, D3, D3S, D700, D300, D300S, D600, D610, D810, D4S, D5600,+ Coolpix A, D3000, D40X, D60, D80, D2Xs, D200, D3200, D3100, D5000, D40, D50, D70, D70s and Nikon 1 V1 now show+ the area the camera itself frames, a few pixels smaller than before.+### Straight brush strokes with ⇧-click+- With the brush, click once, then ⇧-click somewhere else: the brush paints a straight line between the two, and+ further ⇧-clicks carry on from the last point, as in Lightroom. Change the brush size, feather or flow before the+ ⇧-click and the line tapers from the old values to the new ones. The whole line is one undo step.+ `mask.brushStroke {connect: true}` does the same for agents.### Hard-edged Heal and Clone spots- A spot with Feather at 0 no longer draws black pixels exactly on its radius. This also fixes spots at 0% Opacity