Commit 577710e1d47638bbd086a22366de263d858f4475 | snowbound

author	clover caruso <git@paperclover.net> 2026-10-02 12:52:24-07:00
committer	clover caruso <git@paperclover.net> 2026-10-02 13:41:33-07:00
log	577710e1d47638bbd086a22366de263d858f4475
tree	2c03317dcef272b0ef7c986aab8f918f9c13ff4f
parent	30964a9cc80080214547f04dcb744f23406dffd6
signature	Signed by SSH key SHA256:52mNGHRsVFBDED9IAX5pe+LRWUefqTbxEReunq21QvU

fix: Undo and Redo pressed while a page or action is on its way wait for it

Presses during an in-flight page action or page switch were dropped
(the command was disabled while busy), so quick Undo presses were lost
and the replay test undo_walks_back_through_new_pages_and_their_titles
flaked under load. They now queue and are taken in order once nothing
is on its way. An action that shows a page counts as switching until
it lands.

Replay gains `settle`, and `accessibility` waits for the same settled
state before writing the tree, so replay tests stop racing background
work.

Assisted-by: claude-opus-5.5

3 files changed, 87 insertions(+), 35 deletions(-)

crates
- snowbound
  - src
    main.rs
    undo.rs
  - tests
    replay.rs

crates/snowbound/src/main.rs+38-10

 @@ -363,8 +363,9 @@ enum Replay {
     Pinch(f32),
     /// Paints the next frame into a PNG as well as the window.
     Snapshot(PathBuf),
-    /// Writes the window's accessibility tree as text.
+    /// Waits for nothing to be on its way, then writes the window's accessibility tree as
-    Accessibility(PathBuf),
+    /// text where given, and answers.
+    Settle(Option<PathBuf>, std::sync::mpsc::Sender<()>),
     /// A frame during a wait, as a visible window's display would ask for.
     Tick,
     Appearance(winit::window::Theme),
 @@ -883,6 +884,9 @@ struct State {
     strip_held: bool,
     /// Where a replay asked the next frame to be written.
     snapshot: Option<PathBuf>,
+    /// A replay waiting for nothing to be on its way, and where it wants the accessibility
+    /// tree written then.
+    replay_settle: Option<(Option<PathBuf>, std::sync::mpsc::Sender<()>)>,
     /// `SNOWBOUND_FRAMES`: a directory every frame drawn is also written to, named by
     /// milliseconds since the window opened.
     frames: Option<(PathBuf, Instant)>,
 @@ -1226,6 +1230,7 @@ impl State {
             strip_press: None,
             strip_held: false,
             snapshot: None,
+            replay_settle: None,
             frames: std::env::var_os("SNOWBOUND_FRAMES").map(|dir| (dir.into(), Instant::now())),
             initial,
             initial_date,
 @@ -1286,6 +1291,9 @@ impl State {
         if let Err(error) = self.open_loaded() {
             eprintln!("{error}");
         }
+        if let Err(error) = self.take_waiting() {
+            eprintln!("{error}");
+        }
         lap("open", start);
         self.follow_reading();
         let size = self.window.inner_size();
 @@ -5706,11 +5714,7 @@ impl State {
                         }
                     }
                     Replay::Snapshot(path) => self.snapshot = Some(path),
-                    Replay::Accessibility(path) => {
+                    Replay::Settle(path, settled) => self.replay_settle = Some((path, settled)),
-                        if let Err(error) = self.write_accessibility(&path) {
-                            eprintln!("{error}");
-                        }
-                    }
                     Replay::Tick | Replay::Quit => {}
                     Replay::Appearance(appearance) => {
                         self.window.set_theme(Some(appearance));
 @@ -5726,6 +5730,16 @@ impl State {
                 if let Err(error) = self.frame() {
                     eprintln!("{error}");
                 }
+                if self.settled()
+                    && let Some((path, settled)) = self.replay_settle.take()
+                {
+                    if let Some(path) = path
+                        && let Err(error) = self.write_accessibility(&path)
+                    {
+                        eprintln!("{error}");
+                    }
+                    let _ = settled.send(());
+                }
             }
             #[cfg(not(target_arch = "wasm32"))]
             UserEvent::Accessibility(event) => self.access_event(event),
 @@ -6041,10 +6055,12 @@ fn write_png(path: &Path, size: [u32; 2], pixels: &[u8]) -> Result<(), Box<dyn E
 /// Feeds a development script to the window from another thread, one command per line
 /// in logical pixels: `move X Y`, `press [right]`, `release [right]`, `wheel DX DY`,
 /// `pressure LEVEL|none`, `pinch FACTOR`, `key NAME`, `type TEXT`, `modifiers [shift]
-/// [control] [command]`, `wait MILLISECONDS`, `snapshot PNG_PATH`, `accessibility TEXT_PATH`,
+/// [control] [command]`, `wait MILLISECONDS`, `snapshot PNG_PATH`, `settle` and
-/// `appearance light|dark`, `resize WIDTH HEIGHT` and `quit`.
+/// `accessibility TEXT_PATH` (which wait for what is on its way), `appearance light|dark`,
+/// `resize WIDTH HEIGHT` and `quit`.
 #[cfg(not(target_arch = "wasm32"))]
 fn replay(script: String, proxy: EventLoopProxy<UserEvent>) -> Result<(), Box<dyn Error>> {
+    let (settle, settled) = std::sync::mpsc::channel();
     let mut steps = Vec::new();
     for line in script.lines().filter(|line| !line.trim().is_empty()) {
         let (command, rest) = line.split_once(' ').unwrap_or((line, ""));
 @@ -6113,7 +6129,8 @@ fn replay(script: String, proxy: EventLoopProxy<UserEvent>) -> Result<(), Box<dy
                     .map_err(|_| "resize takes WIDTH HEIGHT")?,
             )),
             "snapshot" => Ok(Replay::Snapshot(rest.into())),
-            "accessibility" => Ok(Replay::Accessibility(rest.into())),
+            "settle" => Ok(Replay::Settle(None, settle.clone())),
+            "accessibility" => Ok(Replay::Settle(Some(rest.into()), settle.clone())),
             "appearance" => Ok(Replay::Appearance(match rest {
                 "light" => winit::window::Theme::Light,
                 "dark" => winit::window::Theme::Dark,
 @@ -6129,7 +6146,18 @@ fn replay(script: String, proxy: EventLoopProxy<UserEvent>) -> Result<(), Box<dy
                     if let Replay::Input(ui::Event::Button { at, .. }) = &mut replay {
                         *at = Instant::now();
                     }
+                    let settling = matches!(replay, Replay::Settle(..));
                     let _ = proxy.send_event(UserEvent::Replay(replay));
+                    // Frames tick until settled; a minute bounds a page that never lands.
+                    let start = Instant::now();
+                    while settling
+                        && start.elapsed().as_secs() < 60
+                        && settled
+                            .recv_timeout(std::time::Duration::from_micros(16_667))
+                            .is_err()
+                    {
+                        let _ = proxy.send_event(UserEvent::Replay(Replay::Tick));
+                    }
                 }
                 Err(duration) => {
                     // Ticks keep a 60 Hz display's pace, dropping those a slow frame missed.

crates/snowbound/src/undo.rs+48-24

 @@ -23,8 +23,10 @@ pub struct Timeline {
     redo: Vec<Step>,
     /// Editors of pages left holding history, the longest left first.
     parked: Vec<(ExGuid, CanvasEditor)>,
-    /// Actions on their way, while which Undo and Redo wait.
+    /// Actions on their way.
     busy: usize,
+    /// Presses of Undo, or Redo when true, that wait for an action or page on its way.
+    waiting: std::collections::VecDeque<bool>,
 }
 enum Step {
 @@ -185,9 +187,6 @@ impl Timeline {
         depth: [usize; 2],
         here: &Here,
     ) -> Option<Next> {
-        if self.busy > 0 {
-            return None;
-        }
         self.edited(page, depth, false);
         let steps = if redo { &mut self.redo } else { &mut self.undo };
         let at = steps.iter().rposition(|step| match step {
 @@ -235,10 +234,9 @@ impl Timeline {
     /// Whether Undo, or `redo` Redo, has an action to take `here`.
     pub fn reaches(&self, redo: bool, here: &Here) -> bool {
         let steps = if redo { &self.redo } else { &self.undo };
-        self.busy == 0
+        steps
-            && steps
+            .iter()
-                .iter()
+            .any(|step| matches!(step, Step::Action(action) if action.applies(here)))
-                .any(|step| matches!(step, Step::Action(action) if action.applies(here)))
     }
     /// Keeps the editor of page `page`, just left, for its history.
 @@ -815,21 +813,47 @@ impl State {
         })
     }
-    /// Whether Undo, or `redo` Redo, has something to take.
+    /// Whether no action, page or command is on its way, which Undo and Redo wait for.
+    pub(crate) fn settled(&self) -> bool {
+        self.undo.busy == 0 && self.switching.is_none() && self.commands.is_empty()
+    }
+    /// Whether Undo, or `redo` Redo, has something to take, or may once what is on its way
+    /// lands.
     pub(crate) fn can_step(&self, redo: bool) -> bool {
         let editor = &self.view.editor;
-        (if redo {
+        !self.settled()
-            editor.can_redo()
+            || (if redo {
-        } else {
+                editor.can_redo()
-            editor.can_undo()
+            } else {
-        }) || self
+                editor.can_undo()
-            .here()
+            })
-            .is_some_and(|here| self.undo.reaches(redo, &here))
+            || self
+                .here()
+                .is_some_and(|here| self.undo.reaches(redo, &here))
+    }
+    /// Undo, or `redo` Redo, once what is on its way lands.
+    pub(crate) fn step(&mut self, redo: bool) -> Result<(), Box<dyn Error>> {
+        self.undo.waiting.push_back(redo);
+        self.take_waiting()
+    }
+    /// Takes the Undo and Redo presses waiting, while nothing is on its way.
+    pub(crate) fn take_waiting(&mut self) -> Result<(), Box<dyn Error>> {
+        while self.settled()
+            && let Some(redo) = self.undo.waiting.pop_front()
+        {
+            if self.can_step(redo) {
+                self.take(redo)?;
+            }
+        }
+        Ok(())
     }
     /// Undo, or `redo` Redo: the open page's last edit or the last action made where the
     /// user is, whichever came last.
-    pub(crate) fn step(&mut self, redo: bool) -> Result<(), Box<dyn Error>> {
+    fn take(&mut self, redo: bool) -> Result<(), Box<dyn Error>> {
         self.persist()?;
         let depth = self.view.editor.history_depth();
         // A page kept in no notebook has only its own history.
 @@ -876,7 +900,7 @@ impl State {
                 .ok_or("That notebook is closed")?;
             let Some((structure, undo)) = restructuring(&library, &change) else {
                 return match taken {
-                    Some(redo) => self.step(redo),
+                    Some(redo) => self.take(redo),
                     None => Ok(()),
                 };
             };
 @@ -895,6 +919,7 @@ impl State {
         let shown = session.space;
         let proxy = self.proxy.clone();
         self.undo.busy += 1;
+        self.switching = Some((None, web_time::Instant::now()));
         self.load(move || {
             let applied = site.change(change, shown);
             let show = match &applied {
 @@ -908,7 +933,10 @@ impl State {
                 let Some(applied) = applied else {
                     // What it would change is gone: Undo goes on to the step before.
                     return match taken {
-                        Some(redo) if stale => state.step(redo),
+                        Some(redo) if stale => {
+                            state.undo.waiting.push_front(redo);
+                            Ok(())
+                        }
                         _ => Ok(()),
                     };
                 };
 @@ -1079,8 +1107,7 @@ mod tests {
         assert!(!timeline.reaches(false, &here()));
     }
-    /// Redo takes back the last undone first; a new edit ends what actions it held, and
+    /// Redo takes back the last undone first; a new edit ends what actions it held.
-    /// waits while an action is on its way.
     #[test]
     fn redo_mirrors_undo_and_new_edits_end_it() {
         let mut timeline = Timeline::default();
 @@ -1098,9 +1125,6 @@ mod tests {
         timeline.stepped(shown, true);
         timeline.stepped(shown, false);
         assert!(!timeline.reaches(true, &here()));
-        timeline.record(created(page(3)));
-        timeline.busy = 1;
-        assert!(timeline.next(false, shown, [0, 1], &here()).is_none());
     }
     const AUTHOR: &str = "Rust Author";

crates/snowbound/tests/replay.rs+1-1

...	@@ -205,7 +205,7 @@ fn undo_walks_back_through_new_pages_and_their_titles() {	...	@@ -205,7 +205,7 @@ fn undo_walks_back_through_new_pages_and_their_titles() {
205	let mut steps = Vec::new();	205	let mut steps = Vec::new();
206	for title in ["type One", "type Two"] {	206	for title in ["type One", "type Two"] {
207	steps.extend(chord("modifiers command", "key n"));	207	steps.extend(chord("modifiers command", "key n"));
208	steps.extend([title, "wait 300"].map(String::from));	208	steps.extend(["settle", title, "wait 300"].map(String::from));
209	}	209	}
210	steps.extend(chord("modifiers command control", "key Left"));	210	steps.extend(chord("modifiers command control", "key Left"));
211	steps.push("accessibility back".into());	211	steps.push("accessibility back".into());