`92e1d14`

Add stacked overflow remediation

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 weeks ago

SHA: 92e1d140acce39acc344f0b90da4826e7a0543f3
Parents: ae35f6c
Tree: e1036a4

7 changed files

Status	File	+	-
M	`.gitignore`	1	0
M	`tarmac/src/config/lua.rs`	7	0
M	`tarmac/src/core/input.rs`	2	0
M	`tarmac/src/core/state.rs`	175	138
M	`tarmac/src/core/tree.rs`	375	2
M	`tarmac/src/main.rs`	33	6
M	`tarmacctl/src/main.rs`	1	0

.gitignoremodified


 .claude/
 CLAUDE.md
 .ref/
+.refs/
 AGENTS.md
 nohup.out

tarmac/src/config/lua.rsmodified

          "close" => Ok(Action::CloseWindow),
          "equalize" => Ok(Action::Equalize),
          "toggle_float" => Ok(Action::ToggleFloat),
++        "unstack" => Ok(Action::Unstack),
          "workspace_next" => Ok(Action::WorkspaceNext),
          "workspace_prev" => Ok(Action::WorkspacePrev),
          "focus_monitor_next" => Ok(Action::FocusMonitorNext),
              key: Key::Space,
              action: Action::ToggleFloat,
          },
++        LuaKeybind {
++            modifiers: ms,
++            key: Key::U,
++            action: Action::Unstack,
++        },
          // Focus
          LuaKeybind {
              modifiers: m,
          Action::WorkspaceNext => "workspace_next".to_string(),
          Action::WorkspacePrev => "workspace_prev".to_string(),
          Action::ToggleFloat => "toggle_float".to_string(),
++        Action::Unstack => "unstack".to_string(),
          Action::ToggleSpecial(name) => format!("toggle_special {name}"),
          Action::MoveToSpecial(name) => format!("move_to_special {name}"),
          Action::FocusMonitorNext => "focus_monitor_next".to_string(),

tarmac/src/core/input.rsmodified

      FocusMonitorPrev,                 // Focus previous monitor
      MoveToMonitorNext,                // Move window to next monitor
      MoveToMonitorPrev,                // Move window to previous monitor
++    Unstack,                          // Restore a stacked subtree to its saved BSP shape
      Reload,                           // Hot reload config
      Exit,                             // Clean exit
  }
          // Spawn / close
          mgr.add(m, Key::Return, Action::SpawnTerminal);
          mgr.add(ms, Key::Q, Action::CloseWindow);
++        mgr.add(ms, Key::U, Action::Unstack);
          // Focus: Option+hjkl and Option+Arrows
          mgr.add(m, Key::H, Action::Focus(Left));

tarmac/src/core/state.rsmodified

          self.ax_refs.get(&id)
+     }
++    fn workspace_render_geometries(&self, ws_idx: usize, rect: Rect) -> Vec<(WindowId, Rect)> {
++        let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
++        self.workspaces
++            .get(ws_idx)
++            .tree
++            .calculate_geometries_with_gaps(rect, gap_inner, gap_outer, true)
++    }
++
++    fn workspace_focus_geometries(&self, ws_idx: usize, rect: Rect) -> Vec<(WindowId, Rect)> {
++        let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
++        self.workspaces
++            .get(ws_idx)
++            .tree
++            .calculate_focus_geometries_with_gaps(rect, gap_inner, gap_outer, true)
++    }
++
      pub fn process_events(&mut self) {
          let events: Vec<QueuedEvent> = self.event_queue.borrow_mut().drain(..).collect();
          for queued in events {
              let ws_idx = monitor.active_workspace;
              let ws = self.workspaces.get(ws_idx);
              let screen_rect = self.monitor_rect(mi);
--            let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
++            let geometries = self.workspace_render_geometries(ws_idx, screen_rect);
--            let geometries =
--                ws.tree
--                    .calculate_geometries_with_gaps(screen_rect, gap_inner, gap_outer, true);
              tracing::debug!(monitor = mi, workspace = %ws.id, windows = geometries.len(),
                  sr_x = screen_rect.x, sr_y = screen_rect.y, sr_w = screen_rect.width,
                  sr_h = screen_rect.height, "apply_layout");
              let ws_idx = monitor.active_workspace;
              let ws = self.workspaces.get(ws_idx);
              let sr = self.monitor_rect(mi);
--            let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
++            let geoms = self.workspace_focus_geometries(ws_idx, sr);
--            let geoms = ws
--                .tree
--                .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
              let focused = ws.focused;
              for (wid, rect) in &geoms {
                  .monitor_showing_workspace(ws_idx)
                  .map(|mi| self.monitor_rect(mi))
                  .unwrap_or_else(|| self.focused_rect());
--            let (gap_inner, gap_outer) = self.workspace_gaps(ws_idx);
--
              // Phase 1: Swap oversized windows into larger tiles.
              // Batch all swaps using BSP geometry (no AX calls), then apply layout
              // once and settle. This is both faster (one layout instead of N) and
                      // Geometries are computed from the BSP tree (cheap, no AX).
                      // After batched swaps, tree geometry reflects the new layout
                      // even before apply_layout sends AX commands.
--                    let geometries = self
++                    let geometries = self.workspace_focus_geometries(ws_idx, screen_rect);
--                        .workspaces
--                        .get(ws_idx)
--                        .tree
--                        .calculate_geometries_with_gaps(screen_rect, gap_inner, gap_outer, true);
                      if geometries.is_empty() {
                          break;
+                     }
                  // settling. The settled set prevents ping-pong.
+             }
--            // Phase 2: Float remaining oversized windows locally.
++            // Phase 2: Replace the smallest conflicting subtree with a stack.
--            // Oversized windows should not silently migrate across workspaces;
--            // keep workspace membership stable and remediate in place.
              loop {
--                let geometries = self
++                let geometries = self.workspace_focus_geometries(ws_idx, screen_rect);
--                    .workspaces
--                    .get(ws_idx)
--                    .tree
--                    .calculate_geometries_with_gaps(screen_rect, gap_inner, gap_outer, true);
                  if geometries.is_empty() {
                      break;
+                 }
                      None => break,
                  };
--                tracing::info!(
++                if self.workspaces.get_mut(ws_idx).tree.make_stack_for_window(oversized_wid) {
--                    id = oversized_wid,
++                    tracing::info!(
--                    min_w,
++                        id = oversized_wid,
--                    min_h,
++                        min_w,
--                    ws = ws_idx + 1,
++                        min_h,
--                    "floating oversized window locally"
++                        ws = ws_idx + 1,
--                );
++                        "stacking oversized subtree locally"
--                self.workspaces
++                    );
--                    .get_mut(ws_idx)
++                    self.workspaces.get_mut(ws_idx).tree.set_stack_active(oversized_wid);
--                    .toggle_float(oversized_wid, screen_rect);
++                    self.apply_layout();
--                if let Some(ax_ref) = self.ax_refs.get(&oversized_wid) {
++                    std::thread::sleep(std::time::Duration::from_millis(50));
--                    let fx = screen_rect.x + (screen_rect.width - min_w) / 2.0;
++                } else {
--                    let fy = screen_rect.y + (screen_rect.height - min_h) / 2.0;
++                    break;
--                    let _ = ax_set_position(ax_ref, fx, fy);
--                    let _ = ax_set_size(ax_ref, min_w, min_h);
+                 }
--                self.apply_layout();
--                self.restack_floating_windows(ws_idx);
+             }
              processed.push(ws_idx);
          let ws = self.active_workspace();
          let focused = ws.focused;
          let sr = self.focused_rect();
--        let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
++
++        if let Some(from) = focused
++            && matches!(direction, Direction::Left | Direction::Right)
++            && let Some(next) = self
++                .active_workspace_mut()
++                .tree
++                .cycle_stack(from, matches!(direction, Direction::Right))
++        {
++            self.focus_window(next);
++            return;
++        }
          // Try intra-workspace navigation first (only if we have a focused window)
          if let Some(from) = focused {
--            let geoms = ws
++            let geoms = self.workspace_focus_geometries(self.active_ws_idx(), sr);
--                .tree
--                .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
              // Check if focused window is at the monitor edge in the requested
              // direction. If so, cross monitors instead of spiraling into the BSP tree.
          if let Some(new_mi) = new_mi {
              self.focused_monitor = new_mi;
              let target_sr = self.focused_rect();
--            let target_geoms = self
++            let target_geoms = self.workspace_focus_geometries(self.active_ws_idx(), target_sr);
--                .active_workspace()
--                .tree
--                .calculate_geometries_with_gaps(target_sr, gap_inner, gap_outer, true);
              if let Some(wid) =
                  Node::nearest_to_edge(&target_geoms, direction).or(self.active_workspace().focused)
              None => return,
          };
          let sr = self.focused_rect();
--        let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
++
--        let geoms = ws
++        if matches!(direction, Direction::Left | Direction::Right)
--            .tree
++            && let Some(next) = self
--            .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
++                .active_workspace_mut()
++                .tree
++                .reorder_stack(focused, matches!(direction, Direction::Right))
++        {
++            self.apply_layout();
++            self.focus_window(next);
++            return;
++        }
++
++        let geoms = self.workspace_focus_geometries(self.active_ws_idx(), sr);
          // Check if the focused window touches the monitor edge in the
          // requested direction. If so, skip intra-workspace swap and move
          // Record focus on the workspace that CONTAINS this window,
          // not the active workspace — during cross-monitor FFM the active
          // workspace might be different from the window's workspace.
--        let old_focused = if let Some(ws_idx) = self.workspaces.find_window(id) {
++        let (old_focused, stack_focus_changed) = if let Some(ws_idx) = self.workspaces.find_window(id) {
              let old = self.workspaces.get(ws_idx).focused;
              self.workspaces.get_mut(ws_idx).raise_floating(id);
++            let stack_changed = self.workspaces.get_mut(ws_idx).tree.set_stack_active(id);
              self.workspaces.get_mut(ws_idx).record_focus(id);
--            old
++            (old, stack_changed)
          } else {
              let old = self.active_workspace().focused;
              self.active_workspace_mut().raise_floating(id);
++            let stack_changed = self.active_workspace_mut().tree.set_stack_active(id);
              self.active_workspace_mut().record_focus(id);
--            old
++            (old, stack_changed)
          };
++        if stack_focus_changed {
++            self.apply_layout();
++        }
          self.enforce_floating_levels(id);
          // Update border colors on focus change
                  floating_hit
              } else {
                  // Check tiled windows within the overlay rect
--                let geoms = ws.tree.calculate_geometries_with_gaps(
++                let geoms = ws
--                    overlay_rect,
++                    .tree
--                    gap_inner,
++                    .calculate_geometries_with_gaps(overlay_rect, gap_inner, gap_outer, true);
--                    gap_outer,
--                    true,
--                );
                  geoms
                      .iter()
++                    .rev()
                      .find(|(_, rect)| rect.contains_point(x, y))
                      .map(|(id, _)| *id)
+             }
          } else {
              let ws = self.active_workspace();
--            let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
              // Check floating windows first -- they're visually on top
              let floating_under = ws
                  floating_under
              } else {
                  // Check tiled windows using gap-aware geometry matching actual layout
--                let geoms = ws.tree.calculate_geometries_with_gaps(
++                let geoms =
--                    self.focused_rect(),
++                    self.workspace_render_geometries(self.active_ws_idx(), self.focused_rect());
--                    gap_inner,
--                    gap_outer,
--                    true,
--                );
                  geoms
                      .iter()
++                    .rev()
                      .find(|(_, rect)| rect.contains_point(x, y))
                      .map(|(id, _)| *id)
+             }
+         }
+     }
++    pub fn unstack_focused(&mut self) {
++        let focused = match self.effective_focused() {
++            Some(f) => f,
++            None => return,
++        };
++
++        let Some(ws_idx) = self.workspaces.find_window(focused) else {
++            return;
++        };
++
++        if self.workspaces.get_mut(ws_idx).tree.unstack(focused) {
++            self.apply_layout();
++            self.focus_window(focused);
++            tracing::info!(id = focused, "restored stacked subtree");
++        }
++    }
++
      pub fn click_to_focus(&mut self, x: f64, y: f64) {
          let ws = self.active_workspace();
--        let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
          // Check floating first
          let floating_hit = ws
          let id = if let Some(fid) = floating_hit {
              Some(fid)
          } else {
--            let geoms = ws.tree.calculate_geometries_with_gaps(
++            let geoms = self.workspace_render_geometries(self.active_ws_idx(), self.focused_rect());
--                self.focused_rect(),
--                gap_inner,
--                gap_outer,
--                true,
--            );
              geoms
                  .iter()
++                .rev()
                  .find(|(_, rect)| rect.contains_point(x, y))
                  .map(|(id, _)| *id)
          };
                  // Warp to the focused WINDOW center (not monitor center)
                  if self.mouse_follows_focus {
                      let sr = self.focused_rect();
--                    let (gap_inner, gap_outer) = self.workspace_gaps(target_idx);
++                    let geoms = self.workspace_focus_geometries(target_idx, sr);
--                    let geoms = self
--                        .workspaces
--                        .get(target_idx)
--                        .tree
--                        .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
                      if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {
                          warp_mouse_to_center(rect);
                      } else {
              self.focus_window(wid);
              if self.mouse_follows_focus {
                  let sr = self.focused_rect();
--                let (gap_inner, gap_outer) = self.workspace_gaps(target_idx);
++                let geoms = self.workspace_focus_geometries(target_idx, sr);
--                let geoms = self
--                    .workspaces
--                    .get(target_idx)
--                    .tree
--                    .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
                  if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {
                      warp_mouse_to_center(rect);
                  } else {
              self.focus_window(wid);
              if self.mouse_follows_focus {
                  let sr = self.focused_rect();
--                let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
++                let geoms = self.workspace_focus_geometries(self.active_ws_idx(), sr);
--                let geoms = self
--                    .active_workspace()
--                    .tree
--                    .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
                  if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {
                      warp_mouse_to_center(rect);
                  } else {
              self.focus_window(wid);
              if self.mouse_follows_focus {
                  let sr = self.focused_rect();
--                let (gap_inner, gap_outer) = self.workspace_gaps(self.active_ws_idx());
++                let geoms = self.workspace_focus_geometries(self.active_ws_idx(), sr);
--                let geoms = self
--                    .active_workspace()
--                    .tree
--                    .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
                  if let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == wid) {
                      warp_mouse_to_center(rect);
                  } else {
+     }
      /// After moving a window to a specific workspace, try swaps to fix overflow.
--    /// If no swap works, float the window centered instead of evicting.
++    /// If no swap works, replace the smallest conflicting subtree with a stack.
      /// Only runs when the target workspace is visible — hidden workspaces have
      /// stale window sizes and will be checked when switched to.
      fn fix_oversized_on_target(&mut self, ws_idx: usize, moved_wid: super::window::WindowId) {
          std::thread::sleep(std::time::Duration::from_millis(100));
          // Check if the moved window actually overflows
--        let geometries = self
++        let geometries = self.workspace_focus_geometries(ws_idx, screen_rect);
--            .workspaces
--            .get(ws_idx)
--            .tree
--            .calculate_geometries_with_gaps(
--                screen_rect,
--                self.workspace_gaps(ws_idx).0,
--                self.workspace_gaps(ws_idx).1,
--                true,
--            );
          let (_min_w, _min_h) = match geometries.iter().find(|(wid, _)| *wid == moved_wid) {
              Some((_, rect)) => {
          // Try swaps with settled-set logic (same as fix_oversized_windows phase 1)
          let mut settled: Vec<super::window::WindowId> = Vec::new();
          loop {
--            let geoms = self
++            let geoms = self.workspace_focus_geometries(ws_idx, screen_rect);
--                .workspaces
--                .get(ws_idx)
--                .tree
--                .calculate_geometries_with_gaps(
--                    screen_rect,
--                    self.workspace_gaps(ws_idx).0,
--                    self.workspace_gaps(ws_idx).1,
--                    true,
--                );
              if geoms.is_empty() {
                  break;
+             }
                  self.apply_layout();
                  settled.push(ow);
              } else {
--                // No swap possible — float this window centered
++                if self.workspaces.get_mut(ws_idx).tree.make_stack_for_window(ow) {
--                tracing::info!(
++                    tracing::info!(
--                    id = ow,
++                        id = ow,
--                    min_w = ow_min_w,
++                        min_w = ow_min_w,
--                    min_h = ow_min_h,
++                        min_h = ow_min_h,
--                    ws = ws_idx + 1,
++                        ws = ws_idx + 1,
--                    "floating oversized window on target workspace"
++                        "stacking oversized subtree on target workspace"
--                );
++                    );
--                self.workspaces
++                    self.workspaces.get_mut(ws_idx).tree.set_stack_active(ow);
--                    .get_mut(ws_idx)
++                    self.apply_layout();
--                    .toggle_float(ow, screen_rect);
++                    std::thread::sleep(std::time::Duration::from_millis(50));
--                if let Some(ax_ref) = self.ax_refs.get(&ow) {
++                } else {
--                    let fx = screen_rect.x + (screen_rect.width - ow_min_w) / 2.0;
++                    break;
--                    let fy = screen_rect.y + (screen_rect.height - ow_min_h) / 2.0;
--                    let _ = ax_set_position(ax_ref, fx, fy);
--                    let _ = ax_set_size(ax_ref, ow_min_w, ow_min_h);
+                 }
--                use crate::platform::skylight::{K_CG_FLOATING_WINDOW_LEVEL, set_window_level};
--                set_window_level(ow, K_CG_FLOATING_WINDOW_LEVEL);
--                self.apply_layout();
--                // Continue checking — other windows may still overflow
+             }
+         }
+     }
                      // Record on the workspace that contains this window,
                      // not the active workspace (same fix as focus_window_impl)
                      if let Some(ws_idx) = self.workspaces.find_window(id) {
++                        self.workspaces.get_mut(ws_idx).tree.set_stack_active(id);
                          self.workspaces.get_mut(ws_idx).record_focus(id);
+                     }
+                 }
  mod tests {
      use super::*;
      use crate::core::monitor::Monitor;
++    use crate::core::tree::Direction;
      #[test]
      fn hide_anchor_frame_defaults_without_monitors() {
          state.sync_workspace_visibility();
          assert!(!state.is_window_hidden(123));
+     }
++
++    #[test]
++    fn focus_direction_cycles_stacked_windows_left_right() {
++        let mut state = WmState::new();
++        state.monitors = vec![Monitor {
++            id: 42,
++            frame: Rect::new(0.0, 0.0, 1920.0, 1080.0),
++            usable_frame: Rect::new(0.0, 33.0, 1920.0, 1047.0),
++            is_primary: true,
++            active_workspace: 0,
++        }];
++        state.sync_workspace_visibility();
++        let screen = state.monitors[0].usable_frame;
++
++        {
++            let ws = state.workspaces.get_mut(0);
++            ws.tree.insert_with_rect(1, None, screen);
++            ws.tree.insert_with_rect(2, Some(1), screen);
++            ws.tree.insert_with_rect(3, Some(2), screen);
++            assert!(ws.tree.make_stack_for_window(3));
++            ws.tree.set_stack_active(3);
++            ws.record_focus(3);
++        }
++
++        state.focus_direction(Direction::Left);
++        assert_eq!(state.active_workspace().focused, Some(2));
++
++        state.focus_direction(Direction::Right);
++        assert_eq!(state.active_workspace().focused, Some(3));
++    }
++
++    #[test]
++    fn unstack_focused_restores_original_tree() {
++        let mut state = WmState::new();
++        state.monitors = vec![Monitor {
++            id: 42,
++            frame: Rect::new(0.0, 0.0, 1920.0, 1080.0),
++            usable_frame: Rect::new(0.0, 33.0, 1920.0, 1047.0),
++            is_primary: true,
++            active_workspace: 0,
++        }];
++        state.sync_workspace_visibility();
++        let screen = state.monitors[0].usable_frame;
++
++        let original = {
++            let ws = state.workspaces.get_mut(0);
++            ws.tree.insert_with_rect(1, None, screen);
++            ws.tree.insert_with_rect(2, Some(1), screen);
++            ws.tree.insert_with_rect(3, Some(2), screen);
++            let original = ws.tree.clone();
++            assert!(ws.tree.make_stack_for_window(3));
++            ws.tree.set_stack_active(3);
++            ws.record_focus(3);
++            original
++        };
++
++        state.unstack_focused();
++        assert_eq!(state.active_workspace().tree, original);
++    }
+ }

tarmac/src/core/tree.rsmodified

+     }
+ }
--#[derive(Debug, Clone)]
++const STACK_REVEAL_OFFSET: f64 = 24.0;
++
++#[derive(Debug, Clone, PartialEq)]
  pub enum Node {
      Internal {
          split: SplitDirection,
          left: Box<Node>,
          right: Box<Node>,
      },
++    Stack {
++        windows: Vec<WindowId>,
++        active: usize,
++        previous: Box<Node>,
++    },
      Leaf {
          window: Option<WindowId>,
      },
          matches!(self, Node::Leaf { window: None })
+     }
++    pub fn slot_count(&self) -> usize {
++        match self {
++            Node::Leaf { window: Some(_) } => 1,
++            Node::Leaf { window: None } => 0,
++            Node::Stack { windows, .. } => usize::from(!windows.is_empty()),
++            Node::Internal { left, right, .. } => left.slot_count() + right.slot_count(),
++        }
++    }
++
      pub fn window_count(&self) -> usize {
          match self {
              Node::Leaf { window: Some(_) } => 1,
              Node::Leaf { window: None } => 0,
++            Node::Stack { windows, .. } => windows.len(),
              Node::Internal { left, right, .. } => left.window_count() + right.window_count(),
+         }
+     }
          match self {
              Node::Leaf { window: Some(w) } => vec![*w],
              Node::Leaf { window: None } => vec![],
++            Node::Stack { windows, .. } => windows.clone(),
              Node::Internal { left, right, .. } => {
                  let mut ws = left.windows();
                  ws.extend(right.windows());
          match self {
              Node::Leaf { window: Some(w) } => *w == window,
              Node::Leaf { window: None } => false,
++            Node::Stack { windows, .. } => windows.contains(&window),
              Node::Internal { left, right, .. } => left.contains(window) || right.contains(window),
+         }
+     }
      pub fn first_window(&self) -> Option<WindowId> {
          match self {
              Node::Leaf { window } => *window,
++            Node::Stack {
++                windows, active, ..
++            } => windows.get(*active).copied().or_else(|| windows.first().copied()),
              Node::Internal { left, right, .. } => {
                  left.first_window().or_else(|| right.first_window())
+             }
                      right.insert_with_rect(new_window, None, right_rect);
+                 }
+             }
++            Node::Stack {
++                windows,
++                active,
++                previous,
++            } => {
++                let insert_at = target
++                    .and_then(|target_window| windows.iter().position(|wid| *wid == target_window))
++                    .map(|idx| idx + 1)
++                    .unwrap_or_else(|| (*active + 1).min(windows.len()));
++                windows.insert(insert_at, new_window);
++                *active = insert_at;
++                previous.insert_with_rect(new_window, target, rect);
++            }
+         }
+     }
                  true
+             }
              Node::Leaf { .. } => false,
++            Node::Stack {
++                windows,
++                active,
++                previous,
++            } => {
++                let Some(idx) = windows.iter().position(|wid| *wid == window) else {
++                    return false;
++                };
++                windows.remove(idx);
++                previous.remove(window);
++
++                if windows.is_empty() {
++                    *self = Node::empty();
++                } else if windows.len() == 1 {
++                    *self = Node::Leaf {
++                        window: windows.first().copied(),
++                    };
++                } else if *active >= windows.len() {
++                    *active = windows.len() - 1;
++                } else if idx < *active {
++                    *active -= 1;
++                }
++                true
++            }
              Node::Internal { left, right, .. } => {
                  if left.remove(window) {
                      if left.is_empty() {
          self.calculate_geometries_with_gaps(rect, 0.0, 0.0, true)
+     }
++    pub fn calculate_focus_geometries(&self, rect: Rect) -> Vec<(WindowId, Rect)> {
++        self.calculate_focus_geometries_with_gaps(rect, 0.0, 0.0, true)
++    }
++
      /// Calculate geometries with inner and outer gaps.
      /// `gap_outer` is applied to the root rect edges.
      /// `gap_inner` is the space between adjacent windows (half applied to each side).
          match self {
              Node::Leaf { window: Some(w) } => vec![(*w, padded)],
              Node::Leaf { window: None } => vec![],
++            Node::Stack {
++                windows, active, ..
++            } => {
++                let active_window = windows.get(*active).copied();
++                let mut geoms = Vec::with_capacity(windows.len());
++                let mut depth = 0usize;
++                for (idx, wid) in windows.iter().enumerate() {
++                    if Some(*wid) == active_window {
++                        continue;
++                    }
++                    depth += 1;
++                    geoms.push((
++                        *wid,
++                        Rect::new(
++                            padded.x + STACK_REVEAL_OFFSET * depth as f64,
++                            padded.y,
++                            padded.width,
++                            padded.height,
++                        ),
++                    ));
++                    if idx == *active {
++                        depth = depth.saturating_sub(1);
++                    }
++                }
++                if let Some(wid) = active_window {
++                    geoms.push((wid, padded));
++                }
++                geoms
++            }
              Node::Internal {
                  split,
                  ratio,
+         }
+     }
++    pub fn calculate_focus_geometries_with_gaps(
++        &self,
++        rect: Rect,
++        gap_inner: f64,
++        gap_outer: f64,
++        is_root: bool,
++    ) -> Vec<(WindowId, Rect)> {
++        let padded = if is_root && gap_outer > 0.0 {
++            Rect::new(
++                rect.x + gap_outer,
++                rect.y + gap_outer,
++                (rect.width - 2.0 * gap_outer).max(0.0),
++                (rect.height - 2.0 * gap_outer).max(0.0),
++            )
++        } else {
++            rect
++        };
++
++        match self {
++            Node::Leaf { window: Some(w) } => vec![(*w, padded)],
++            Node::Leaf { window: None } => vec![],
++            Node::Stack {
++                windows, active, ..
++            } => windows
++                .get(*active)
++                .copied()
++                .map(|wid| vec![(wid, padded)])
++                .unwrap_or_default(),
++            Node::Internal {
++                split,
++                ratio,
++                left,
++                right,
++            } => {
++                let half_gap = gap_inner / 2.0;
++                let (mut left_rect, mut right_rect) = padded.split(*split, *ratio);
++
++                if gap_inner > 0.0 {
++                    match split {
++                        SplitDirection::Vertical => {
++                            left_rect.width = (left_rect.width - half_gap).max(0.0);
++                            right_rect.x += half_gap;
++                            right_rect.width = (right_rect.width - half_gap).max(0.0);
++                        }
++                        SplitDirection::Horizontal => {
++                            left_rect.height = (left_rect.height - half_gap).max(0.0);
++                            right_rect.y += half_gap;
++                            right_rect.height = (right_rect.height - half_gap).max(0.0);
++                        }
++                    }
++                }
++
++                let mut geoms = left.calculate_focus_geometries_with_gaps(
++                    left_rect, gap_inner, gap_outer, false,
++                );
++                geoms.extend(right.calculate_focus_geometries_with_gaps(
++                    right_rect, gap_inner, gap_outer, false,
++                ));
++                geoms
++            }
++        }
++    }
++
      /// Equalize all split ratios to 0.5.
      pub fn equalize(&mut self) {
          if let Node::Internal {
+                 }
+             }
              Node::Leaf { window: None } => {}
++            Node::Stack {
++                windows,
++                active,
++                previous,
++            } => {
++                if let Some(w) = windows.iter_mut().find(|w| **w == a) {
++                    *w = b;
++                    *found_a = true;
++                } else if let Some(w) = windows.iter_mut().find(|w| **w == b) {
++                    *w = a;
++                    *found_b = true;
++                }
++                if let Some(current) = windows.get(*active).copied() {
++                    if current == a {
++                        *active = windows.iter().position(|wid| *wid == b).unwrap_or(*active);
++                    } else if current == b {
++                        *active = windows.iter().position(|wid| *wid == a).unwrap_or(*active);
++                    }
++                }
++                previous.swap_impl(a, b, found_a, found_b);
++            }
              Node::Internal { left, right, .. } => {
                  left.swap_impl(a, b, found_a, found_b);
                  right.swap_impl(a, b, found_a, found_b);
      /// Resize the split affecting a window in the given direction.
      pub fn resize(&mut self, window: WindowId, direction: Direction, delta: f32) -> bool {
          match self {
--            Node::Leaf { .. } => false,
++            Node::Leaf { .. } | Node::Stack { .. } => false,
              Node::Internal {
                  split,
                  ratio,
+             }
+         }
+     }
++
++    pub fn set_stack_active(&mut self, window: WindowId) -> bool {
++        match self {
++            Node::Stack {
++                windows,
++                active,
++                previous: _,
++            } => {
++                if let Some(idx) = windows.iter().position(|wid| *wid == window) {
++                    *active = idx;
++                    true
++                } else {
++                    false
++                }
++            }
++            Node::Internal { left, right, .. } => {
++                left.set_stack_active(window) || right.set_stack_active(window)
++            }
++            Node::Leaf { .. } => false,
++        }
++    }
++
++    pub fn stack_info(&self, window: WindowId) -> Option<(Vec<WindowId>, usize)> {
++        match self {
++            Node::Stack {
++                windows, active, ..
++            } if windows.contains(&window) => Some((windows.clone(), *active)),
++            Node::Internal { left, right, .. } => left
++                .stack_info(window)
++                .or_else(|| right.stack_info(window)),
++            _ => None,
++        }
++    }
++
++    pub fn cycle_stack(&mut self, window: WindowId, forward: bool) -> Option<WindowId> {
++        match self {
++            Node::Stack {
++                windows, active, ..
++            } if windows.contains(&window) => {
++                if windows.is_empty() {
++                    return None;
++                }
++                let len = windows.len();
++                *active = if forward {
++                    (*active + 1) % len
++                } else if *active == 0 {
++                    len - 1
++                } else {
++                    *active - 1
++                };
++                windows.get(*active).copied()
++            }
++            Node::Internal { left, right, .. } => left
++                .cycle_stack(window, forward)
++                .or_else(|| right.cycle_stack(window, forward)),
++            _ => None,
++        }
++    }
++
++    pub fn reorder_stack(&mut self, window: WindowId, forward: bool) -> Option<WindowId> {
++        match self {
++            Node::Stack {
++                windows,
++                active,
++                previous,
++            } if windows.contains(&window) => {
++                let idx = windows.iter().position(|wid| *wid == window)?;
++                let swap_idx = if forward {
++                    if idx + 1 < windows.len() {
++                        idx + 1
++                    } else {
++                        0
++                    }
++                } else if idx == 0 {
++                    windows.len() - 1
++                } else {
++                    idx - 1
++                };
++                windows.swap(idx, swap_idx);
++                *active = swap_idx;
++                previous.swap(window, windows[idx]);
++                windows.get(*active).copied()
++            }
++            Node::Internal { left, right, .. } => left
++                .reorder_stack(window, forward)
++                .or_else(|| right.reorder_stack(window, forward)),
++            _ => None,
++        }
++    }
++
++    pub fn unstack(&mut self, window: WindowId) -> bool {
++        match self {
++            Node::Stack {
++                windows, previous, ..
++            } if windows.contains(&window) => {
++                *self = (**previous).clone();
++                true
++            }
++            Node::Internal { left, right, .. } => left.unstack(window) || right.unstack(window),
++            _ => false,
++        }
++    }
++
++    pub fn make_stack_for_window(&mut self, window: WindowId) -> bool {
++        self.make_stack_for_window_impl(window)
++    }
++
++    fn make_stack_for_window_impl(&mut self, window: WindowId) -> bool {
++        match self {
++            Node::Internal { left, right, .. } => {
++                let left_contains = left.contains(window);
++                let right_contains = right.contains(window);
++                if !left_contains && !right_contains {
++                    return false;
++                }
++
++                let child_contains = if left_contains { left } else { right };
++                if !matches!(child_contains.as_ref(), Node::Stack { .. })
++                    && child_contains.slot_count() > 1
++                    && child_contains.make_stack_for_window_impl(window)
++                {
++                    return true;
++                }
++
++                if self.slot_count() > 1 {
++                    let previous = self.clone();
++                    let windows = self.windows();
++                    let active = windows.iter().position(|wid| *wid == window).unwrap_or(0);
++                    *self = Node::Stack {
++                        windows,
++                        active,
++                        previous: Box::new(previous),
++                    };
++                    true
++                } else {
++                    false
++                }
++            }
++            _ => false,
++        }
++    }
+ }
  #[cfg(test)]
              );
+         }
+     }
++
++    #[test]
++    fn make_stack_for_window_replaces_smallest_conflicting_subtree() {
++        let mut tree = Node::empty();
++        tree.insert_with_rect(1, None, SCREEN);
++        tree.insert_with_rect(2, Some(1), SCREEN);
++        tree.insert_with_rect(3, Some(2), SCREEN);
++
++        assert!(tree.make_stack_for_window(3));
++        let stack = tree.stack_info(3).expect("window should be stacked");
++        assert_eq!(stack.0, vec![2, 3]);
++        assert_eq!(stack.1, 1);
++        assert!(tree.contains(1));
++    }
++
++    #[test]
++    fn stacked_render_geometries_reveal_background_windows() {
++        let mut tree = Node::empty();
++        tree.insert_with_rect(1, None, SCREEN);
++        tree.insert_with_rect(2, Some(1), SCREEN);
++        tree.insert_with_rect(3, Some(2), SCREEN);
++        assert!(tree.make_stack_for_window(3));
++
++        let geoms = tree.calculate_geometries(SCREEN);
++        let g2 = geoms.iter().find(|(wid, _)| *wid == 2).unwrap().1;
++        let g3 = geoms.iter().find(|(wid, _)| *wid == 3).unwrap().1;
++
++        assert!(g2.x > g3.x);
++        assert_eq!(g2.width, g3.width);
++        assert_eq!(g2.height, g3.height);
++    }
++
++    #[test]
++    fn unstack_restores_previous_subtree() {
++        let mut tree = Node::empty();
++        tree.insert_with_rect(1, None, SCREEN);
++        tree.insert_with_rect(2, Some(1), SCREEN);
++        tree.insert_with_rect(3, Some(2), SCREEN);
++        let original = tree.clone();
++
++        assert!(tree.make_stack_for_window(3));
++        assert!(tree.unstack(3));
++        assert_eq!(tree, original);
++    }
++
++    #[test]
++    fn removing_from_stack_collapses_to_leaf() {
++        let mut tree = Node::empty();
++        tree.insert_with_rect(1, None, SCREEN);
++        tree.insert_with_rect(2, Some(1), SCREEN);
++
++        assert!(tree.make_stack_for_window(2));
++        assert!(tree.remove(2));
++
++        assert!(matches!(tree, Node::Leaf { window: Some(1) }));
++    }
+ }

tarmac/src/main.rsmodified

                      });
+                 }
                  Action::ToggleFloat => state.toggle_float(),
++                Action::Unstack => state.unstack_focused(),
                  Action::ToggleSpecial(ref name) => state.toggle_special(name),
                  Action::MoveToSpecial(ref name) => state.move_to_special(name),
                  Action::FocusMonitorNext => {
  gar.bind("mod+shift+q", "close")
  gar.bind("mod+e", "equalize")
  gar.bind("mod+shift+space", "toggle_float")
++gar.bind("mod+shift+u", "unstack")
  -- Focus
  gar.bind("mod+h", "focus left")
                  state.equalize();
                  Response::ok_empty()
+             }
++            "unstack" => {
++                state.unstack_focused();
++                Response::ok_empty()
++            }
              "workspace" => {
                  if let Some(target) = request
                      .args
                          .map(|w| w.app_name.clone())
                          .unwrap_or_default();
                      let floating = state.active_workspace().is_floating(focused_id);
++                    let stack = state
++                        .active_workspace()
++                        .tree
++                        .stack_info(focused_id)
++                        .map(|(members, active)| {
++                            serde_json::json!({
++                                "members": members,
++                                "active_index": active,
++                                "active": members.get(active),
++                            })
++                        });
                      // Query live AX data for current title and geometry
                      let (title, x, y, width, height) =
                          "x": x, "y": y,
                          "width": width, "height": height,
                          "floating": floating,
++                        "stack": stack,
                          "workspace": state.active_workspace().id.to_string(),
                      }))
                  } else {
                      .monitor_showing_workspace(ws_idx)
                      .map(|mi| state.monitor_rect(mi))
                      .unwrap_or_else(|| state.focused_rect());
--                let geoms = ws.tree.calculate_geometries_with_gaps(
++                let (gap_inner, gap_outer) = state.workspace_gaps(ws_idx);
--                    sr,
++                let geoms = ws
--                    state.gap_inner,
++                    .tree
--                    state.gap_outer,
++                    .calculate_geometries_with_gaps(sr, gap_inner, gap_outer, true);
--                    true,
--                );
                  let windows: Vec<serde_json::Value> = geoms
                      .iter()
                      .map(|(wid, rect)| {
                              .get(*wid)
                              .map(|w| w.app_name.clone())
                              .unwrap_or_default();
++                        let stack = ws.tree.stack_info(*wid);
++                        let stack_index = stack
++                            .as_ref()
++                            .and_then(|(members, _)| members.iter().position(|id| *id == *wid));
++                        let stack_active = stack
++                            .as_ref()
++                            .map(|(members, active)| members.get(*active) == Some(wid))
++                            .unwrap_or(false);
                          serde_json::json!({
                              "id": wid,
                              "app_name": app_name,
                              "x": rect.x, "y": rect.y,
                              "width": rect.width, "height": rect.height,
++                            "stacked": stack.is_some(),
++                            "stack_index": stack_index,
++                            "stack_active": stack_active,
                          })
                      })
                      .collect();

tarmacctl/src/main.rsmodified


         eprintln!("  resize <left|right|up|down>   Resize split in direction");
         eprintln!("  close                         Close focused window");
         eprintln!("  equalize                      Equalize all splits");
+        eprintln!("  unstack                       Restore the focused stacked subtree");
         eprintln!("  workspace <1-10>              Switch workspace");
         eprintln!("  move-to-workspace <1-10>      Move window to workspace");
         eprintln!("  toggle-floating               Toggle floating state");

`@@ -15,5 +15,6 @@` docs/
15	.claude/	15	.claude/
16	CLAUDE.md	16	CLAUDE.md
17	.ref/	17	.ref/
		18	+.refs/
18	AGENTS.md	19	AGENTS.md
19	nohup.out	20	nohup.out

`@@ -38,6 +38,7 @@` fn main() {
38	eprintln!(" resize <left\|right\|up\|down> Resize split in direction");	38	eprintln!(" resize <left\|right\|up\|down> Resize split in direction");
39	eprintln!(" close Close focused window");	39	eprintln!(" close Close focused window");
40	eprintln!(" equalize Equalize all splits");	40	eprintln!(" equalize Equalize all splits");
		41	+ eprintln!(" unstack Restore the focused stacked subtree");
41	eprintln!(" workspace <1-10> Switch workspace");	42	eprintln!(" workspace <1-10> Switch workspace");
42	eprintln!(" move-to-workspace <1-10> Move window to workspace");	43	eprintln!(" move-to-workspace <1-10> Move window to workspace");
43	eprintln!(" toggle-floating Toggle floating state");	44	eprintln!(" toggle-floating Toggle floating state");