monolith

public

Star0

Fork 0

Watch0

268 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `ab9ba6872885`

tarball

atagen <boss@atagen.co>2026-10-19 10:43 UTC

2 files changed+73-3

planner: finish vanishing windows before appearing ones grow

A closing window collapses to a seed inside its own full rect, and a window
spawned in the same retarget grows from a seed on that same line. They overlap
for real throughout any single set of phases, so Direct, AxisOrder, Lanes and
Grid all failed validation and plan() fell through to Pinch for the whole
output. When a plan would pinch and some window appears from an empty rect,
plan() now plans everything else first and grows the appearing windows
afterwards, which keeps the no-overlap check exact for visible windows.

Modified file: crates/planner/src/plan.rs+37 additions−3 deletions@@ -87,18 +87,52 @@ impl GroupPlan {
 }
 
 /// Plans the transition from `from` to `to`. Both slices index the same windows.
+/// When some windows appear while others vanish in the same place, no single
+/// set of phases keeps them apart, so the vanishing ones finish first.
+pub fn plan(from: &[Rect], to: &[Rect], cfg: &Config) -> Plan {
+    let direct = plan_once(from, to, cfg);
+    if !direct.groups.iter().any(|g| g.strategy == Strategy::Pinch) {
+        return direct;
+    }
+    staged(from, to, cfg).unwrap_or(direct)
+}
+
+/// Plans everything but the windows that appear, then lets those grow.
+/// A window that appears from a seed sits inside the space a vanishing one
+/// still fills, and the exact overlap check rejects growing into it.
+fn staged(from: &[Rect], to: &[Rect], cfg: &Config) -> Option<Plan> {
+    let appears = |i: usize| is_empty(&from[i], cfg) && !is_empty(&to[i], cfg);
+    if !(0..from.len()).any(appears) {
+        return None;
+    }
+    let mid: Vec<Rect> = (0..from.len())
+        .map(|i| if appears(i) { from[i] } else { to[i] })
+        .collect();
+    let (first, second) = (plan_once(from, &mid, cfg), plan_once(&mid, to, cfg));
+    let groups: Vec<Group> = first.groups.into_iter().chain(second.groups).collect();
+    if groups.iter().any(|g| g.strategy == Strategy::Pinch) {
+        return None;
+    }
+    let mut keyframes = first.keyframes;
+    keyframes.extend(second.keyframes.into_iter().skip(1));
+    Some(Plan { keyframes, groups })
+}
+
+fn is_empty(r: &Rect, cfg: &Config) -> bool {
+    r.w <= cfg.eps || r.h <= cfg.eps
+}
+
 /// Windows with no area at either end, like hidden ones held at their seed,
 /// jump straight to `to`. Planning them would let an invisible point inside
 /// a visible window join its group, or block every strategy and pinch.
-pub fn plan(from: &[Rect], to: &[Rect], cfg: &Config) -> Plan {
+fn plan_once(from: &[Rect], to: &[Rect], cfg: &Config) -> Plan {
     assert_eq!(
         from.len(),
         to.len(),
         "layouts must describe the same windows"
     );
-    let empty = |r: &Rect| r.w <= cfg.eps || r.h <= cfg.eps;
     let live: Vec<usize> = (0..from.len())
-        .filter(|&i| !(empty(&from[i]) && empty(&to[i])))
+        .filter(|&i| !(is_empty(&from[i], cfg) && is_empty(&to[i], cfg)))
         .collect();
     if live.len() == from.len() {
         return plan_live(from, to, cfg);

Modified file: crates/planner/src/tests.rs+36 additions@@ -236,6 +236,24 @@ proptest! {
     }
 
     #[test]
+    fn closing_while_spawning_never_pinches(seed in 1u64.., n in 2usize..9, edge in 0usize..3, direct: bool) {
+        let mut rng = Rng(seed);
+        let c = cfg(if direct { Style::Direct } else { Style::Orthogonal });
+        let a = random_layout(&mut rng, n);
+        let v = rng.below(n);
+        let at = [a[v].x - G / 2.0, a[v].center_x(), a[v].right() + G / 2.0][edge];
+        let line = Rect::new(at, a[v].y, 0.0, a[v].h);
+        let mut from = a.clone();
+        from.push(line);
+        let mut to = a.clone();
+        to[v] = Rect::new(a[v].center_x(), a[v].y, 0.0, a[v].h);
+        to.push(a[v]);
+        let p = plan(&from, &to, &c);
+        prop_assert!(validate(&p, &c).is_empty(), "{:?}", p);
+        prop_assert!(p.groups.iter().all(|g| g.strategy != Strategy::Pinch), "{:?}", p);
+    }
+
+    #[test]
     fn interrupts_replan_cleanly(seed in 1u64.., n in 2usize..9, at in 0.0f64..1.0, s in 0.0f64..1.0) {
         let mut rng = Rng(seed);
         let c = cfg(Style::Orthogonal);
@@ -266,3 +284,21 @@ fn hidden_seeds_stay_out_of_the_plan() {
     assert!(p.groups.iter().all(|g| !g.members.contains(&2)));
     assert!(p.keyframes.iter().all(|k| k[2] == to[2]));
 }
+
+/// A window closes in the slot where another opens. The ghost shrinks to a
+/// seed inside its own full rect while the newcomer grows from a seed on the
+/// same line, so no single set of phases keeps them apart and every strategy
+/// used to fail until the plan pinched the whole output.
+#[test]
+fn closing_and_spawning_in_one_slot_plan_in_stages() {
+    let c = cfg(Style::Orthogonal);
+    let t = cols(region(), 3);
+    let seed = Rect::new(600.0, 10.0, 0.0, 680.0);
+    let from = vec![t[0], t[1], t[2], seed];
+    let to = vec![t[0], seed, t[2], t[1]];
+    let p = plan(&from, &to, &c);
+    assert!(validate(&p, &c).is_empty(), "{p:?}");
+    assert!(p.groups.iter().all(|g| g.strategy != Strategy::Pinch));
+    assert_eq!(p.phases(), 2);
+    assert_eq!(p.keyframes[1], vec![t[0], seed, t[2], seed]);
+}

monolith

Commit ab9ba6872885

Commit `ab9ba6872885`