From 0546dd58c6218c1498b22daf78040b320c6e6d4e Mon Sep 17 00:00:00 2001 From: SteamSmith <341182916+SteamSmith@users.noreply.github.com> Date: Thu, 5 Nov 2026 06:57:14 -0500 Subject: [PATCH] fix(engine): end undo merge runs at gesture and request boundaries merge_key was cleared only by edit/undo/redo/reset_history, so two drags of one slider, two "New random seed" clicks and two MCP/control node_param calls collapsed into one undo entry. Add Session::end_merge, call it on pointer release and around each control/MCP command, and restore the session when a merged edit fails. Co-Authored-By: Claude Sonnet 5.5 --- crates/automation/src/headless.rs | 10 ++++++- crates/automation/src/headless.test.rs | 16 ++++++++++ crates/engine/src/session.rs | 17 +++++++++-- crates/engine/src/session.test.rs | 41 ++++++++++++++++++++++++++ crates/ui-egui/src/control.rs | 6 +++- crates/ui-egui/src/lib.rs | 12 ++++++++ crates/ui-egui/src/lib.test.rs | 20 +++++++++++++ 7 files changed, 118 insertions(+), 4 deletions(-) create mode 100644 crates/automation/src/headless.test.rs create mode 100644 crates/engine/src/session.test.rs create mode 100644 crates/ui-egui/src/lib.test.rs diff --git a/crates/automation/src/headless.rs b/crates/automation/src/headless.rs index 93feac1..0fe1000 100644 --- a/crates/automation/src/headless.rs +++ b/crates/automation/src/headless.rs @@ -127,7 +127,11 @@ impl Headless { if !self.trusted() { authorize_command(id, ¶ms)?; } - Ok(materialcraft_engine::execute(&mut self.session, id, ¶ms)?) + // Each request is its own undo step, never merged with a neighbour's. + self.session.end_merge(); + let r = materialcraft_engine::execute(&mut self.session, id, ¶ms); + self.session.end_merge(); + Ok(r?) } /// Run `[{id, params?}]` in order, stopping at the first error (reported with its index). @@ -290,3 +294,7 @@ pub fn batch_reply(results: Vec, failed: Option<(usize, &str, String)>) - "failed": failed.map(|(index, id, error)| json!({ "index": index, "id": id, "error": error })), }) } + +#[cfg(test)] +#[path = "headless.test.rs"] +mod tests; diff --git a/crates/automation/src/headless.test.rs b/crates/automation/src/headless.test.rs new file mode 100644 index 0000000..dd39c1d --- /dev/null +++ b/crates/automation/src/headless.test.rs @@ -0,0 +1,16 @@ +#[cfg(test)] +mod end_merge_tests { + use crate::headless::{Filesystem, Headless}; + use serde_json::json; + + #[test] + fn two_param_requests_are_two_undo_steps() { + let mut h = Headless::new(Headless::default_session(), Filesystem::TrustedLocal); + h.command_run("file.new", json!({"template": "empty"})).unwrap(); + let id = h.command_run("graph.node.add", json!({"def": "levels"})).unwrap()["id"].as_u64().unwrap(); + let sets = |h: &Headless| h.session.history().iter().filter(|l| *l == "Set parameter").count(); + h.command_run("graph.node.param", json!({"id": id, "param": "in_low", "value": 0.3})).unwrap(); + h.command_run("graph.node.param", json!({"id": id, "param": "in_low", "value": 0.4})).unwrap(); + assert_eq!(sets(&h), 2, "separate requests must not merge"); + } +} diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs index 7dbdeae..c40a263 100644 --- a/crates/engine/src/session.rs +++ b/crates/engine/src/session.rs @@ -210,9 +210,12 @@ impl Session { /// make a single undo step. pub fn edit_merged(&mut self, key: &str, label: &str, f: impl FnOnce(&mut Session) -> Result) -> Result { if self.merge_key.as_deref() == Some(key) && !self.undo.is_empty() { + // The merged step keeps its original snapshot; restore the session if `f` fails. + let snap = self.snapshot(label); let r = f(self); - if r.is_ok() { - self.changed(); + match &r { + Ok(_) => self.changed(), + Err(_) => self.restore(snap), } return r; } @@ -223,6 +226,12 @@ impl Session { r } + /// End the current coalescing run: the next [`Session::edit_merged`] starts a new undo step. + /// Call it when a gesture ends (pointer release) and once per control or MCP request. + pub fn end_merge(&mut self) { + self.merge_key = None; + } + fn edit_inner(&mut self, label: &str, f: impl FnOnce(&mut Session) -> Result) -> Result { let snap = self.snapshot(label); match f(self) { @@ -402,3 +411,7 @@ impl Session { } } } + +#[cfg(test)] +#[path = "session.test.rs"] +mod tests; diff --git a/crates/engine/src/session.test.rs b/crates/engine/src/session.test.rs new file mode 100644 index 0000000..a3e5866 --- /dev/null +++ b/crates/engine/src/session.test.rs @@ -0,0 +1,41 @@ +#[cfg(test)] +mod merge_tests { + use crate::{EngineError, Session}; + + fn session() -> Session { + crate::sample_session() + } + + fn set(s: &mut Session, key: &str) { + s.edit_merged(key, "Set parameter", |s| { + s.modified = true; + Ok(()) + }) + .unwrap(); + } + + #[test] + fn same_key_merges_until_end_merge() { + let mut s = session(); + let base = s.history().len(); + set(&mut s, "k"); + set(&mut s, "k"); + assert_eq!(s.history().len(), base + 1, "one drag is one entry"); + s.end_merge(); + set(&mut s, "k"); + assert_eq!(s.history().len(), base + 2, "a second drag after end_merge is a new entry"); + } + + #[test] + fn failed_merged_edit_restores_the_session() { + let mut s = session(); + set(&mut s, "k"); + let name = s.pkg.name.clone(); + let r: Result<(), EngineError> = s.edit_merged("k", "Set parameter", |s| { + s.pkg.name = "half-applied".into(); + Err(EngineError::Other("boom".into())) + }); + assert!(r.is_err()); + assert_eq!(s.pkg.name, name); + } +} diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index 3970877..771d302 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -225,7 +225,11 @@ pub fn handle(app: &mut MaterialCraftApp, ctx: &egui::Context, method: &str, p: "command.run" => { let Some(id) = p.get("id").and_then(Value::as_str) else { return err("`id` is required") }; let params = p.get("params").cloned().unwrap_or(Value::Null); - match materialcraft_engine::execute(&mut app.session, id, ¶ms) { + // Each request is its own undo step, never merged with a neighbour's. + app.session.end_merge(); + let r = materialcraft_engine::execute(&mut app.session, id, ¶ms); + app.session.end_merge(); + match r { Ok(v) => ok(v), Err(e) => err(e), } diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 68aac01..cc625a1 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -263,11 +263,23 @@ impl MaterialCraftApp { function_editor::show(self, &ctx); toasts(self, &ctx); control::request_screenshots(self, &ctx); + end_gesture_if_released(&mut self.session, ctx.input(|i| i.pointer.any_released())); let dt = (now_ms() - t0) as f32; self.ui_ms = if self.ui_ms == 0.0 { dt } else { self.ui_ms * 0.9 + dt * 0.1 }; } } +/// A released pointer ends a gesture (slider drag, button click): the next edit is a new undo step. +pub(crate) fn end_gesture_if_released(session: &mut materialcraft_engine::Session, released: bool) { + if released { + session.end_merge(); + } +} + +#[cfg(test)] +#[path = "lib.test.rs"] +mod tests; + /// `Documents/MaterialCraft/` in the user's home folder. #[cfg(not(target_arch = "wasm32"))] pub fn user_dir(sub: &str) -> std::path::PathBuf { diff --git a/crates/ui-egui/src/lib.test.rs b/crates/ui-egui/src/lib.test.rs new file mode 100644 index 0000000..a385db6 --- /dev/null +++ b/crates/ui-egui/src/lib.test.rs @@ -0,0 +1,20 @@ +#[cfg(test)] +mod gesture_tests { + use crate::end_gesture_if_released; + + #[test] + fn pointer_release_ends_the_merge_run() { + let mut s = materialcraft_engine::sample_session(); + let base = s.history().len(); + let set = |s: &mut materialcraft_engine::Session| { + s.edit_merged("k", "Set parameter", |_| Ok(())).unwrap(); + }; + set(&mut s); + end_gesture_if_released(&mut s, false); + set(&mut s); + assert_eq!(s.history().len(), base + 1, "still dragging: merged"); + end_gesture_if_released(&mut s, true); + set(&mut s); + assert_eq!(s.history().len(), base + 2, "released: a new step"); + } +}