gardesk/tarmac / b9e6405

+            Node::Stack { windows, .. } => {

+                // All stack members share the tile's full rect. Non-active

+                // windows sit fully behind the active in z-order. The

+                // previous "Slack-style reveal" offset (origin += depth *

+                // STACK_REVEAL_OFFSET) leaked: the depth counter never

+                // reset past the active member, so windows iterated after

+                // the active in insertion order accumulated progressively

+                // larger offsets and visibly drifted away from the tile

+                // (user-reported as "the windows are not sized and

+                // positioned as if they are members of the stack").

+                windows.iter().map(|wid| (*wid, padded)).collect()

+    /// Replace the entire tree with a single root-level Stack containing

+    /// every window currently in the tree. Used as overflow remediation

+    /// during initial discovery: if even one window can't fit its tile in

+    /// the BSP layout we'd otherwise produce, just stack everything into

+    /// one tile so the user gets a clean, navigable layout instead of a

+    /// staircase with a partial stack at the bottom.

+    pub fn collapse_to_root_stack(&mut self, active_window: WindowId) -> bool {

+        match self {

+            Node::Internal { .. } => {

+                let previous = self.clone();

+                let windows = self.windows();

+                if windows.is_empty() {

+                    return false;

+                }

+                let active = windows

+                    .iter()

+                    .position(|wid| *wid == active_window)

+                    .unwrap_or(0);

+                *self = Node::Stack {

+                    windows,

+                    active,

+                    previous: Box::new(previous),

+                };

+                true

+            }

+            _ => false,

+        }

+    }

+

+    fn stacked_render_geometries_share_the_tile_rect() {

+        // All stack members occupy the full tile rect, regardless of

+        // which is active. Non-active windows sit fully behind the

+        // active in z-order — no Slack-style peek offset (removed:

+        // its depth counter accumulated past the active position

+        // and produced visibly drifting non-active windows).

+        for active in 0..3 {

+            let tree = Node::Stack {

+                windows: vec![1, 2, 3],

+                active,

+                previous: Box::new(Node::Leaf { window: Some(1) }),

+            };

+            let geoms = tree.calculate_geometries(SCREEN);

+            assert_eq!(geoms.len(), 3);

+            for (_, rect) in &geoms {

+                assert_eq!(rect.x, SCREEN.x);

+                assert_eq!(rect.y, SCREEN.y);

+                assert_eq!(rect.width, SCREEN.width);

+                assert_eq!(rect.height, SCREEN.height);

+            }

+        }