Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

LRC-DEV-HISTORY: History cursor — going to a step adds no step

Andrew Frahn139e9633cf56
diff --git a/crates/catalog/src/journal.rs b/crates/catalog/src/journal.rs
index 697ddf010..dd92b5e2d 100644
--- a/crates/catalog/src/journal.rs
+++ b/crates/catalog/src/journal.rs
@@ -50,6 +50,7 @@
//! | 5 | the keyword list | `Op::SetKeyword`, `Catalog.keyword_list` |
//! | 6 | folder labels | `Op::SetFolderRecord`, `Catalog.folder_records` |
//! | 7 | Kelvin white balance for raws whose camera has matrices (#730) | `Op::SetAsShotWb`, `WhiteBalance.scale` |
+//! | 8 | History cursor: Go to History Step adds no step | `Op::SetHistoryCursor`, `Photo.history_cursor` |
//!
//! Rules:
//! - **Bump [`VERSION`]** (and add a row above) in the change that adds an [`Op`] variant or a
@@ -74,7 +75,7 @@ pub const LOG: &str = "catalog.log";
const FORMAT: &str = "lightcraft-catalog";
/// The catalog format this build writes (and the newest it reads). See the module docs →
/// *Format versions*; bump it whenever an [`Op`] variant or a serialized field is added.
-pub const VERSION: u32 = 7;
+pub const VERSION: u32 = 8;
/// When [`Journal::wants_snapshot`] says it's time to compact the log.
#[derive(Clone, Copy, Debug)]
diff --git a/crates/catalog/src/lib.rs b/crates/catalog/src/lib.rs
index cc24266f2..ecde973ba 100644
--- a/crates/catalog/src/lib.rs
+++ b/crates/catalog/src/lib.rs
@@ -125,6 +125,12 @@ pub enum Op {
id: PhotoId,
step: HistoryStep,
},
+ /// Move the History cursor (see [`Photo::history_cursor`]) without changing the steps.
+ SetHistoryCursor {
+ id: PhotoId,
+ #[serde(default)]
+ cursor: Option<usize>,
+ },
AddAlbum {
album: Album,
},
@@ -545,12 +551,25 @@ impl Catalog {
Op::PushHistory { id, step } => {
let p = self.photo_mut(id)?;
let old = p.history.clone();
+ let old_cursor = p.history_cursor.take();
+ // a new edit made from an earlier step drops the steps after it
+ if let Some(c) = old_cursor {
+ p.history.truncate(c.saturating_add(1));
+ }
p.history.push(step);
if p.history.len() > HISTORY_LIMIT {
let n = p.history.len() - HISTORY_LIMIT;
p.history.drain(..n);
}
- Op::SetHistory { id, history: old }
+ if old_cursor.is_none() {
+ Op::SetHistory { id, history: old }
+ } else {
+ Op::Batch { ops: vec![Op::SetHistory { id, history: old }, Op::SetHistoryCursor { id, cursor: old_cursor }] }
+ }
+ }
+ Op::SetHistoryCursor { id, cursor } => {
+ let p = self.photo_mut(id)?;
+ Op::SetHistoryCursor { id, cursor: std::mem::replace(&mut p.history_cursor, cursor) }
}
Op::AddAlbum { album } => {
if self.albums.contains_key(&album.id) {
diff --git a/crates/catalog/src/local.rs b/crates/catalog/src/local.rs
index ff83a179d..9cfc14f35 100644
--- a/crates/catalog/src/local.rs
+++ b/crates/catalog/src/local.rs
@@ -279,6 +279,7 @@ impl Op {
| Op::SetVersions { id, .. }
| Op::SetHistory { id, .. }
| Op::PushHistory { id, .. }
+ | Op::SetHistoryCursor { id, .. }
| Op::SetCaptured { id, .. }
| Op::SetAnalysis { id, .. }
| Op::SetFile { id, .. }
diff --git a/crates/catalog/src/model.rs b/crates/catalog/src/model.rs
index abeaadad4..a4216a37e 100644
--- a/crates/catalog/src/model.rs
+++ b/crates/catalog/src/model.rs
@@ -247,6 +247,11 @@ pub struct Photo {
pub versions: Vec<Version>,
#[serde(default)]
pub history: Vec<HistoryStep>,
+ /// The History step the photo's settings are at, when it isn't the latest one (Go to History
+ /// Step moved back): later steps stay listed and can be returned to until a new edit drops
+ /// them. `None` (and catalogs written before the cursor existed) = the latest step.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub history_cursor: Option<usize>,
/// In "Recently Deleted".
#[serde(default)]
pub deleted: bool,
@@ -327,6 +332,12 @@ pub fn relative_wb_camera(format: &str, camera: &str) -> bool {
}
impl Photo {
+ /// The History step the settings are at (the cursor, clamped to the list; `None` = no history).
+ pub fn history_index(&self) -> Option<usize> {
+ let last = self.history.len().checked_sub(1)?;
+ Some(self.history_cursor.map_or(last, |c| c.min(last)))
+ }
+
pub fn new(id: PhotoId, source: Source, file_name: &str, format: &str, width: u32, height: u32, imported: &str) -> Photo {
Photo {
id,
@@ -347,6 +358,7 @@ impl Photo {
edited: None,
versions: Vec::new(),
history: Vec::new(),
+ history_cursor: None,
deleted: false,
local: false,
duration: None,
diff --git a/crates/catalog/src/tests_format_version.rs b/crates/catalog/src/tests_format_version.rs
index 37bd639e8..e2461781a 100644
--- a/crates/catalog/src/tests_format_version.rs
+++ b/crates/catalog/src/tests_format_version.rs
@@ -211,8 +211,9 @@ fn op_variants_are_versioned() {
Op::SetKeyword { .. } => 5,
Op::SetFolderRecord { .. } => 6,
Op::SetAsShotWb { .. } => 7,
+ Op::SetHistoryCursor { .. } => 8,
}
}
- let newest = since(&Op::SetAsShotWb { id: PhotoId(1), wb: None });
+ let newest = since(&Op::SetHistoryCursor { id: PhotoId(1), cursor: None });
assert_eq!(newest, VERSION, "the newest op's version must be the current format version");
}
diff --git a/crates/engine/src/cmd/develop.rs b/crates/engine/src/cmd/develop.rs
index 42f59fe72..1ae72e48e 100644
--- a/crates/engine/src/cmd/develop.rs
+++ b/crates/engine/src/cmd/develop.rs
@@ -1079,15 +1079,47 @@ pub fn specs() -> Vec<CommandSpec> {
let id = active(s, "history.clear")?;
let d = s.develop_of(id).unwrap_or_default();
let history = vec![lightcraft_catalog::HistoryStep { label: "Cleared History".into(), settings: d }];
- s.commit("Clear History", Op::SetHistory { id, history })?;
+ s.commit("Clear History", Op::Batch { ops: vec![Op::SetHistory { id, history }, Op::SetHistoryCursor { id, cursor: None }] })?;
ok()
}),
- cmd!("history.restore", "Go to History Step", [], None, "{index}", has_active, |s, p| {
- let id = active(s, "history.restore")?;
- let i = f64_req(p, "index", "history.restore")? as usize;
- let st = s.catalog.photo(id).and_then(|ph| ph.history.get(i).cloned()).ok_or_else(|| bad("history.restore", "no such step"))?;
- s.set_develop(id, (*st.settings).clone(), &format!("History: {}", st.label))?;
- ok()
+ cmd!(
+ "history.restore",
+ "Go to History Step",
+ [],
+ None,
+ "{index} — loads that step's settings and moves the History cursor there; later steps stay listed until a new edit",
+ has_active,
+ |s, p| {
+ let c = "history.restore";
+ let id = active(s, c)?;
+ let i = f64_req(p, "index", c)?;
+ if !(i.is_finite() && i >= 0.0) {
+ return Err(bad(c, "no such step"));
+ }
+ go_to_history_step(s, c, id, i as usize)
+ }
+ ),
+ cmd!("history.previous", "Previous History Step", [], None, "{} — steps the History cursor back one step", has_history_before, |s, _| {
+ let c = "history.previous";
+ let id = active(s, c)?;
+ let i = s
+ .catalog
+ .photo(id)
+ .and_then(|ph| ph.history_index())
+ .and_then(|i| i.checked_sub(1))
+ .ok_or_else(|| bad(c, "at the first History step"))?;
+ go_to_history_step(s, c, id, i)
+ }),
+ cmd!("history.next", "Next History Step", [], None, "{} — steps the History cursor forward one step", has_history_after, |s, _| {
+ let c = "history.next";
+ let id = active(s, c)?;
+ let ph = s.catalog.photo(id).ok_or_else(|| bad(c, "no photo"))?;
+ let i = ph
+ .history_index()
+ .map(|i| i.saturating_add(1))
+ .filter(|i| *i < ph.history.len())
+ .ok_or_else(|| bad(c, "at the latest History step"))?;
+ go_to_history_step(s, c, id, i)
}),
// ---- interactions (slider drags, brush strokes)
cmd!("develop.beginInteraction", "Begin Interaction", [], None, "{label}", has_active, |s, p| {
@@ -1104,3 +1136,32 @@ pub fn specs() -> Vec<CommandSpec> {
}),
]
}
+
+/// Load History step `i` of photo `id` and put the cursor there, without adding a step: the later
+/// steps stay listed (one undo step).
+fn go_to_history_step(s: &mut Session, c: &str, id: PhotoId, i: usize) -> Result<Value> {
+ let ph = s.catalog.photo(id).ok_or_else(|| bad(c, "no photo"))?;
+ let st = ph.history.get(i).cloned().ok_or_else(|| bad(c, "no such step"))?;
+ let cursor = (i.saturating_add(1) < ph.history.len()).then_some(i);
+ let label = format!("History: {}", st.label);
+ let edited = Some((s.clock)());
+ s.commit(
+ &label,
+ Op::Batch { ops: vec![Op::SetDevelop { id, settings: st.settings, label: label.clone(), edited }, Op::SetHistoryCursor { id, cursor }] },
+ )?;
+ ok()
+}
+
+fn has_history_before(s: &Session) -> std::result::Result<(), String> {
+ let at = s.active().and_then(|id| s.catalog.photo(id)).and_then(|p| p.history_index());
+ if at.is_some_and(|i| i > 0) { Ok(()) } else { Err("at the first History step".into()) }
+}
+
+fn has_history_after(s: &Session) -> std::result::Result<(), String> {
+ let photo = s.active().and_then(|id| s.catalog.photo(id));
+ if photo.is_some_and(|p| p.history_index().is_some_and(|i| i.saturating_add(1) < p.history.len())) {
+ Ok(())
+ } else {
+ Err("at the latest History step".into())
+ }
+}
diff --git a/crates/engine/src/cmd/query.rs b/crates/engine/src/cmd/query.rs
index 6c232860d..2feb9dbb3 100644
--- a/crates/engine/src/cmd/query.rs
+++ b/crates/engine/src/cmd/query.rs
@@ -204,11 +204,12 @@ pub fn specs() -> Vec<CommandSpec> {
))
}),
cmd!(query "profiles.menu", "Profile Menu", [], None, "{} — favourites, recent (newest first) and groups", always, |s, _| Ok(s.profile_menu())),
- cmd!(query "history.list", "List History", [], None, "{id?}", has_active, |s, p| {
+ cmd!(query "history.list", "List History", [], None, "{id?} — returns {history: labels oldest first, cursor: index of the step the settings are at (later steps can be returned to), versions}", has_active, |s, p| {
let id = photo_arg(s, p, "history.list")?;
let ph = s.catalog.photo(id).ok_or_else(|| bad("history.list", "no such photo"))?;
Ok(json!({
"history": ph.history.iter().map(|h| h.label.clone()).collect::<Vec<_>>(),
+ "cursor": ph.history_index(),
"versions": ph.versions.iter().map(|v| json!({"name": v.name, "created": v.created})).collect::<Vec<_>>(),
}))
}),
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 3bc6c431e..f873c115d 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -130,7 +130,8 @@ fn single_photo(op: &Op, depth: usize) -> Option<PhotoId> {
| Op::SetMeta { id, .. }
| Op::SetVersions { id, .. }
| Op::SetHistory { id, .. }
- | Op::PushHistory { id, .. } => Some(*id),
+ | Op::PushHistory { id, .. }
+ | Op::SetHistoryCursor { id, .. } => Some(*id),
Op::Batch { ops } if depth < 8 => {
let mut ids = ops.iter().map(|o| single_photo(o, depth + 1));
let first = ids.next()??;
@@ -999,6 +1000,8 @@ mod tests_folders;
#[cfg(test)]
mod tests_forget_local;
#[cfg(test)]
+mod tests_history_cursor;
+#[cfg(test)]
mod tests_import;
#[cfg(test)]
mod tests_import_move;
diff --git a/crates/engine/src/tests_history_cursor.rs b/crates/engine/src/tests_history_cursor.rs
new file mode 100644
index 000000000..55c265403
--- /dev/null
+++ b/crates/engine/src/tests_history_cursor.rs
@@ -0,0 +1,100 @@
+//! Feature: the History panel has a cursor. Going to a step loads its settings without adding a
+//! step; later steps stay listed until a new edit drops them; undo/redo stay coherent.
+
+use serde_json::json;
+
+use crate::Session;
+
+fn exposure(s: &Session) -> f64 {
+ s.develop_of(s.active().unwrap()).unwrap().light.exposure
+}
+
+fn list(s: &mut Session) -> (usize, Option<usize>) {
+ let h = s.execute("history.list", &json!({})).unwrap();
+ (h["history"].as_array().unwrap().len(), h["cursor"].as_u64().map(|c| c as usize))
+}
+
+/// A demo session with three exposure edits (1, 2, 3) as its latest History steps.
+fn three_edits() -> (Session, usize) {
+ let mut s = Session::with_demo();
+ for v in [1.0, 2.0, 3.0] {
+ s.execute("develop.set", &json!({"control": "light.exposure", "value": v})).unwrap();
+ }
+ let (n, cursor) = list(&mut s);
+ assert_eq!(cursor, Some(n - 1), "the cursor starts at the latest step");
+ (s, n)
+}
+
+#[test]
+fn going_back_adds_no_step_and_forward_returns() {
+ let (mut s, n) = three_edits();
+ s.execute("history.restore", &json!({"index": n - 3})).unwrap();
+ assert_eq!(exposure(&s), 1.0);
+ assert_eq!(list(&mut s), (n, Some(n - 3)), "no new step; later steps kept");
+ s.execute("history.next", &json!({})).unwrap();
+ assert_eq!(exposure(&s), 2.0);
+ s.execute("history.restore", &json!({"index": n - 1})).unwrap();
+ assert_eq!(exposure(&s), 3.0);
+ assert_eq!(list(&mut s), (n, Some(n - 1)));
+ assert!(s.execute("history.next", &json!({})).is_err(), "nothing after the latest step");
+ s.execute("history.previous", &json!({})).unwrap();
+ assert_eq!((exposure(&s), list(&mut s)), (2.0, (n, Some(n - 2))));
+ assert!(s.execute("history.restore", &json!({"index": n})).is_err());
+ assert!(s.execute("history.restore", &json!({"index": -1})).is_err());
+}
+
+#[test]
+fn a_new_edit_behind_the_end_drops_the_later_steps() {
+ let (mut s, n) = three_edits();
+ s.execute("history.restore", &json!({"index": n - 3})).unwrap();
+ s.execute("develop.set", &json!({"control": "light.exposure", "value": -1.0})).unwrap();
+ assert_eq!(list(&mut s), (n - 1, Some(n - 2)), "steps 2 and 3 dropped, the new one appended");
+ assert_eq!(exposure(&s), -1.0);
+ // undo brings the dropped steps and the cursor back
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!((exposure(&s), list(&mut s)), (1.0, (n, Some(n - 3))));
+ s.execute("edit.redo", &json!({})).unwrap();
+ assert_eq!((exposure(&s), list(&mut s)), (-1.0, (n - 1, Some(n - 2))));
+}
+
+#[test]
+fn undo_and_redo_move_the_cursor_with_the_settings() {
+ let (mut s, n) = three_edits();
+ s.execute("history.restore", &json!({"index": n - 3})).unwrap();
+ s.execute("edit.undo", &json!({})).unwrap();
+ assert_eq!((exposure(&s), list(&mut s)), (3.0, (n, Some(n - 1))), "undoing a step move");
+ s.execute("edit.redo", &json!({})).unwrap();
+ assert_eq!((exposure(&s), list(&mut s)), (1.0, (n, Some(n - 3))));
+}
+
+#[test]
+fn clearing_history_resets_the_cursor() {
+ let (mut s, n) = three_edits();
+ s.execute("history.restore", &json!({"index": n - 2})).unwrap();
+ s.execute("history.clear", &json!({})).unwrap();
+ assert_eq!((exposure(&s), list(&mut s)), (2.0, (1, Some(0))));
+ assert_eq!(s.catalog.photo(s.active().unwrap()).unwrap().history_cursor, None);
+}
+
+#[test]
+fn the_cursor_survives_the_op_log_and_old_catalogs_load_at_the_end() {
+ let mut s = Session::with_demo();
+ let snap = s.catalog.to_snapshot();
+ let _ = s.drain_log();
+ for v in [1.0, 2.0] {
+ s.execute("develop.set", &json!({"control": "light.exposure", "value": v})).unwrap();
+ }
+ let (n, _) = list(&mut s);
+ s.execute("history.restore", &json!({"index": n - 2})).unwrap();
+ let log: String = s.drain_log().iter().map(lightcraft_catalog::Catalog::op_to_log_line).collect();
+ let mut c = lightcraft_catalog::Catalog::from_snapshot(&snap).unwrap();
+ c.replay(&log).unwrap();
+ assert_eq!(c.to_snapshot(), s.catalog.to_snapshot());
+ let id = s.active().unwrap();
+ assert_eq!(c.photo(id).unwrap().history_cursor, Some(n - 2));
+ // a photo written before the cursor existed has no `history_cursor` key: at the latest step
+ let mut v = serde_json::to_value(c.photo(id).unwrap()).unwrap();
+ v.as_object_mut().unwrap().remove("history_cursor");
+ let old: lightcraft_catalog::Photo = serde_json::from_value(v).unwrap();
+ assert_eq!((old.history_cursor, old.history_index()), (None, Some(n - 1)));
+}
diff --git a/crates/pipeline/src/spots.rs b/crates/pipeline/src/spots.rs
index 483f83f3c..f8b3fbbdf 100644
--- a/crates/pipeline/src/spots.rs
+++ b/crates/pipeline/src/spots.rs
@@ -247,8 +247,8 @@ fn fill_box(src: &mut [[f32; 3]], tgt: &[[f32; 3]], alpha: &[f32], bw: usize, bh
let flat: Vec<f32> = tgt.iter().flatten().copied().collect();
let out = lightcraft_inpaint::complete(bw, bh, 3, &flat, &hole, &lightcraft_inpaint::CompleteParams::default())
.unwrap_or_else(|| lightcraft_inpaint::membrane_fill(bw, bh, 3, &flat, &hole));
- for (d, v) in src.iter_mut().zip(out.chunks_exact(3)) {
- *d = [v[0], v[1], v[2]];
+ for (d, v) in src.iter_mut().zip(out.as_chunks::<3>().0) {
+ *d = *v;
}
}
diff --git a/crates/ui-egui/src/panels/right.rs b/crates/ui-egui/src/panels/right.rs
index 501a78c5e..a46ca332b 100644
--- a/crates/ui-egui/src/panels/right.rs
+++ b/crates/ui-egui/src/panels/right.rs
@@ -1105,6 +1105,23 @@ fn short_time(iso: &str) -> String {
}
}
+/// How a History row is drawn: the step the settings are at is highlighted, the steps after it
+/// (still there to return to until a new edit) are greyed out.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum HistoryRow {
+ Done,
+ Current,
+ Undone,
+}
+
+fn history_row(i: usize, cursor: Option<usize>) -> HistoryRow {
+ match cursor {
+ Some(c) if i == c => HistoryRow::Current,
+ Some(c) if i > c => HistoryRow::Undone,
+ _ => HistoryRow::Done,
+ }
+}
+
fn activity(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {
let Some(p) = app.session.catalog.photo(id).cloned() else { return };
header(ui, "History");
@@ -1113,19 +1130,24 @@ fn activity(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {
if p.history.is_empty() {
ui.label(egui::RichText::new(crate::i18n::tr("No edits yet.")).color(t.text_dim));
}
+ let cursor = p.history_index();
for (i, h) in p.history.iter().enumerate().rev() {
let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 24.0), Sense::click());
register(ui.ctx(), format!("history:{i}"), r);
- if resp.hovered() {
+ let row = history_row(i, cursor);
+ if row == HistoryRow::Current {
+ ui.painter().rect_filled(r, 3.0, t.pressed);
+ } else if resp.hovered() {
ui.painter().rect_filled(r, 3.0, t.hover);
}
- paint(ui.painter(), Rect::from_min_size(r.min + vec2(0.0, 4.0), vec2(16.0, 16.0)), Icon::Clock, t.icon);
+ let (icon, text) = if row == HistoryRow::Undone { (t.text_disabled, t.text_disabled) } else { (t.icon, t.text_label) };
+ paint(ui.painter(), Rect::from_min_size(r.min + vec2(0.0, 4.0), vec2(16.0, 16.0)), Icon::Clock, icon);
ui.painter().text(
pos2(r.left() + 24.0, r.center().y),
Align2::LEFT_CENTER,
crate::i18n::history_label(&h.label, &app.session.presets),
t.font(12.5),
- t.text_label,
+ text,
);
if resp.clicked() {
let _ = app.run("history.restore", json!({"index": i}));
@@ -1149,6 +1171,16 @@ fn activity(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {
#[cfg(test)]
mod tests {
+ // Feature: the History panel greys out the steps after the cursor
+ #[test]
+ fn history_rows_after_the_cursor_are_greyed() {
+ use super::{HistoryRow, history_row};
+ let rows: Vec<_> = (0..4).map(|i| history_row(i, Some(1))).collect();
+ assert_eq!(rows, [HistoryRow::Done, HistoryRow::Current, HistoryRow::Undone, HistoryRow::Undone]);
+ assert_eq!(history_row(3, Some(3)), HistoryRow::Current, "at the latest step nothing is greyed");
+ assert_eq!(history_row(0, None), HistoryRow::Done);
+ }
+
// Feature: the aspect button tells what is locked
#[test]
fn aspect_label_names_presets_in_either_orientation() {
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index 77ae26e4c..ae30c8d18 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -1,6 +1,6 @@
# Lightroom parity checklist
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** minor (rapid slider entry; LR-PROF-CAMERACOLOR: tone curve from black-and-white camera JPEGs; LR-VIEW-ZOOM, LR-VIEW-COMPARE: Compare and Reference zoom windows; LR-IMP-FORMATS, LR-IMP-CAMERA-COVERAGE: EOS R5 Mark II CR3 decodes; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md; filesystem history retry/Undo/Redo evidence; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** minor (LR-VER-HISTORY, LRC-DEV-HISTORY: History cursor — going to a step adds no step, later steps stay until a new edit; rapid slider entry; LR-PROF-CAMERACOLOR: tone curve from black-and-white camera JPEGs; LR-VIEW-ZOOM, LR-VIEW-COMPARE: Compare and Reference zoom windows; LR-IMP-FORMATS, LR-IMP-CAMERA-COVERAGE: EOS R5 Mark II CR3 decodes; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md; filesystem history retry/Undo/Redo evidence; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6
The measured, row-by-row checklist: one row per Lightroom feature, menu item and shortcut, what we
have and what is missing. It answers *does the feature exist?* (feature breadth). Whether it is good
@@ -329,7 +329,7 @@ differences and missing bindings are in [ui-parity.md](ui-parity.md#shortcuts).
| LR-VER-CREATE | Create version | P1 | ✅ | `cmd:version.create` | |
| LR-VER-PANEL | Versions panel | P1 | ✅ | `cmd:panel.versions`, `cmd:version.create`, `cmd:version.restore`, `cmd:version.delete`, `cmd:version.rename`, `cmd:version.update`, `crates/ui-egui/src/panels/right.rs` (`versions`) | Named / Auto tabs, a thumbnail of each version's look, name and date, current marker; resting on a version previews it in the loupe; click restores, double-click renames; row menu (update, rename, set as before, delete). No automatic versions are created yet (LR-VER-AUTO) |
| LR-VER-AUTO | Automatic versions | P2 | ✅ | `crates/engine/src/lib.rs` (`auto_version`) | leaving an edited photo keeps its settings as an Auto version (when they differ from the latest version; 20 kept; not an undo step); Versions panel ▸ Auto |
-| LR-VER-HISTORY | Edit history | P1 | ✅ | `cmd:panel.activity`, `cmd:history.list`, `cmd:history.restore` | |
+| LR-VER-HISTORY | Edit history | P1 | ✅ | `cmd:panel.activity`, `cmd:history.list`, `cmd:history.restore`, `cmd:history.previous`, `cmd:history.next` | going to a step moves a per-photo cursor without adding a step; later steps stay listed (greyed) until a new edit drops them; `history.list` returns `cursor` |
| LR-VER-UNDO | Undo / redo | P0 | ✅ | `cmd:edit.undo`, `cmd:edit.redo` | |
## N. Copy / paste / sync (SYNC)
@@ -712,7 +712,7 @@ From `08-lightroom-classic-extras.md` (Classic-only features) and part 2 of `06-
| LRC-LIB-PREVIEWS | Build / discard previews | P1 | ✅ | `cmd:library.buildPreviews`, `cmd:library.previewProgress`, `cmd:library.cancelPreviews`, `cmd:library.clearPreviews`, `crates/engine/src/cmd/previews.rs`, `crates/preview/src/lib.rs` | File ▸ Previews: build standard-sized (Settings → Performance size) or 1:1 previews of the selected / visible photos in the background (a row in the activity stack, ✕ to stop), discard the cache; disk thumbnail + view cache; no smart previews (offline proxies) |
| LRC-LIB-SLIDESHOW-IMPROMPTU | Impromptu slideshow | P2 | ✅ | `cmd:view.slideshow` | see LR-VIEW-SLIDESHOW |
| LRC-DEV-SNAPSHOTS | Named snapshots | P1 | ✅ | `cmd:version.create`, `cmd:version.restore` | = versions |
-| LRC-DEV-HISTORY | Full history panel | P1 | ✅ | `cmd:history.list`, `cmd:history.restore`, `cmd:history.clear` | row menu: copy step to before, create version from step, clear history |
+| LRC-DEV-HISTORY | Full history panel | P1 | ✅ | `cmd:history.list`, `cmd:history.restore`, `cmd:history.previous`, `cmd:history.next`, `cmd:history.clear` | row menu: copy step to before, create version from step, clear history; clicking a step loads it without adding one (current step highlighted, later steps greyed and returnable until a new edit truncates them; one undo step; cursor saved in the catalog, old catalogs open at the latest step) |
| LRC-DEV-SOFTPROOF | Soft proofing | P2 | 🟡 | `cmd:view.softProof`, `crates/pipeline/src/output.rs` (`Proof`), `crates/ui-egui/src/panels/edit.rs` (`soft_proofing`) | S in the loupe (in grids S stays Expand/Collapse Stack): paper-white surround and "Proof Preview", proof profile (sRGB / Display P3 / Adobe RGB / ProPhoto / Rec. 2020), destination (red) and display (blue) gamut warnings (the display's gamut is the monitor profile's, `cmd:app.displayProfile`, else sRGB), Create Proof Copy (a named virtual copy). printer / paper ICC profiles can be loaded as the proof profile (size-capped, the last few kept), with rendering intent (Perceptual / Relative Colorimetric), Simulate Paper & Ink and a device-gamut warning (`crates/codecs/src/proof.rs`, `crates/engine/src/proof.rs`) |
| LRC-DEV-AUTOSYNC | Sync / auto sync / paste previous | P1 | ✅ | `cmd:develop.sync`, `cmd:develop.autoSync`, `cmd:develop.pastePrevious` | Edit ▸ Sync Settings / Auto Sync (⌥⇧⌘A): only the changed settings carry over, one undo step, slider drags sync on release, spots / red eye stay per photo; Edit panel banner |
| LRC-DEV-MATCHEXP | Match total exposures | P2 | ✅ | `cmd:develop.matchExposure` | Photo ▸ Match Total Exposures: the selected photos' Exposure set so shutter × ISO ÷ aperture² plus the slider matches the active photo's |
@@ -787,6 +787,7 @@ Latin stays upright. Advanced Japanese composition remains open. Regression cove
| Date | Change | Summary |
|---|---|---|
+| 2026-10-13 | minor | LR-VER-HISTORY, LRC-DEV-HISTORY: History cursor (go to a step without adding one; Previous/Next History Step) |
| 2026-10-11 | minor | KEY-SLIDER-TYPE: honor immediate Return/Escape and keep typed keys in the value editor; add regression references |
| 2026-10-11 | minor | LR-PROF-CAMERACOLOR: raws with a black-and-white camera JPEG take its tone curve (issue #577) |
| 2026-10-11 | minor | LR-VIEW-ZOOM and LR-VIEW-COMPARE: Compare and Reference are sharp at 1:1 (zoom windows per pane, two originals kept decoded while they are open); statuses unchanged |