refactor(tab): move tiled panes to their own module (#1239)

* work

* tests passing

* simplify render state

* move more stuff to state

* moved tiled panes outside

* move files around

* style(fmt): rustfmt

22 files changed, 3827 insertions, 2746 deletions

diff --git a/src/tests/e2e/cases.rs b/src/tests/e2e/cases.rs
index f3a181be..8bb4d898 100644
--- a/src/tests/e2e/cases.rs
+++ b/src/tests/e2e/cases.rs
@@ -477,6 +477,7 @@ pub fn close_tab() {
                 let mut step_is_complete = false;
                 if remote_terminal.cursor_position_is(3, 2)
                     && !remote_terminal.snapshot_contains("Tab #2")
+                    && remote_terminal.tip_appears()
                 {
                     // cursor is in the first tab again
                     step_is_complete = true;
diff --git a/zellij-server/src/tab/floating_pane_grid.rs b/zellij-server/src/panes/floating_panes/floating_pane_grid.rs
index 18248342..31d0d6ff 100644
--- a/zellij-server/src/tab/floating_pane_grid.rs
+++ b/zellij-server/src/panes/floating_panes/floating_pane_grid.rs
@@ -1,12 +1,8 @@
-use super::pane_resizer::PaneResizer;
 use crate::tab::{MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH};
 use crate::{panes::PaneId, tab::Pane};
 use std::cmp::Ordering;
-use std::collections::{HashMap, HashSet};
-use zellij_utils::{
-    input::layout::Direction,
-    pane_size::{Dimension, PaneGeom, Size, Viewport},
-};
+use std::collections::HashMap;
+use zellij_utils::pane_size::{Dimension, PaneGeom, Size, Viewport};
 
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -40,11 +36,6 @@ impl<'a> FloatingPaneGrid<'a> {
             viewport,
         }
     }
-
-    pub fn layout(&mut self, direction: Direction, space: usize) -> Result<(), String> {
-        let mut pane_resizer = PaneResizer::new(self.panes.clone());
-        pane_resizer.layout(direction, space)
-    }
     pub fn move_pane_by(&mut self, pane_id: PaneId, x: isize, y: isize) {
         // true => succeeded to move, false => failed to move
         let new_pane_position = {
@@ -568,16 +559,6 @@ impl<'a> FloatingPaneGrid<'a> {
             None
         }
     }
-    fn increase_pane_height(&mut self, id: &PaneId, percent: f64) {
-        let mut panes = self.panes.borrow_mut();
-        let terminal = panes.get_mut(id).unwrap();
-        terminal.increase_height(percent);
-    }
-    fn increase_pane_width(&mut self, id: &PaneId, percent: f64) {
-        let mut panes = self.panes.borrow_mut();
-        let terminal = panes.get_mut(id).unwrap();
-        terminal.increase_width(percent);
-    }
     fn increase_pane_size_left(&mut self, id: &PaneId, increase_by: usize) {
         let new_pane_geom = {
             let mut panes = self.panes.borrow_mut();
@@ -679,140 +660,6 @@ impl<'a> FloatingPaneGrid<'a> {
         };
         self.set_pane_geom(*id, new_pane_geom);
     }
-    fn pane_ids_directly_left_of(&self, id: &PaneId) -> Option<Vec<PaneId>> {
-        let panes = self.panes.borrow();
-        let mut ids = vec![];
-        let terminal_to_check = panes.get(id).unwrap();
-        if terminal_to_check.x() == 0 {
-            return None;
-        }
-        // for (&pid, terminal) in self.get_panes() {
-        for (&pid, terminal) in panes.iter() {
-            if terminal.x() + terminal.cols() == terminal_to_check.x() {
-                ids.push(pid);
-            }
-        }
-        if ids.is_empty() {
-            None
-        } else {
-            Some(ids)
-        }
-    }
-    fn pane_ids_directly_right_of(&self, id: &PaneId) -> Option<Vec<PaneId>> {
-        let mut ids = vec![];
-        let panes = self.panes.borrow();
-        let terminal_to_check = panes.get(id).unwrap();
-        // for (&pid, terminal) in self.get_panes() {
-        for (&pid, terminal) in panes.iter() {
-            if terminal.x() == terminal_to_check.x() + terminal_to_check.cols() {
-                ids.push(pid);
-            }
-        }
-        if ids.is_empty() {
-            None
-        } else {
-            Some(ids)
-        }
-    }
-    fn pane_ids_directly_below(&self, id: &PaneId) -> Option<Vec<PaneId>> {
-        let mut ids = vec![];
-        let panes = self.panes.borrow();
-        let terminal_to_check = panes.get(id).unwrap();
-        // for (&pid, terminal) in self.get_panes() {
-        for (&pid, terminal) in panes.iter() {
-            if terminal.y() == terminal_to_check.y() + terminal_to_check.rows() {
-                ids.push(pid);
-            }
-        }
-        if ids.is_empty() {
-            None
-        } else {
-            Some(ids)
-        }
-    }
-    fn pane_ids_directly_above(&self, id: &PaneId) -> Option<Vec<PaneId>> {
-        let mut ids = vec![];
-        let panes = self.panes.borrow();
-        let terminal_to_check = panes.get(id).unwrap();
-        // for (&pid, terminal) in self.get_panes() {
-        for (&pid, terminal) in panes.iter() {
-            if terminal.y() + terminal.rows() == terminal_to_check.y() {
-                ids.push(pid);
-            }
-        }
-        if ids.is_empty() {
-            None
-        } else {
-            Some(ids)
-        }
-    }
-    fn pane_is_between_vertical_borders(
-        &self,
-        id: &PaneId,
-        left_border_x: usize,
-        right_border_x: usize,
-    ) -> bool {
-        let panes = self.panes.borrow();
-        let pane = panes.get(id).unwrap();
-        pane.x() >= left_border_x && pane.x() + pane.cols() <= right_border_x
-    }
-    fn pane_is_between_horizontal_borders(
-        &self,
-        id: &PaneId,
-        top_border_y: usize,
-        bottom_border_y: usize,
-    ) -> bool {
-        let panes = self.panes.borrow();
-        let pane = panes.get(id).unwrap();
-        pane.y() >= top_border_y && pane.y() + pane.rows() <= bottom_border_y
-    }
-    pub fn next_selectable_pane_id(&self, current_pane_id: &PaneId) -> PaneId {
-        let panes = self.panes.borrow();
-        let mut panes: Vec<(&PaneId, &&mut Box<dyn Pane>)> =
-            panes.iter().filter(|(_, p)| p.selectable()).collect();
-        panes.sort_by(|(_a_id, a_pane), (_b_id, b_pane)| {
-            if a_pane.y() == b_pane.y() {
-                a_pane.x().cmp(&b_pane.x())
-            } else {
-                a_pane.y().cmp(&b_pane.y())
-            }
-        });
-        let active_pane_position = panes
-            .iter()
-            .position(|(id, _)| *id == current_pane_id) // TODO: better
-            .unwrap();
-
-        let next_active_pane_id = panes
-            .get(active_pane_position + 1)
-            .or_else(|| panes.get(0))
-            .map(|p| *p.0)
-            .unwrap();
-        next_active_pane_id
-    }
-    pub fn previous_selectable_pane_id(&self, current_pane_id: &PaneId) -> PaneId {
-        let panes = self.panes.borrow();
-        let mut panes: Vec<(&PaneId, &&mut Box<dyn Pane>)> =
-            panes.iter().filter(|(_, p)| p.selectable()).collect();
-        panes.sort_by(|(_a_id, a_pane), (_b_id, b_pane)| {
-            if a_pane.y() == b_pane.y() {
-                a_pane.x().cmp(&b_pane.x())
-            } else {
-                a_pane.y().cmp(&b_pane.y())
-            }
-        });
-        let last_pane = panes.last().unwrap();
-        let active_pane_position = panes
-            .iter()
-            .position(|(id, _)| *id == current_pane_id) // TODO: better
-            .unwrap();
-
-        let previous_active_pane_id = if active_pane_position == 0 {
-            *last_pane.0
-        } else {
-            *panes.get(active_pane_position - 1).unwrap().0
-        };
-        previous_active_pane_id
-    }
     pub fn next_selectable_pane_id_to_the_left(&self, current_pane_id: &PaneId) -> Option<PaneId> {
         let panes = self.panes.borrow();
         let current_pane = panes.get(current_pane_id)?;
@@ -917,196 +764,6 @@ impl<'a> FloatingPaneGrid<'a> {
             .copied();
         next_index
     }
-    fn horizontal_borders(&self, pane_ids: &[PaneId]) -> HashSet<usize> {
-        pane_ids.iter().fold(HashSet::new(), |mut borders, p| {
-            let panes = self.panes.borrow();
-            let pane = panes.get(p).unwrap();
-            borders.insert(pane.y());
-            borders.insert(pane.y() + pane.rows());
-            borders
-        })
-    }
-    fn vertical_borders(&self, pane_ids: &[PaneId]) -> HashSet<usize> {
-        pane_ids.iter().fold(HashSet::new(), |mut borders, p| {
-            let panes = self.panes.borrow();
-            let pane = panes.get(p).unwrap();
-            borders.insert(pane.x());
-            borders.insert(pane.x() + pane.cols());
-            borders
-        })
-    }
-    fn panes_to_the_left_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> {
-        let panes = self.panes.borrow();
-        if let Some(pane) = panes.get(&id) {
-            let upper_close_border = pane.y();
-            let lower_close_border = pane.y() + pane.rows();
-
-            if let Some(panes_to_the_left) = self.pane_ids_directly_left_of(&id) {
-                let mut selectable_panes: Vec<_> = panes_to_the_left
-                    .into_iter()
-                    .filter(|pid| panes.get(pid).unwrap().selectable())
-                    .collect();
-                let pane_borders_to_the_left = self.horizontal_borders(&selectable_panes);
-                if pane_borders_to_the_left.contains(&upper_close_border)
-                    && pane_borders_to_the_left.contains(&lower_close_border)
-                {
-                    selectable_panes.retain(|t| {
-                        self.pane_is_between_horizontal_borders(
-                            t,
-                            upper_close_border,
-                            lower_close_border,
-                        )
-                    });
-                    return Some(selectable_panes);
-                }
-            }
-        }
-        None
-    }
-    fn panes_to_the_right_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> {
-        let panes = self.panes.borrow();
-        if let Some(pane) = panes.get(&id) {
-            let upper_close_border = pane.y();
-            let lower_close_border = pane.y() + pane.rows();
-
-            if let Some(panes_to_the_right) = self.pane_ids_directly_right_of(&id) {
-                let mut selectable_panes: Vec<_> = panes_to_the_right
-                    .into_iter()
-                    .filter(|pid| panes.get(pid).unwrap().selectable())
-                    .collect();
-                let pane_borders_to_the_right = self.horizontal_borders(&selectable_panes);
-                if pane_borders_to_the_right.contains(&upper_close_border)
-                    && pane_borders_to_the_right.contains(&lower_close_border)
-                {
-                    selectable_panes.retain(|t| {
-                        self.pane_is_between_horizontal_borders(
-                            t,
-                            upper_close_border,
-                            lower_close_border,
-                        )
-                    });
-                    return Some(selectable_panes);
-                }
-            }
-        }
-        None
-    }
-    fn panes_above_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> {
-        let panes = self.panes.borrow();
-        if let Some(pane) = panes.get(&id) {
-            let left_close_border = pane.x();
-            let right_close_border = pane.x() + pane.cols();
-
-            if let Some(panes_above) = self.pane_ids_directly_above(&id) {
-                let mut selectable_panes: Vec<_> = panes_above
-                    .into_iter()
-                    .filter(|pid| panes.get(pid).unwrap().selectable())
-                    .collect();
-                let pane_borders_above = self.vertical_borders(&selectable_panes);
-                if pane_borders_above.contains(&left_close_border)
-                    && pane_borders_above.contains(&right_close_border)
-                {
-                    selectable_panes.retain(|t| {
-                        self.pane_is_between_vertical_borders(
-                            t,
-                            left_close_border,
-                            right_close_border,
-                        )
-                    });
-                    return Some(selectable_panes);
-                }
-            }
-        }
-        None
-    }
-    fn panes_below_between_aligning_borders(&self, id: PaneId) -> Option<Vec<PaneId>> {
-        let panes = self.panes.borrow();
-        if let Some(pane) = panes.get(&id) {
-            let left_close_border = pane.x();
-            let right_close_border = pane.x() + pane.cols();
-
-            if let Some(panes_below) = self.pane_ids_directly_below(&id) {
-                let mut selectable_panes: Vec<_> = panes_below
-                    .into_iter()
-                    .filter(|pid| panes[pid].selectable())
-                    .collect();
-                let pane_borders_below = self.vertical_borders(&selectable_panes);
-                if pane_borders_below.contains(&left_close_border)
-                    && pane_borders_below.contains(&right_close_border)
-                {
-                    selectable_panes.retain(|t| {
-                        self.pane_is_between_vertical_borders(
-                            t,
-                            left_close_border,
-                            right_close_border,
-                        )
-                    });
-                    return Some(selectable_panes);
-                }
-            }
-        }
-        None
-    }
-    fn find_panes_to_grow(&self, id: PaneId) -> Option<(Vec<PaneId>, Direction)> {
-        if let Some(panes) = self
-            .panes_to_the_left_between_aligning_borders(id)
-            .or_else(|| self.panes_to_the_right_between_aligning_borders(id))
-        {
-            return Some((panes, Direction::Horizontal));
-        }
-
-        if let Some(panes) = self
-            .panes_above_between_aligning_borders(id)
-            .or_else(|| self.panes_below_between_aligning_borders(id))
-        {
-            return Some((panes, Direction::Vertical));
-        }
-
-        None
-    }
-    fn grow_panes(&mut self, panes: &[PaneId], direction: Direction, (width, height): (f64, f64)) {
-        match direction {
-            Direction::Horizontal => {
-                for pane_id in panes {
-                    self.increase_pane_width(pane_id, width);
-                }
-            }
-            Direction::Vertical => {
-                for pane_id in panes {
-                    self.increase_pane_height(pane_id, height);
-                }
-            }
-        };
-    }
-    pub fn fill_space_over_pane(&mut self, id: PaneId) -> bool {
-        // true => successfully filled space over pane
-        // false => didn't succeed, so didn't do anything
-        let (freed_width, freed_height) = {
-            let panes = self.panes.borrow_mut();
-            let pane_to_close = panes.get(&id).unwrap();
-            let freed_space = pane_to_close.position_and_size();
-            let freed_width = freed_space.cols.as_percent();
-            let freed_height = freed_space.rows.as_percent();
-            (freed_width, freed_height)
-        };
-        if let (Some(freed_width), Some(freed_height)) = (freed_width, freed_height) {
-            if let Some((panes_to_grow, direction)) = self.find_panes_to_grow(id) {
-                self.grow_panes(&panes_to_grow, direction, (freed_width, freed_height));
-                let side_length = match direction {
-                    Direction::Vertical => self.display_area.rows,
-                    Direction::Horizontal => self.display_area.cols,
-                };
-                {
-                    let mut panes = self.panes.borrow_mut();
-                    (*panes).remove(&id);
-                }
-                let mut pane_resizer = PaneResizer::new(self.panes.clone());
-                let _ = pane_resizer.layout(direction, side_length);
-                return true;
-            }
-        }
-        false
-    }
     pub fn find_room_for_new_pane(&self) -> Option<PaneGeom> {
         let panes = self.panes.borrow();
         let pane_geoms: Vec<PaneGeom> = panes.values().map(|p| p.position_and_size()).collect();
diff --git a/zellij-server/src/panes/floating_panes.rs b/zellij-server/src/panes/floating_panes/mod.rs
index c88bcba9..99cf7e9d 100644
--- a/zellij-server/src/panes/floating_panes.rs
+++ b/zellij-server/src/panes/floating_panes/mod.rs
@@ -1,7 +1,9 @@
+mod floating_pane_grid;
+
 use zellij_utils::{position::Position, zellij_tile};
 
-use crate::tab::floating_pane_grid::FloatingPaneGrid;
 use crate::tab::Pane;
+use floating_pane_grid::FloatingPaneGrid;
 
 use crate::{
     os_input_output::ServerOsApi,
@@ -35,6 +37,12 @@ pub struct FloatingPanes {
     panes: BTreeMap<PaneId, Box<dyn Pane>>,
     display_area: Rc<RefCell<Size>>,
     viewport: Rc<RefCell<Viewport>>,
+    connected_clients: Rc<RefCell<HashSet<ClientId>>>,
+    connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>,
+    mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>,
+    default_mode_info: ModeInfo,
+    colors: Palette,
+    session_is_mirrored: bool,
     desired_pane_positions: HashMap<PaneId, PaneGeom>, // this represents the positions of panes the user moved with intention, rather than by resizing the terminal window
     z_indices: Vec<PaneId>,
     active_panes: HashMap<ClientId, PaneId>,
@@ -44,11 +52,26 @@ pub struct FloatingPanes {
 
 #[allow(clippy::borrowed_box)]
 impl FloatingPanes {
-    pub fn new(display_area: Rc<RefCell<Size>>, viewport: Rc<RefCell<Viewport>>) -> Self {
+    pub fn new(
+        display_area: Rc<RefCell<Size>>,
+        viewport: Rc<RefCell<Viewport>>,
+        connected_clients: Rc<RefCell<HashSet<ClientId>>>,
+        connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>,
+        mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>,
+        session_is_mirrored: bool,
+        default_mode_info: ModeInfo,
+        colors: Palette,
+    ) -> Self {
         FloatingPanes {
             panes: BTreeMap::new(),
             display_area,
             viewport,
+            connected_clients,
+            connected_clients_in_app,
+            mode_info,
+            session_is_mirrored,
+            default_mode_info,
+            colors,
             desired_pane_positions: HashMap::new(),
             z_indices: vec![],
             show_panes: false,
@@ -56,13 +79,17 @@ impl FloatingPanes {
             pane_being_moved_with_mouse: None,
         }
     }
-    pub fn stack(&self) -> FloatingPanesStack {
-        let layers = self
-            .z_indices
-            .iter()
-            .map(|pane_id| self.panes.get(pane_id).unwrap().position_and_size())
-            .collect();
-        FloatingPanesStack { layers }
+    pub fn stack(&self) -> Option<FloatingPanesStack> {
+        if self.panes_are_visible() {
+            let layers = self
+                .z_indices
+                .iter()
+                .map(|pane_id| self.panes.get(pane_id).unwrap().position_and_size())
+                .collect();
+            Some(FloatingPanesStack { layers })
+        } else {
+            None
+        }
     }
     pub fn pane_ids(&self) -> impl Iterator<Item = &PaneId> {
         self.panes.keys()
@@ -151,17 +178,9 @@ impl FloatingPanes {
             resize_pty!(pane, os_api);
         }
     }
-    #[allow(clippy::too_many_arguments)]
-    pub fn render(
-        &mut self,
-        connected_clients_in_app: &Rc<RefCell<HashSet<ClientId>>>,
-        connected_clients: &HashSet<ClientId>,
-        mode_info: &HashMap<ClientId, ModeInfo>,
-        default_mode_info: &ModeInfo,
-        session_is_mirrored: bool,
-        output: &mut Output,
-        colors: Palette,
-    ) {
+    pub fn render(&mut self, output: &mut Output) {
+        let connected_clients: Vec<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
         let mut floating_panes: Vec<_> = self.panes.iter_mut().collect();
         floating_panes.sort_by(|(a_id, _a_pane), (b_id, _b_pane)| {
             self.z_indices
@@ -173,25 +192,35 @@ impl FloatingPanes {
 
         for (z_index, (kind, pane)) in floating_panes.iter_mut().enumerate() {
             let mut active_panes = self.active_panes.clone();
-            let multiple_users_exist_in_session = { connected_clients_in_app.borrow().len() > 1 };
-            active_panes.retain(|c_id, _| connected_clients.contains(c_id));
+            let multiple_users_exist_in_session =
+                { self.connected_clients_in_app.borrow().len() > 1 };
+            active_panes.retain(|c_id, _| self.connected_clients.borrow().contains(c_id));
             let mut pane_contents_and_ui = PaneContentsAndUi::new(
                 pane,
                 output,
-                colors,
+                self.colors,
                 &active_panes,
                 multiple_users_exist_in_session,
                 Some(z_index + 1), // +1 because 0 is reserved for non-floating panes
             );
-            for &client_id in connected_clients {
-                let client_mode = mode_info.get(&client_id).unwrap_or(default_mode_info).mode;
-                pane_contents_and_ui.render_pane_frame(client_id, client_mode, session_is_mirrored);
+            for client_id in &connected_clients {
+                let client_mode = self
+                    .mode_info
+                    .borrow()
+                    .get(&client_id)
+                    .unwrap_or(&self.default_mode_info)
+                    .mode;
+                pane_contents_and_ui.render_pane_frame(
+                    *client_id,
+                    client_mode,
+                    self.session_is_mirrored,
+                );
                 if let PaneId::Plugin(..) = kind {
-                    pane_contents_and_ui.render_pane_contents_for_client(client_id);
+                    pane_contents_and_ui.render_pane_contents_for_client(*client_id);
                 }
                 // this is done for panes that don't have their own cursor (eg. panes of
                 // another user)
-                pane_contents_and_ui.render_fake_cursor_if_needed(client_id);
+                pane_contents_and_ui.render_fake_cursor_if_needed(*client_id);
             }
             if let PaneId::Terminal(..) = kind {
                 pane_contents_and_ui
@@ -719,18 +748,32 @@ impl FloatingPanes {
             }
         }
     }
-    pub fn focus_pane(&mut self, pane_id: PaneId, client_id: ClientId) {
-        self.active_panes.insert(client_id, pane_id);
+    pub fn focus_pane_for_all_clients(&mut self, pane_id: PaneId) {
+        let connected_clients: Vec<ClientId> =
+            self.connected_clients.borrow().iter().copied().collect();
+        for client_id in connected_clients {
+            self.active_panes.insert(client_id, pane_id);
+        }
         self.z_indices.retain(|p_id| *p_id != pane_id);
         self.z_indices.push(pane_id);
         self.set_pane_active_at(pane_id);
         self.set_force_render();
     }
+    pub fn focus_pane(&mut self, pane_id: PaneId, client_id: ClientId) {
+        self.active_panes.insert(client_id, pane_id);
+        self.focus_pane_for_all_clients(pane_id);
+    }
     pub fn defocus_pane(&mut self, pane_id: PaneId, client_id: ClientId) {
         self.z_indices.retain(|p_id| *p_id != pane_id);
         self.active_panes.remove(&client_id);
         self.set_force_render();
     }
+    pub fn get_pane(&self, pane_id: PaneId) -> Option<&Box<dyn Pane>> {
+        self.panes.get(&pane_id)
+    }
+    pub fn get_pane_mut(&mut self, pane_id: PaneId) -> Option<&mut Box<dyn Pane>> {
+        self.panes.get_mut(&pane_id)
+    }
     pub fn get_pane_id_at(&self, point: &Position, search_selectable: bool) -> Option<PaneId> {
         if search_selectable {
             // TODO: better - loop through z-indices and check each one if it contains the point
@@ -825,4 +868,10 @@ impl FloatingPanes {
         };
         self.pane_being_moved_with_mouse = None;
     }
+    pub fn get_active_pane_id(&self, client_id: ClientId) -> Option<PaneId> {
+        self.active_panes.get(&client_id).copied()
+    }
+    pub fn get_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> {
+        self.panes.iter()
+    }
 }
diff --git a/zellij-server/src/panes/mod.rs b/zellij-server/src/panes/mod.rs
index d3fd0807..b9e7d8d0 100644
--- a/zellij-server/src/panes/mod.rs
+++ b/zellij-server/src/panes/mod.rs
@@ -6,6 +6,7 @@ mod plugin_pane;
 pub mod selection;
 pub mod terminal_character;
 mod terminal_pane;
+mod tiled_panes;
 
 pub use alacritty_functions::*;
 pub use floating_panes::*;
@@ -14,3 +15,4 @@ pub use link_handler::*;
 pub(crate) use plugin_pane::*;
 pub(crate) use terminal_character::*;
 pub use terminal_pane::*;
+pub use tiled_panes::*;
diff --git a/zellij-server/src/panes/tiled_panes/mod.rs b/zellij-server/src/panes/tiled_panes/mod.rs
new file mode 100644
index 00000000..dc755af4
--- /dev/null
+++ b/zellij-server/src/panes/tiled_panes/mod.rs
@@ -0,0 +1,1035 @@
+mod pane_resizer;
+mod tiled_pane_grid;
+
+use zellij_utils::zellij_tile;
+
+use crate::tab::{Pane, MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH};
+use tiled_pane_grid::{split, TiledPaneGrid};
+
+use crate::{
+    os_input_output::ServerOsApi, output::Output, panes::PaneId, ui::boundaries::Boundaries,
+    ui::pane_contents_and_ui::PaneContentsAndUi, ClientId,
+};
+use std::cell::RefCell;
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::rc::Rc;
+use std::time::Instant;
+use zellij_tile::data::{ModeInfo, Palette};
+use zellij_utils::{
+    input::layout::Direction,
+    pane_size::{Offset, PaneGeom, Size, Viewport},
+};
+
+macro_rules! resize_pty {
+    ($pane:expr, $os_input:expr) => {
+        if let PaneId::Terminal(ref pid) = $pane.pid() {
+            // FIXME: This `set_terminal_size_using_fd` call would be best in
+            // `TerminalPane::reflow_lines`
+            $os_input.set_terminal_size_using_fd(
+                *pid,
+                $pane.get_content_columns() as u16,
+                $pane.get_content_rows() as u16,
+            );
+        }
+    };
+}
+
+fn pane_content_offset(position_and_size: &PaneGeom, viewport: &Viewport) -> (usize, usize) {
+    // (columns_offset, rows_offset)
+    // if the pane is not on the bottom or right edge on the screen, we need to reserve one space
+    // from its content to leave room for the boundary between it and the next pane (if it doesn't
+    // draw its own frame)
+    let columns_offset = if position_and_size.x + position_and_size.cols.as_usize() < viewport.cols
+    {
+        1
+    } else {
+        0
+    };
+    let rows_offset = if position_and_size.y + position_and_size.rows.as_usize() < viewport.rows {
+        1
+    } else {
+        0
+    };
+    (columns_offset, rows_offset)
+}
+
+pub struct TiledPanes {
+    pub panes: BTreeMap<PaneId, Box<dyn Pane>>,
+    display_area: Rc<RefCell<Size>>,
+    viewport: Rc<RefCell<Viewport>>,
+    connected_clients: Rc<RefCell<HashSet<ClientId>>>,
+    connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>,
+    mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>,
+    default_mode_info: ModeInfo,
+    colors: Palette,
+    session_is_mirrored: bool,
+    active_panes: HashMap<ClientId, PaneId>,
+    draw_pane_frames: bool,
+    panes_to_hide: HashSet<PaneId>,
+    fullscreen_is_active: bool,
+    os_api: Box<dyn ServerOsApi>,
+}
+
+impl TiledPanes {
+    pub fn new(
+        display_area: Rc<RefCell<Size>>,
+        viewport: Rc<RefCell<Viewport>>,
+        connected_clients: Rc<RefCell<HashSet<ClientId>>>,
+        connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>,
+        mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>,
+        session_is_mirrored: bool,
+        draw_pane_frames: bool,
+        default_mode_info: ModeInfo,
+        colors: Palette,
+        os_api: Box<dyn ServerOsApi>,
+    ) -> Self {
+        TiledPanes {
+            panes: BTreeMap::new(),
+            display_area,
+            viewport,
+            connected_clients,
+            connected_clients_in_app,
+            mode_info,
+            default_mode_info,
+            colors,
+            session_is_mirrored,
+            active_panes: HashMap::new(),
+            draw_pane_frames,
+            panes_to_hide: HashSet::new(),
+            fullscreen_is_active: false,
+            os_api,
+        }
+    }
+    pub fn add_pane_with_existing_geom(&mut self, pane_id: PaneId, pane: Box<dyn Pane>) {
+        self.panes.insert(pane_id, pane);
+    }
+    pub fn insert_pane(&mut self, pane_id: PaneId, mut pane: Box<dyn Pane>) {
+        let pane_grid = TiledPaneGrid::new(
+            &mut self.panes,
+            *self.display_area.borrow(),
+            *self.viewport.borrow(),
+        );
+        let pane_id_and_split_direction = pane_grid.find_room_for_new_pane();
+        if let Some((pane_id_to_split, split_direction)) = pane_id_and_split_direction {
+            // this unwrap is safe because floating panes should not be visible if there are no floating panes
+            let pane_to_split = self.panes.get_mut(&pane_id_to_split).unwrap();
+            let size_of_both_panes = pane_to_split.position_and_size();
+            if let Some((first_geom, second_geom)) = split(split_direction, &size_of_both_panes) {
+                pane_to_split.set_geom(first_geom);
+                pane.set_geom(second_geom);
+                self.panes.insert(pane_id, pane);
+                // ¯\_(ツ)_/¯
+                let relayout_direction = match split_direction {
+                    Direction::Vertical => Direction::Horizontal,
+                    Direction::Horizontal => Direction::Vertical,
+                };
+                self.relayout(relayout_direction);
+            }
+        }
+    }
+    pub fn has_room_for_new_pane(&mut self) -> bool {
+        let pane_grid = TiledPaneGrid::new(
+            &mut self.panes,
+            *self.display_area.borrow(),
+            *self.viewport.borrow(),
+        );
+        pane_grid.find_room_for_new_pane().is_some()
+    }
+    pub fn fixed_pane_geoms(&self) -> Vec<Viewport> {
+        self.panes
+            .values()
+            .filter_map(|p| {
+                let geom = p.position_and_size();
+                if geom.cols.is_fixed() || geom.rows.is_fixed() {
+                    Some(geom.into())
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+    pub fn first_selectable_pane_id(&self) -> Option<PaneId> {
+        self.panes
+            .iter()
+            .filter(|(_id, pane)| pane.selectable())
+            .map(|(id, _)| id.to_owned())
+            .next()
+    }
+    pub fn pane_ids(&self) -> impl Iterator<Item = &PaneId> {
+        self.panes.keys()
+    }
+    pub fn relayout(&mut self, direction: Direction) {
+        let mut pane_grid = TiledPaneGrid::new(
+            &mut self.panes,
+            *self.display_area.borrow(),
+            *self.viewport.borrow(),
+        );
+        let result = match direction {
+            Direction::Horizontal => {
+                pane_grid.layout(direction, (*self.display_area.borrow()).cols)
+            }
+            Direction::Vertical => pane_grid.layout(direction, (*self.display_area.borrow()).rows),
+        };
+        if let Err(e) = &result {
+            log::error!("{:?} relayout of the tab failed: {}", direction, e);
+        }
+        self.set_pane_frames(self.draw_pane_frames);
+    }
+    pub fn set_pane_frames(&mut self, draw_pane_frames: bool) {
+        self.draw_pane_frames = draw_pane_frames;
+        let viewport = *self.viewport.borrow();
+        for pane in self.panes.values_mut() {
+            if !pane.borderless() {
+                pane.set_frame(draw_pane_frames);
+            }
+
+            #[allow(clippy::if_same_then_else)]
+            if draw_pane_frames & !pane.borderless() {
+                // there's definitely a frame around this pane, offset its contents
+                pane.set_content_offset(Offset::frame(1));
+            } else if draw_pane_frames && pane.borderless() {
+                // there's no frame around this pane, and the tab isn't handling the boundaries
+                // between panes (they each draw their own frames as they please)
+                // this one doesn't - do not offset its content
+                pane.set_content_offset(Offset::default());
+            } else if !is_inside_viewport(&viewport, pane) {
+                // this pane is outside the viewport and has no border - it should not have an offset
+                pane.set_content_offset(Offset::default());
+            } else {
+                // no draw_pane_frames and this pane should have a separation to other panes
+                // according to its position in the viewport (eg. no separation if its at the
+                // viewport bottom) - offset its content accordingly
+                let position_and_size = pane.current_geom();
+                let (pane_columns_offset, pane_rows_offset) =
+                    pane_content_offset(&position_and_size, &viewport);
+                pane.set_content_offset(Offset::shift(pane_rows_offset, pane_columns_offset));
+            }
+
+            resize_pty!(pane, &mut self.os_api);
+        }
+    }
+    pub fn can_split_pane_horizontally(&mut self, client_id: ClientId) -> bool {
+        if let Some(active_pane_id) = &self.active_panes.get(&client_id) {
+            if let Some(active_pane) = self.panes.get_mut(active_pane_id) {
+                let full_pane_size = active_pane.position_and_size();
+                if full_pane_size.rows.as_usize() < MIN_TERMINAL_HEIGHT * 2 {
+                    return false;
+                } else {
+                    return split(Direction::Horizontal, &full_pane_size).is_some();
+                }
+            }
+        }
+        false
+    }
+    pub fn can_split_pane_vertically(&mut self, client_id: ClientId) -> bool {
+        if let Some(active_pane_id) = &self.active_panes.get(&client_id) {
+            if let Some(active_pane) = self.panes.get_mut(active_pane_id) {
+                let full_pane_size = active_pane.position_and_size();
+                if full_pane_size.cols.as_usize() < MIN_TERMINAL_WIDTH * 2 {
+                    return false;
+                }
+                return split(Direction::Vertical, &full_pane_size).is_some();
+            }
+        }
+        false
+    }
+    pub fn split_pane_horizontally(
+        &mut self,
+        pid: PaneId,
+        mut new_pane: Box<dyn Pane>,
+        client_id: ClientId,
+    ) {
+        let active_pane_id = &self.active_panes.get(&client_id).unwrap();
+        let active_pane = self.panes.get_mut(active_pane_id).unwrap();
+        let full_pane_size = active_pane.position_and_size();
+        if let Some((top_winsize, bottom_winsize)) = split(Direction::Horizontal, &full_pane_size) {
+            active_pane.set_geom(top_winsize);
+            new_pane.set_geom(bottom_winsize);
+            self.panes.insert(pid, new_pane);
+            self.relayout(Direction::Vertical);
+        }
+    }
+    pub fn split_pane_vertically(
+        &mut self,
+        pid: PaneId,
+        mut new_pane: Box<dyn Pane>,
+        client_id: ClientId,
+    ) {
+        let active_pane_id = &self.active_panes.get(&client_id).unwrap();
+        let active_pane = self.panes.get_mut(active_pane_id).unwrap();
+        let full_pane_size = active_pane.position_and_size();
+        if let Some((left_winsize, right_winsize)) = split(Direction::Vertical, &full_pane_size) {
+            active_pane.set_geom(left_winsize);
+            new_pane.set_geom(right_winsize);
+            self.panes.insert(pid, new_pane);
+            self.relayout(Direction::Horizontal);
+        }
+    }
+    pub fn focus_pane(&mut self, pane_id: PaneId, client_id: ClientId) {
+        self.active_panes.insert(client_id, pane_id);
+        if self.session_is_mirrored {
+            // move all clients
+            let connected_clients: Vec<ClientId> =
+                self.connected_clients.borrow().iter().copied().collect();
+            for client_id in connected_clients {
+                self.active_panes.insert(client_id, pane_id);
+            }
+        }
+    }
+    pub fn clear_active_panes(&mut self) {
+        self.active_panes.clear();
+    }
+    pub fn first_active_pane_id(&self) -> Option<PaneId> {
+        self.connected_clients
+            .borrow()
+            .iter()
+            .next()
+            .and_then(|first_client_id| self.active_panes.get(first_client_id).copied())
+    }
+    pub fn focused_pane_id(&self, client_id: ClientId) -> Option<PaneId> {
+        self.active_panes.get(&client_id).copied()
+    }
+    pub fn get_pane(&self, pane_id: PaneId) -> Option<&Box<dyn Pane>> {
+        self.panes.get(&pane_id)
+    }
+    pub fn get_pane_mut(&mut self, pane_id: PaneId) -> Option<&mut Box<dyn Pane>> {
+        self.panes.get_mut(&pane_id)
+    }
+    pub fn get_active_pane_id(&self, client_id: ClientId) -> Option<PaneId> {
+        self.active_panes.get(&client_id).copied()
+    }
+    pub fn panes_contain(&self, pane_id: &PaneId) -> bool {
+        self.panes.contains_key(pane_id)
+    }
+    pub fn set_force_render(&mut self) {
+        for pane in self.panes.values_mut() {
+            pane.set_should_render(true);
+            pane.set_should_render_boundaries(true);
+            pane.render_full_viewport();
+        }
+    }
+    pub fn has_active_panes(&self) -> bool {
+        !self.active_panes.is_empty()
+    }
+    pub fn has_panes(&self) -> bool {
+        !self.panes.is_empty()
+    }
+    pub fn render(&mut self, output: &mut Output) {
+        let connected_clients: Vec<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
+        let multiple_users_exist_in_session = { self.connected_clients_in_app.borrow().len() > 1 };
+        let mut client_id_to_boundaries: HashMap<ClientId, Boundaries> = HashMap::new();
+        let active_panes = if self.session_is_mirrored {
+            HashMap::new()
+        } else {
+            self.active_panes
+                .iter()
+                .filter(|(client_id, _pane_id)| connected_clients.contains(client_id))
+                .map(|(client_id, pane_id)| (*client_id, *pane_id))
+                .collect()
+        };
+        for (kind, pane) in self.panes.iter_mut() {
+            if !self.panes_to_hide.contains(&pane.pid()) {
+                let mut pane_contents_and_ui = PaneContentsAndUi::new(
+                    pane,
+                    output,
+                    self.colors,
+                    &active_panes,
+                    multiple_users_exist_in_session,
+                    None,
+                );
+                for client_id in &connected_clients {
+                    let client_mode = self
+                        .mode_info
+                        .borrow()
+                        .get(&client_id)
+                        .unwrap_or(&self.default_mode_info)
+                        .mode;
+                    if let PaneId::Plugin(..) = kind {
+                        pane_contents_and_ui.render_pane_contents_for_client(*client_id);
+                    }
+                    if self.draw_pane_frames {
+                        pane_contents_and_ui.render_pane_frame(
+                            *client_id,
+                            client_mode,
+                            self.session_is_mirrored,
+                        );
+                    } else {
+                        let boundaries = client_id_to_boundaries
+                            .entry(*client_id)
+                            .or_insert_with(|| Boundaries::new(*self.viewport.borrow()));
+                        pane_contents_and_ui.render_pane_boundaries(
+                            *client_id,
+                            client_mode,
+                            boundaries,
+                            self.session_is_mirrored,
+                        );
+                    }
+                    pane_contents_and_ui.render_terminal_title_if_needed(*client_id, client_mode);
+                    // this is done for panes that don't have their own cursor (eg. panes of
+                    // another user)
+                    pane_contents_and_ui.render_fake_cursor_if_needed(*client_id);
+                }
+                if let PaneId::Terminal(..) = kind {
+                    pane_contents_and_ui.render_pane_contents_to_multiple_clients(
+                        connected_clients.iter().copied(),
+                    );
+                }
+            }
+        }
+        // render boundaries if needed
+        for (client_id, boundaries) in &mut client_id_to_boundaries {
+            // TODO: add some conditional rendering here so this isn't rendered for every character
+            output.add_character_chunks_to_client(*client_id, boundaries.render(), None);
+        }
+    }
+    pub fn get_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> {
+        self.panes.iter()
+    }
+    pub fn resize(&mut self, new_screen_size: Size) {
+        // this is blocked out to appease the borrow checker
+        {
+            let mut display_area = self.display_area.borrow_mut();
+            let mut viewport = self.viewport.borrow_mut();
+            let panes = self
+                .panes
+                .iter_mut()
+                .filter(|(pid, _)| !self.panes_to_hide.contains(pid));
+            let Size { rows, cols } = new_screen_size;
+            let mut pane_grid = TiledPaneGrid::new(panes, *display_area, *viewport);
+            if pane_grid.layout(Direction::Horizontal, cols).is_ok() {
+                let column_difference = cols as isize - display_area.cols as isize;
+                // FIXME: Should the viewport be an Offset?
+                viewport.cols = (viewport.cols as isize + column_difference) as usize;
+                display_area.cols = cols;
+            } else {
+                log::error!("Failed to horizontally resize the tab!!!");
+            }
+            if pane_grid.layout(Direction::Vertical, rows).is_ok() {
+                let row_difference = rows as isize - display_area.rows as isize;
+                viewport.rows = (viewport.rows as isize + row_difference) as usize;
+                display_area.rows = rows;
+            } else {
+                log::error!("Failed to vertically resize the tab!!!");
+            }
+        }
+        self.set_pane_frames(self.draw_pane_frames);
+    }
+    pub fn resize_active_pane_left(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let mut pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            pane_grid.resize_pane_left(&active_pane_id);
+            for pane in self.panes.values_mut() {
+                resize_pty!(pane, &mut self.os_api);
+            }
+        }
+    }
+    pub fn resize_active_pane_right(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let mut pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            pane_grid.resize_pane_right(&active_pane_id);
+            for pane in self.panes.values_mut() {
+                resize_pty!(pane, &mut self.os_api);
+            }
+        }
+    }
+    pub fn resize_active_pane_up(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let mut pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            pane_grid.resize_pane_up(&active_pane_id);
+            for pane in self.panes.values_mut() {
+                resize_pty!(pane, &mut self.os_api);
+            }
+        }
+    }
+    pub fn resize_active_pane_down(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let mut pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            pane_grid.resize_pane_down(&active_pane_id);
+            for pane in self.panes.values_mut() {
+                resize_pty!(pane, &mut self.os_api);
+            }
+        }
+    }
+    pub fn resize_active_pane_increase(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let mut pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            pane_grid.resize_increase(&active_pane_id);
+            for pane in self.panes.values_mut() {
+                resize_pty!(pane, &mut self.os_api);
+            }
+        }
+    }
+    pub fn resize_active_pane_decrease(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let mut pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            pane_grid.resize_decrease(&active_pane_id);
+            for pane in self.panes.values_mut() {
+                resize_pty!(pane, &mut self.os_api);
+            }
+        }
+    }
+    pub fn focus_next_pane(&mut self, client_id: ClientId) {
+        let connected_clients: Vec<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
+        let active_pane_id = self.get_active_pane_id(client_id).unwrap();
+        let pane_grid = TiledPaneGrid::new(
+            &mut self.panes,
+            *self.display_area.borrow(),
+            *self.viewport.borrow(),
+        );
+        let next_active_pane_id = pane_grid.next_selectable_pane_id(&active_pane_id);
+        for client_id in connected_clients {
+            self.active_panes.insert(client_id, next_active_pane_id);
+        }
+        self.set_pane_active_at(next_active_pane_id);
+    }
+    pub fn focus_previous_pane(&mut self, client_id: ClientId) {
+        let connected_clients: Vec<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
+        let active_pane_id = self.get_active_pane_id(client_id).unwrap();
+        let pane_grid = TiledPaneGrid::new(
+            &mut self.panes,
+            *self.display_area.borrow(),
+            *self.viewport.borrow(),
+        );
+        let next_active_pane_id = pane_grid.previous_selectable_pane_id(&active_pane_id);
+        for client_id in connected_clients {
+            self.active_panes.insert(client_id, next_active_pane_id);
+        }
+        self.set_pane_active_at(next_active_pane_id);
+    }
+    fn set_pane_active_at(&mut self, pane_id: PaneId) {
+        if let Some(pane) = self.get_pane_mut(pane_id) {
+            pane.set_active_at(Instant::now());
+        }
+    }
+    pub fn move_focus_left(&mut self, client_id: ClientId) -> bool {
+        match self.get_active_pane_id(client_id) {
+            Some(active_pane_id) => {
+                let pane_grid = TiledPaneGrid::new(
+                    &mut self.panes,
+                    *self.display_area.borrow(),
+                    *self.viewport.borrow(),
+                );
+                let next_index = pane_grid.next_selectable_pane_id_to_the_left(&active_pane_id);
+                match next_index {
+                    Some(p) => {
+                        // render previously active pane so that its frame does not remain actively
+                        // colored
+                        let previously_active_pane = self
+                            .panes
+                            .get_mut(self.active_panes.get(&client_id).unwrap())
+                            .unwrap();
+
+                        previously_active_pane.set_should_render(true);
+                        // we render the full viewport to remove any ui elements that might have been
+                        // there before (eg. another user's cursor)
+                        previously_active_pane.render_full_viewport();
+
+                        let next_active_pane = self.panes.get_mut(&p).unwrap();
+                        next_active_pane.set_should_render(true);
+                        // we render the full viewport to remove any ui elements that might have been
+                        // there before (eg. another user's cursor)
+                        next_active_pane.render_full_viewport();
+
+                        self.focus_pane(p, client_id);
+                        self.set_pane_active_at(p);
+
+                        return true;
+                    }
+                    None => {
+                        return false;
+                    }
+                }
+            }
+            None => {
+                return false;
+            }
+        }
+    }
+    pub fn move_focus_down(&mut self, client_id: ClientId) -> bool {
+        match self.get_active_pane_id(client_id) {
+            Some(active_pane_id) => {
+                let pane_grid = TiledPaneGrid::new(
+                    &mut self.panes,
+                    *self.display_area.borrow(),
+                    *self.viewport.borrow(),
+                );
+                let next_index = pane_grid.next_selectable_pane_id_below(&active_pane_id);
+                match next_index {
+                    Some(p) => {
+                        // render previously active pane so that its frame does not remain actively
+                        // colored
+                        let previously_active_pane = self
+                            .panes
+                            .get_mut(self.active_panes.get(&client_id).unwrap())
+                            .unwrap();
+
+                        previously_active_pane.set_should_render(true);
+                        // we render the full viewport to remove any ui elements that might have been
+                        // there before (eg. another user's cursor)
+                        previously_active_pane.render_full_viewport();
+
+                        let next_active_pane = self.panes.get_mut(&p).unwrap();
+                        next_active_pane.set_should_render(true);
+                        // we render the full viewport to remove any ui elements that might have been
+                        // there before (eg. another user's cursor)
+                        next_active_pane.render_full_viewport();
+
+                        self.focus_pane(p, client_id);
+                        self.set_pane_active_at(p);
+
+                        return true;
+                    }
+                    None => {
+                        return false;
+                    }
+                }
+            }
+            None => {
+                return false;
+            }
+        }
+    }
+    pub fn move_focus_up(&mut self, client_id: ClientId) -> bool {
+        match self.get_active_pane_id(client_id) {
+            Some(active_pane_id) => {
+                let pane_grid = TiledPaneGrid::new(
+                    &mut self.panes,
+                    *self.display_area.borrow(),
+                    *self.viewport.borrow(),
+                );
+                let next_index = pane_grid.next_selectable_pane_id_above(&active_pane_id);
+                match next_index {
+                    Some(p) => {
+                        // render previously active pane so that its frame does not remain actively
+                        // colored
+                        let previously_active_pane = self
+                            .panes
+                            .get_mut(self.active_panes.get(&client_id).unwrap())
+                            .unwrap();
+
+                        previously_active_pane.set_should_render(true);
+                        // we render the full viewport to remove any ui elements that might have been
+                        // there before (eg. another user's cursor)
+                        previously_active_pane.render_full_viewport();
+
+                        let next_active_pane = self.panes.get_mut(&p).unwrap();
+                        next_active_pane.set_should_render(true);
+                        // we render the full viewport to remove any ui elements that might have been
+                        // there before (eg. another user's cursor)
+                        next_active_pane.render_full_viewport();
+
+                        self.focus_pane(p, client_id);
+                        self.set_pane_active_at(p);
+
+                        return true;
+                    }
+                    None => {
+                        return false;
+                    }
+                }
+            }
+            None => {
+                return false;
+            }
+        }
+    }
+    pub fn move_focus_right(&mut self, client_id: ClientId) -> bool {
+        match self.get_active_pane_id(client_id) {
+            Some(active_pane_id) => {
+                let pane_grid = TiledPaneGrid::new(
+                    &mut self.panes,
+                    *self.display_area.borrow(),
+                    *self.viewport.borrow(),
+                );
+                let next_index = pane_grid.next_selectable_pane_id_to_the_right(&active_pane_id);
+                match next_index {
+                    Some(p) => {
+                        // render previously active pane so that its frame does not remain actively
+                        // colored
+                        let previously_active_pane = self
+                            .panes
+                            .get_mut(self.active_panes.get(&client_id).unwrap())
+                            .unwrap();
+
+                        previously_active_pane.set_should_render(true);
+                        // we render the full viewport to remove any ui elements that might have been
+                        // there before (eg. another user's cursor)
+                        previously_active_pane.render_full_viewport();
+
+                        let next_active_pane = self.panes.get_mut(&p).unwrap();
+                        next_active_pane.set_should_render(true);
+                        // we render the full viewport to remove any ui elements that might have been
+                        // there before (eg. another user's cursor)
+                        next_active_pane.render_full_viewport();
+
+                        self.focus_pane(p, client_id);
+                        self.set_pane_active_at(p);
+
+                        return true;
+                    }
+                    None => {
+                        return false;
+                    }
+                }
+            }
+            None => {
+                return false;
+            }
+        }
+    }
+    pub fn move_active_pane(&mut self, client_id: ClientId) {
+        let active_pane_id = self.get_active_pane_id(client_id).unwrap();
+        let pane_grid = TiledPaneGrid::new(
+            &mut self.panes,
+            *self.display_area.borrow(),
+            *self.viewport.borrow(),
+        );
+        let new_position_id = pane_grid.next_selectable_pane_id(&active_pane_id);
+        let current_position = self.panes.get(&active_pane_id).unwrap();
+        let prev_geom = current_position.position_and_size();
+        let prev_geom_override = current_position.geom_override();
+
+        let new_position = self.panes.get_mut(&new_position_id).unwrap();
+        let next_geom = new_position.position_and_size();
+        let next_geom_override = new_position.geom_override();
+        new_position.set_geom(prev_geom);
+        if let Some(geom) = prev_geom_override {
+            new_position.get_geom_override(geom);
+        }
+        resize_pty!(new_position, &mut self.os_api);
+        new_position.set_should_render(true);
+
+        let current_position = self.panes.get_mut(&active_pane_id).unwrap();
+        current_position.set_geom(next_geom);
+        if let Some(geom) = next_geom_override {
+            current_position.get_geom_override(geom);
+        }
+        resize_pty!(current_position, &mut self.os_api);
+        current_position.set_should_render(true);
+    }
+    pub fn move_active_pane_down(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            let next_index = pane_grid.next_selectable_pane_id_below(&active_pane_id);
+            if let Some(p) = next_index {
+                let active_pane_id = self.active_panes.get(&client_id).unwrap();
+                let current_position = self.panes.get(active_pane_id).unwrap();
+                let prev_geom = current_position.position_and_size();
+                let prev_geom_override = current_position.geom_override();
+
+                let new_position = self.panes.get_mut(&p).unwrap();
+                let next_geom = new_position.position_and_size();
+                let next_geom_override = new_position.geom_override();
+                new_position.set_geom(prev_geom);
+                if let Some(geom) = prev_geom_override {
+                    new_position.get_geom_override(geom);
+                }
+                resize_pty!(new_position, &mut self.os_api);
+                new_position.set_should_render(true);
+
+                let current_position = self.panes.get_mut(active_pane_id).unwrap();
+                current_position.set_geom(next_geom);
+                if let Some(geom) = next_geom_override {
+                    current_position.get_geom_override(geom);
+                }
+                resize_pty!(current_position, &mut self.os_api);
+                current_position.set_should_render(true);
+            }
+        }
+    }
+    pub fn move_active_pane_left(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            let next_index = pane_grid.next_selectable_pane_id_to_the_left(&active_pane_id);
+            if let Some(p) = next_index {
+                let active_pane_id = self.active_panes.get(&client_id).unwrap();
+                let current_position = self.panes.get(active_pane_id).unwrap();
+                let prev_geom = current_position.position_and_size();
+                let prev_geom_override = current_position.geom_override();
+
+                let new_position = self.panes.get_mut(&p).unwrap();
+                let next_geom = new_position.position_and_size();
+                let next_geom_override = new_position.geom_override();
+                new_position.set_geom(prev_geom);
+                if let Some(geom) = prev_geom_override {
+                    new_position.get_geom_override(geom);
+                }
+                resize_pty!(new_position, &mut self.os_api);
+                new_position.set_should_render(true);
+
+                let current_position = self.panes.get_mut(active_pane_id).unwrap();
+                current_position.set_geom(next_geom);
+                if let Some(geom) = next_geom_override {
+                    current_position.get_geom_override(geom);
+                }
+                resize_pty!(current_position, &mut self.os_api);
+                current_position.set_should_render(true);
+            }
+        }
+    }
+    pub fn move_active_pane_right(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            let next_index = pane_grid.next_selectable_pane_id_to_the_right(&active_pane_id);
+            if let Some(p) = next_index {
+                let active_pane_id = self.active_panes.get(&client_id).unwrap();
+                let current_position = self.panes.get(active_pane_id).unwrap();
+                let prev_geom = current_position.position_and_size();
+                let prev_geom_override = current_position.geom_override();
+
+                let new_position = self.panes.get_mut(&p).unwrap();
+                let next_geom = new_position.position_and_size();
+                let next_geom_override = new_position.geom_override();
+                new_position.set_geom(prev_geom);
+                if let Some(geom) = prev_geom_override {
+                    new_position.get_geom_override(geom);
+                }
+                resize_pty!(new_position, &mut self.os_api);
+                new_position.set_should_render(true);
+
+                let current_position = self.panes.get_mut(active_pane_id).unwrap();
+                current_position.set_geom(next_geom);
+                if let Some(geom) = next_geom_override {
+                    current_position.get_geom_override(geom);
+                }
+                resize_pty!(current_position, &mut self.os_api);
+                current_position.set_should_render(true);
+            }
+        }
+    }
+    pub fn move_active_pane_up(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            let pane_grid = TiledPaneGrid::new(
+                &mut self.panes,
+                *self.display_area.borrow(),
+                *self.viewport.borrow(),
+            );
+            let next_index = pane_grid.next_selectable_pane_id_above(&active_pane_id);
+            if let Some(p) = next_index {
+                let active_pane_id = self.active_panes.get(&client_id).unwrap();
+                let current_position = self.panes.get(active_pane_id).unwrap();
+                let prev_geom = current_position.position_and_size();
+                let prev_geom_override = current_position.geom_override();
+
+                let new_position = self.panes.get_mut(&p).unwrap();
+                let next_geom = new_position.position_and_size();
+                let next_geom_override = new_position.geom_override();
+                new_position.set_geom(prev_geom);
+                if let Some(geom) = prev_geom_override {
+                    new_position.get_geom_override(geom);
+                }
+                resize_pty!(new_position, &mut self.os_api);
+                new_position.set_should_render(true);
+
+                let current_position = self.panes.get_mut(active_pane_id).unwrap();
+                current_position.set_geom(next_geom);
+                if let Some(geom) = next_geom_override {
+                    current_position.get_geom_override(geom);
+                }
+                resize_pty!(current_position, &mut self.os_api);
+                current_position.set_should_render(true);
+            }
+        }
+    }
+    pub fn move_clients_out_of_pane(&mut self, pane_id: PaneId) {
+        let active_panes: Vec<(ClientId, PaneId)> = self
+            .active_panes
+            .iter()
+            .map(|(cid, pid)| (*cid, *pid))
+            .collect();
+        match self
+            .panes
+            .iter()
+            .find(|(p_id, p)| **p_id != pane_id && p.selectable())
+            .map(|(p_id, _p)| p_id)
+        {
+            Some(next_active_pane) => {
+                for (client_id, active_pane_id) in active_panes {
+                    if active_pane_id == pane_id {
+                        self.active_panes.insert(client_id, *next_active_pane);
+                    }
+                }
+            }
+            None => self.active_panes.clear(),
+        }
+    }
+    pub fn remove_pane(&mut self, pane_id: PaneId) -> Option<Box<dyn Pane>> {
+        let mut pane_grid = TiledPaneGrid::new(
+            &mut self.panes,
+            *self.display_area.borrow(),
+            *self.viewport.borrow(),
+        );
+        if pane_grid.fill_space_over_pane(pane_id) {
+            // successfully filled space over pane
+            let closed_pane = self.panes.remove(&pane_id);
+            self.move_clients_out_of_pane(pane_id);
+            for pane in self.panes.values_mut() {
+                resize_pty!(pane, &mut self.os_api);
+            }
+            closed_pane
+        } else {
+            self.panes.remove(&pane_id);
+            // this is a bit of a roundabout way to say: this is the last pane and so the tab
+            // should be destroyed
+            self.active_panes.clear();
+            None
+        }
+    }
+    pub fn panes_to_hide_contains(&self, pane_id: PaneId) -> bool {
+        self.panes_to_hide.contains(&pane_id)
+    }
+    pub fn fullscreen_is_active(&self) -> bool {
+        self.fullscreen_is_active
+    }
+    pub fn unset_fullscreen(&mut self) {
+        if self.fullscreen_is_active {
+            let first_client_id = {
+                let connected_clients = self.connected_clients.borrow();
+                *connected_clients.iter().next().unwrap()
+            };
+            let active_pane_id = self.get_active_pane_id(first_client_id).unwrap();
+            let panes_to_hide: Vec<_> = self.panes_to_hide.iter().copied().collect();
+            for pane_id in panes_to_hide {
+                let pane = self.get_pane_mut(pane_id).unwrap();
+                pane.set_should_render(true);
+                pane.set_should_render_boundaries(true);
+            }
+            let viewport_pane_ids: Vec<_> = self
+                .panes
+                .keys()
+                .copied()
+                .into_iter()
+                .filter(|id| {
+                    !is_inside_viewport(&*self.viewport.borrow(), self.get_pane(*id).unwrap())
+                })
+                .collect();
+            for pid in viewport_pane_ids {
+                let viewport_pane = self.get_pane_mut(pid).unwrap();
+                viewport_pane.reset_size_and_position_override();
+            }
+            self.panes_to_hide.clear();
+            let active_terminal = self.get_pane_mut(active_pane_id).unwrap();
+            active_terminal.reset_size_and_position_override();
+            self.set_force_render();
+            let display_area = *self.display_area.borrow();
+            self.resize(display_area);
+            self.fullscreen_is_active = false;
+        }
+    }
+    pub fn toggle_active_pane_fullscreen(&mut self, client_id: ClientId) {
+        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+            if self.fullscreen_is_active {
+                self.unset_fullscreen();
+            } else {
+                let pane_ids_to_hide = self.panes.iter().filter_map(|(&id, _pane)| {
+                    if id != active_pane_id
+                        && is_inside_viewport(&*self.viewport.borrow(), self.get_pane(id).unwrap())
+                    {
+                        Some(id)
+                    } else {
+                        None
+                    }
+                });
+                self.panes_to_hide = pane_ids_to_hide.collect();
+                if self.panes_to_hide.is_empty() {
+                    // nothing to do, pane is already as fullscreen as it can be, let's bail
+                    return;
+                } else {
+                    // For all of the panes outside of the viewport staying on the fullscreen
+                    // screen, switch them to using override positions as well so that the resize
+                    // system doesn't get confused by viewport and old panes that no longer line up
+                    let viewport_pane_ids: Vec<_> = self
+                        .panes
+                        .keys()
+                        .copied()
+                        .into_iter()
+                        .filter(|id| {
+                            !is_inside_viewport(
+                                &*self.viewport.borrow(),
+                                self.get_pane(*id).unwrap(),
+                            )
+                        })
+                        .collect();
+                    for pid in viewport_pane_ids {
+                        let viewport_pane = self.get_pane_mut(pid).unwrap();
+                        viewport_pane.get_geom_override(viewport_pane.position_and_size());
+                    }
+                    let viewport = { *self.viewport.borrow() };
+                    let active_terminal = self.get_pane_mut(active_pane_id).unwrap();
+                    let full_screen_geom = PaneGeom {
+                        x: viewport.x,
+                        y: viewport.y,
+                        ..Default::default()
+                    };
+                    active_terminal.get_geom_override(full_screen_geom);
+                }
+                let connected_client_list: Vec<ClientId> =
+                    { self.connected_clients.borrow().iter().copied().collect() };
+                for client_id in connected_client_list {
+                    self.focus_pane(active_pane_id, client_id);
+                }
+                self.set_force_render();
+                let display_area = *self.display_area.borrow();
+                self.resize(display_area);
+                self.fullscreen_is_active = true;
+            }
+        }
+    }
+    pub fn panes_to_hide_count(&self) -> usize {
+        self.panes_to_hide.len()
+    }
+}
+
+#[allow(clippy::borrowed_box)]
+pub fn is_inside_viewport(viewport: &Viewport, pane: &Box<dyn Pane>) -> bool {
+    let pane_position_and_size = pane.current_geom();
+    pane_position_and_size.y >= viewport.y
+        && pane_position_and_size.y + pane_position_and_size.rows.as_usize()
+            <= viewport.y + viewport.rows
+}
+
+pub fn pane_geom_is_inside_viewport(viewport: &Viewport, geom: &PaneGeom) -> bool {
+    geom.y >= viewport.y
+        && geom.y + geom.rows.as_usize() <= viewport.y + viewport.rows
+        && geom.x >= viewport.x
+        && geom.x + geom.cols.as_usize() <= viewport.x + viewport.cols
+}
diff --git a/zellij-server/src/tab/pane_resizer.rs b/zellij-server/src/panes/tiled_panes/pane_resizer.rs
index 7264c49a..7264c49a 100644
--- a/zellij-server/src/tab/pane_resizer.rs
+++ b/zellij-server/src/panes/tiled_panes/pane_resizer.rs
diff --git a/zellij-server/src/tab/tiled_pane_grid.rs b/zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs
index 827c5771..5bbaf65a 100644
--- a/zellij-server/src/tab/tiled_pane_grid.rs
+++ b/zellij-server/src/panes/tiled_panes/tiled_pane_grid.rs
@@ -1,5 +1,6 @@
+use super::is_inside_viewport;
 use super::pane_resizer::PaneResizer;
-use crate::tab::{is_inside_viewport, MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH};
+use crate::tab::{MIN_TERMINAL_HEIGHT, MIN_TERMINAL_WIDTH};
 use crate::{panes::PaneId, tab::Pane};
 use std::cmp::Reverse;
 use std::collections::{HashMap, HashSet};
diff --git a/zellij-server/src/screen.rs b/zellij-server/src/screen.rs
index 5a3f0279..8ba6cccf 100644
--- a/zellij-server/src/screen.rs
+++ b/zellij-server/src/screen.rs
@@ -428,7 +428,7 @@ impl Screen {
         let size = self.size;
         let overlay = self.overlay.clone();
         for (tab_index, tab) in &mut self.tabs {
-            if tab.has_active_panes() {
+            if tab.has_selectable_panes() {
                 let vte_overlay = overlay.generate_overlay(size);
                 tab.render(&mut output, Some(vte_overlay));
             } else {
@@ -567,11 +567,9 @@ impl Screen {
     }
     pub fn remove_client(&mut self, client_id: ClientId) {
         self.tabs.iter_mut().for_each(|(_, tab)| {
-            if tab.active_panes.get(&client_id).is_some() {
-                tab.remove_client(client_id);
-                if tab.has_no_connected_clients() {
-                    tab.visible(false);
-                }
+            tab.remove_client(client_id);
+            if tab.has_no_connected_clients() {
+                tab.visible(false);
             }
         });
         if self.active_tab_indices.contains_key(&client_id) {
@@ -604,7 +602,7 @@ impl Screen {
                     position: tab.position,
                     name: tab.name.clone(),
                     active: *active_tab_index == tab.index,
-                    panes_to_hide: tab.panes_to_hide.len(),
+                    panes_to_hide: tab.panes_to_hide_count(),
                     is_fullscreen_active: tab.is_fullscreen_active(),
                     is_sync_panes_active: tab.is_sync_panes_active(),
                     are_floating_panes_visible: tab.are_floating_panes_visible(),
@@ -874,7 +872,7 @@ pub(crate) fn screen_thread_main(
                 screen
                     .get_active_tab_mut(client_id)
                     .unwrap()
-                    .move_focus(client_id);
+                    .focus_next_pane(client_id);
 
                 screen.render();
             }
diff --git a/zellij-server/src/tab/mod.rs b/zellij-server/src/tab/mod.rs
index e33141f6..18a6ef72 100644
--- a/zellij-server/src/tab/mod.rs
+++ b/zellij-server/src/tab/mod.rs
@@ -3,9 +3,6 @@
 
 mod clipboard;
 mod copy_command;
-pub mod floating_pane_grid;
-pub mod pane_resizer;
-pub mod tiled_pane_grid;
 
 use copy_command::CopyCommand;
 use zellij_utils::input::options::Clipboard;
@@ -13,37 +10,33 @@ use zellij_utils::position::{Column, Line};
 use zellij_utils::{position::Position, serde, zellij_tile};
 
 use crate::ui::pane_boundaries_frame::FrameParams;
-use tiled_pane_grid::{split, TiledPaneGrid};
 
 use self::clipboard::ClipboardProvider;
 use crate::{
     os_input_output::ServerOsApi,
     output::{CharacterChunk, Output},
-    panes::FloatingPanes,
+    panes::{FloatingPanes, TiledPanes},
     panes::{LinkHandler, PaneId, PluginPane, TerminalPane},
     pty::{ClientOrTabIndex, PtyInstruction, VteBytes},
     thread_bus::ThreadSenders,
-    ui::boundaries::Boundaries,
-    ui::pane_contents_and_ui::PaneContentsAndUi,
     wasm_vm::PluginInstruction,
     ClientId, ServerInstruction,
 };
 use serde::{Deserialize, Serialize};
 use std::cell::RefCell;
-use std::cmp::Reverse;
 use std::os::unix::io::RawFd;
 use std::rc::Rc;
 use std::sync::mpsc::channel;
 use std::time::Instant;
 use std::{
-    collections::{BTreeMap, HashMap, HashSet},
+    collections::{HashMap, HashSet},
     str,
 };
 use zellij_tile::data::{Event, InputMode, ModeInfo, Palette, PaletteColor};
 use zellij_utils::{
     input::{
         command::TerminalAction,
-        layout::{Direction, Layout, Run},
+        layout::{Layout, Run},
         parse_keys,
     },
     pane_size::{Offset, PaneGeom, Size, Viewport},
@@ -69,48 +62,24 @@ pub const MIN_TERMINAL_WIDTH: usize = 5;
 
 const MAX_PENDING_VTE_EVENTS: usize = 7000;
 
-fn pane_content_offset(position_and_size: &PaneGeom, viewport: &Viewport) -> (usize, usize) {
-    // (columns_offset, rows_offset)
-    // if the pane is not on the bottom or right edge on the screen, we need to reserve one space
-    // from its content to leave room for the boundary between it and the next pane (if it doesn't
-    // draw its own frame)
-    let columns_offset = if position_and_size.x + position_and_size.cols.as_usize() < viewport.cols
-    {
-        1
-    } else {
-        0
-    };
-    let rows_offset = if position_and_size.y + position_and_size.rows.as_usize() < viewport.rows {
-        1
-    } else {
-        0
-    };
-    (columns_offset, rows_offset)
-}
-
 pub(crate) struct Tab {
     pub index: usize,
     pub position: usize,
     pub name: String,
-    panes: BTreeMap<PaneId, Box<dyn Pane>>,
+    tiled_panes: TiledPanes,
     floating_panes: FloatingPanes,
-    pub panes_to_hide: HashSet<PaneId>,
-    pub active_panes: HashMap<ClientId, PaneId>,
     max_panes: Option<usize>,
     viewport: Rc<RefCell<Viewport>>, // includes all non-UI panes
     display_area: Rc<RefCell<Size>>, // includes all panes (including eg. the status bar and tab bar in the default layout)
-    fullscreen_is_active: bool,
     os_api: Box<dyn ServerOsApi>,
     pub senders: ThreadSenders,
     synchronize_is_active: bool,
     should_clear_display_before_rendering: bool,
-    mode_info: HashMap<ClientId, ModeInfo>,
+    mode_info: Rc<RefCell<HashMap<ClientId, ModeInfo>>>,
     default_mode_info: ModeInfo,
     pub colors: Palette,
-    connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>, // TODO: combine this and connected_clients
-    connected_clients: HashSet<ClientId>,
+    connected_clients: Rc<RefCell<HashSet<ClientId>>>,
     draw_pane_frames: bool,
-    session_is_mirrored: bool,
     pending_vte_events: HashMap<RawFd, Vec<VteBytes>>,
     pub selecting_with_mouse: bool, // this is only pub for the tests TODO: remove this once we combine write_text_to_clipboard with render
     link_handler: Rc<RefCell<LinkHandler>>,
@@ -303,7 +272,7 @@ impl Tab {
         os_api: Box<dyn ServerOsApi>,
         senders: ThreadSenders,
         max_panes: Option<usize>,
-        mode_info: ModeInfo,
+        default_mode_info: ModeInfo,
         colors: Palette,
         draw_pane_frames: bool,
         connected_clients_in_app: Rc<RefCell<HashSet<ClientId>>>,
@@ -312,8 +281,6 @@ impl Tab {
         copy_command: Option<String>,
         copy_clipboard: Clipboard,
     ) -> Self {
-        let panes = BTreeMap::new();
-
         let name = if name.is_empty() {
             format!("Tab #{}", index + 1)
         } else {
@@ -325,7 +292,31 @@ impl Tab {
         let viewport: Viewport = display_area.into();
         let viewport = Rc::new(RefCell::new(viewport));
         let display_area = Rc::new(RefCell::new(display_area));
-        let floating_panes = FloatingPanes::new(display_area.clone(), viewport.clone());
+        let connected_clients = Rc::new(RefCell::new(connected_clients));
+        let mode_info = Rc::new(RefCell::new(HashMap::new()));
+
+        let tiled_panes = TiledPanes::new(
+            display_area.clone(),
+            viewport.clone(),
+            connected_clients.clone(),
+            connected_clients_in_app.clone(),
+            mode_info.clone(),
+            session_is_mirrored,
+            draw_pane_frames,
+            default_mode_info.clone(),
+            colors,
+            os_api.clone(),
+        );
+        let floating_panes = FloatingPanes::new(
+            display_area.clone(),
+            viewport.clone(),
+            connected_clients.clone(),
+            connected_clients_in_app.clone(),
+            mode_info.clone(),
+            session_is_mirrored,
+            default_mode_info.clone(),
+            colors,
+        );
 
         let clipboard_provider = match copy_command {
             Some(command) => ClipboardProvider::Command(CopyCommand::new(command)),
@@ -335,26 +326,21 @@ impl Tab {
         Tab {
             index,
             position,
-            panes,
+            tiled_panes,
             floating_panes,
             name,
             max_panes,
-            panes_to_hide: HashSet::new(),
-            active_panes: HashMap::new(),
             viewport,
             display_area,
-            fullscreen_is_active: false,
             synchronize_is_active: false,
             os_api,
             senders,
             should_clear_display_before_rendering: false,
-            mode_info: HashMap::new(),
-            default_mode_info: mode_info,
+            mode_info,
+            default_mode_info,
             colors,
             draw_pane_frames,
-            session_is_mirrored,
             pending_vte_events: HashMap::new(),
-            connected_clients_in_app,
             connected_clients,
             selecting_with_mouse: false,
             link_handler: Rc::new(RefCell::new(LinkHandler::new())),
@@ -370,7 +356,11 @@ impl Tab {
         tab_index: usize,
         client_id: ClientId,
     ) {
-        // TODO: this should be an attribute on Screen instead of full_screen_ws
+        if self.tiled_panes.has_panes() {
+            log::error!(
+                "Applying a layout to a tab with existing panes - this is not yet supported!"
+            );
+        }
         let (viewport_cols, viewport_rows) = {
             let viewport = self.viewport.borrow();
             (viewport.cols, viewport.rows)
@@ -379,26 +369,9 @@ impl Tab {
         free_space.cols.set_inner(viewport_cols);
         free_space.rows.set_inner(viewport_rows);
 
-        self.panes_to_hide.clear();
         let positions_in_layout = layout.position_panes_in_space(&free_space);
 
-        let mut positions_and_size = positions_in_layout.iter();
-        for (pane_kind, terminal_pane) in &mut self.panes {
-            // for now the layout only supports terminal panes
-            if let PaneId::Terminal(pid) = pane_kind {
-                match positions_and_size.next() {
-                    Some(&(_, position_and_size)) => {
-                        terminal_pane.reset_size_and_position_override();
-                        terminal_pane.set_geom(position_and_size);
-                    }
-                    None => {
-                        // we filled the entire layout, no room for this pane
-                        // TODO: handle active terminal
-                        self.panes_to_hide.insert(PaneId::Terminal(*pid));
-                    }
-                }
-            }
-        }
+        let positions_and_size = positions_in_layout.iter();
         let mut new_pids = new_pids.iter();
 
         let mut focus_pane_id: Option<PaneId> = None;
@@ -425,7 +398,8 @@ impl Tab {
                     layout.pane_name.clone().unwrap_or_default(),
                 );
                 new_plugin.set_borderless(layout.borderless);
-                self.panes.insert(PaneId::Plugin(pid), Box::new(new_plugin));
+                self.tiled_panes
+                    .add_pane_with_existing_geom(PaneId::Plugin(pid), Box::new(new_plugin));
                 set_focus_pane_id(layout, PaneId::Plugin(pid));
             } else {
                 // there are still panes left to fill, use the pids we received in this method
@@ -440,8 +414,8 @@ impl Tab {
                     self.link_handler.clone(),
                 );
                 new_pane.set_borderless(layout.borderless);
-                self.panes
-                    .insert(PaneId::Terminal(*pid), Box::new(new_pane));
+                self.tiled_panes
+                    .add_pane_with_existing_geom(PaneId::Terminal(*pid), Box::new(new_pane));
                 set_focus_pane_id(layout, PaneId::Terminal(*pid));
             }
         }
@@ -460,59 +434,35 @@ impl Tab {
             *display_area
         };
         self.resize_whole_tab(display_area);
-        let boundary_geom: Vec<_> = self
-            .panes
-            .values()
-            .filter_map(|p| {
-                let geom = p.position_and_size();
-                if geom.cols.is_fixed() || geom.rows.is_fixed() {
-                    Some(geom.into())
-                } else {
-                    None
-                }
-            })
-            .collect();
-        for geom in boundary_geom {
+        let boundary_geoms = self.tiled_panes.fixed_pane_geoms();
+        for geom in boundary_geoms {
             self.offset_viewport(&geom)
         }
-        self.set_pane_frames(self.draw_pane_frames);
-
-        let mut active_pane = |pane_id: PaneId| {
-            let connected_clients: Vec<ClientId> = self.connected_clients.iter().copied().collect();
-            for client_id in connected_clients {
-                self.active_panes.insert(client_id, pane_id);
-            }
-        };
+        self.tiled_panes.set_pane_frames(self.draw_pane_frames);
+        self.should_clear_display_before_rendering = true;
 
         if let Some(pane_id) = focus_pane_id {
             self.focus_pane_id = Some(pane_id);
-            active_pane(pane_id);
+            self.tiled_panes.focus_pane(pane_id, client_id);
         } else {
             // This is the end of the nasty viewport hack...
-            let next_selectable_pane_id = self
-                .panes
-                .iter()
-                .filter(|(_id, pane)| pane.selectable())
-                .map(|(id, _)| id.to_owned())
-                .next();
+            let next_selectable_pane_id = self.tiled_panes.first_selectable_pane_id();
             match next_selectable_pane_id {
                 Some(active_pane_id) => {
-                    active_pane(active_pane_id);
+                    self.tiled_panes.focus_pane(active_pane_id, client_id);
                 }
                 None => {
                     // this is very likely a configuration error (layout with no selectable panes)
-                    self.active_panes.clear();
+                    self.tiled_panes.clear_active_panes();
                 }
             }
         }
     }
     pub fn update_input_modes(&mut self) {
         // this updates all plugins with the client's input mode
-        for client_id in &self.connected_clients {
-            let mode_info = self
-                .mode_info
-                .get(client_id)
-                .unwrap_or(&self.default_mode_info);
+        let mode_infos = self.mode_info.borrow();
+        for client_id in self.connected_clients.borrow().iter() {
+            let mode_info = mode_infos.get(client_id).unwrap_or(&self.default_mode_info);
             self.senders
                 .send_to_plugin(PluginInstruction::Update(
                     None,
@@ -523,64 +473,58 @@ impl Tab {
         }
     }
     pub fn add_client(&mut self, client_id: ClientId, mode_info: Option<ModeInfo>) {
-        let first_connected_client = self.connected_clients.iter().next();
-        match first_connected_client {
-            Some(first_client_id) => {
-                let first_active_pane_id = *self.active_panes.get(first_client_id).unwrap();
-                if self.floating_panes.panes_are_visible() {
-                    if let Some(first_active_floating_pane_id) =
-                        self.floating_panes.first_active_floating_pane_id()
-                    {
-                        self.floating_panes
-                            .focus_pane(first_active_floating_pane_id, client_id);
-                    }
-                }
-                self.connected_clients.insert(client_id);
-                self.active_panes.insert(client_id, first_active_pane_id);
-                self.mode_info.insert(
-                    client_id,
-                    mode_info.unwrap_or_else(|| self.default_mode_info.clone()),
-                );
+        let other_clients_exist_in_tab = { !self.connected_clients.borrow().is_empty() };
+        if other_clients_exist_in_tab {
+            if let Some(first_active_floating_pane_id) =
+                self.floating_panes.first_active_floating_pane_id()
+            {
+                self.floating_panes
+                    .focus_pane(first_active_floating_pane_id, client_id);
             }
-            None => {
-                let mut pane_ids: Vec<PaneId> = self.panes.keys().copied().collect();
-                if pane_ids.is_empty() {
-                    // no panes here, bye bye
-                    return;
-                }
-                self.active_panes.insert(
-                    client_id,
-                    self.focus_pane_id.unwrap_or_else(|| {
-                        pane_ids.sort(); // TODO: make this predictable
-                        pane_ids.retain(|p| !self.panes_to_hide.contains(p));
-                        *pane_ids.get(0).unwrap()
-                    }),
-                );
-                self.connected_clients.insert(client_id);
-                self.mode_info.insert(
-                    client_id,
-                    mode_info.unwrap_or_else(|| self.default_mode_info.clone()),
-                );
+            if let Some(first_active_tiled_pane_id) = self.tiled_panes.first_active_pane_id() {
+                self.tiled_panes
+                    .focus_pane(first_active_tiled_pane_id, client_id);
+            }
+            self.connected_clients.borrow_mut().insert(client_id);
+            self.mode_info.borrow_mut().insert(
+                client_id,
+                mode_info.unwrap_or_else(|| self.default_mode_info.clone()),
+            );
+        } else {
+            let mut pane_ids: Vec<PaneId> = self.tiled_panes.pane_ids().copied().collect();
+            if pane_ids.is_empty() {
+                // no panes here, bye bye
+                return;
             }
+            let focus_pane_id = self.focus_pane_id.unwrap_or_else(|| {
+                pane_ids.sort(); // TODO: make this predictable
+                pane_ids.retain(|p| !self.tiled_panes.panes_to_hide_contains(*p));
+                *pane_ids.get(0).unwrap()
+            });
+            self.tiled_panes.focus_pane(focus_pane_id, client_id);
+            self.connected_clients.borrow_mut().insert(client_id);
+            self.mode_info.borrow_mut().insert(
+                client_id,
+                mode_info.unwrap_or_else(|| self.default_mode_info.clone()),
+            );
         }
-        // TODO: we might be able to avoid this, we do this so that newly connected clients will
-        // necessarily get a full render
         self.set_force_render();
         self.update_input_modes();
     }
     pub fn change_mode_info(&mut self, mode_info: ModeInfo, client_id: ClientId) {
-        self.mode_info.insert(client_id, mode_info);
+        self.mode_info.borrow_mut().insert(client_id, mode_info);
     }
     pub fn add_multiple_clients(&mut self, client_ids_to_mode_infos: Vec<(ClientId, ModeInfo)>) {
         for (client_id, client_mode_info) in client_ids_to_mode_infos {
             self.add_client(client_id, None);
-            self.mode_info.insert(client_id, client_mode_info);
+            self.mode_info
+                .borrow_mut()
+                .insert(client_id, client_mode_info);
         }
     }
     pub fn remove_client(&mut self, client_id: ClientId) {
         self.focus_pane_id = None;
-        self.active_panes.remove(&client_id);
-        self.connected_clients.remove(&client_id);
+        self.connected_clients.borrow_mut().remove(&client_id);
         self.set_force_render();
     }
     pub fn drain_connected_clients(
@@ -589,8 +533,8 @@ impl Tab {
     ) -> Vec<(ClientId, ModeInfo)> {
         // None => all clients
         let mut client_ids_to_mode_infos = vec![];
-        let clients_to_drain =
-            clients_to_drain.unwrap_or_else(|| self.connected_clients.drain().collect());
+        let clients_to_drain = clients_to_drain
+            .unwrap_or_else(|| self.connected_clients.borrow_mut().drain().collect());
         for client_id in clients_to_drain {
             client_ids_to_mode_infos.push(self.drain_single_client(client_id));
         }
@@ -599,63 +543,32 @@ impl Tab {
     pub fn drain_single_client(&mut self, client_id: ClientId) -> (ClientId, ModeInfo) {
         let client_mode_info = self
             .mode_info
+            .borrow_mut()
             .remove(&client_id)
             .unwrap_or_else(|| self.default_mode_info.clone());
-        self.connected_clients.remove(&client_id);
+        self.connected_clients.borrow_mut().remove(&client_id);
         (client_id, client_mode_info)
     }
     pub fn has_no_connected_clients(&self) -> bool {
-        self.connected_clients.is_empty()
+        self.connected_clients.borrow().is_empty()
     }
     pub fn toggle_pane_embed_or_floating(&mut self, client_id: ClientId) {
         if self.floating_panes.panes_are_visible() {
             if let Some(focused_floating_pane_id) = self.floating_panes.active_pane_id(client_id) {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let terminal_id_and_split_direction = pane_grid.find_room_for_new_pane();
-                if let Some((terminal_id_to_split, split_direction)) =
-                    terminal_id_and_split_direction
-                {
+                if self.tiled_panes.has_room_for_new_pane() {
                     // this unwrap is safe because floating panes should not be visible if there are no floating panes
-                    let mut floating_pane_to_embed =
-                        self.close_pane(focused_floating_pane_id).unwrap();
-                    let pane_to_split = self.panes.get_mut(&terminal_id_to_split).unwrap();
-                    let size_of_both_panes = pane_to_split.position_and_size();
-                    if let Some((first_geom, second_geom)) =
-                        split(split_direction, &size_of_both_panes)
-                    {
-                        pane_to_split.set_geom(first_geom);
-                        floating_pane_to_embed.set_geom(second_geom);
-                        self.panes
-                            .insert(focused_floating_pane_id, floating_pane_to_embed);
-                        // ¯\_(ツ)_/¯
-                        let relayout_direction = match split_direction {
-                            Direction::Vertical => Direction::Horizontal,
-                            Direction::Horizontal => Direction::Vertical,
-                        };
-                        self.relayout_tab(relayout_direction);
-                    }
-                    if self.session_is_mirrored {
-                        // move all clients
-                        let connected_clients: Vec<ClientId> =
-                            self.connected_clients.iter().copied().collect();
-                        for client_id in connected_clients {
-                            self.active_panes
-                                .insert(client_id, focused_floating_pane_id);
-                        }
-                    } else {
-                        self.active_panes
-                            .insert(client_id, focused_floating_pane_id);
-                    }
+                    let floating_pane_to_embed = self.close_pane(focused_floating_pane_id).unwrap();
+                    self.tiled_panes
+                        .insert_pane(focused_floating_pane_id, floating_pane_to_embed);
+                    self.should_clear_display_before_rendering = true;
+                    self.tiled_panes
+                        .focus_pane(focused_floating_pane_id, client_id);
                     self.floating_panes.toggle_show_panes(false);
                 }
             }
-        } else if let Some(focused_pane_id) = self.active_panes.get(&client_id).copied() {
+        } else if let Some(focused_pane_id) = self.tiled_panes.focused_pane_id(client_id) {
             if let Some(new_pane_geom) = self.floating_panes.find_room_for_new_pane() {
-                if self.get_selectable_panes().count() <= 1 {
+                if self.get_selectable_tiled_panes().count() <= 1 {
                     // don't close the only pane on screen...
                     return;
                 }
@@ -665,14 +578,8 @@ impl Tab {
                     embedded_pane_to_float.set_active_at(Instant::now());
                     self.floating_panes
                         .add_pane(focused_pane_id, embedded_pane_to_float);
+                    self.floating_panes.focus_pane(focused_pane_id, client_id);
                     self.floating_panes.toggle_show_panes(true);
-                    // move all clients
-                    let connected_clients: Vec<ClientId> =
-                        self.connected_clients.iter().copied().collect();
-                    for client_id in connected_clients {
-                        self.floating_panes.focus_pane(focused_pane_id, client_id);
-                    }
-                    self.floating_panes.set_force_render();
                 }
             }
         }
@@ -733,165 +640,102 @@ impl Tab {
                     new_pane.set_content_offset(Offset::frame(1)); // floating panes always have a frame
                     resize_pty!(new_pane, self.os_api);
                     self.floating_panes.add_pane(pid, Box::new(new_pane));
-                    // move all clients to new floating pane
-                    let connected_clients: Vec<ClientId> =
-                        self.connected_clients.iter().copied().collect();
-                    for client_id in connected_clients {
-                        self.floating_panes.focus_pane(pid, client_id);
-                    }
+                    self.floating_panes.focus_pane_for_all_clients(pid);
                 }
             }
         } else {
-            if self.fullscreen_is_active {
-                self.unset_fullscreen();
+            if self.tiled_panes.fullscreen_is_active() {
+                self.tiled_panes.unset_fullscreen();
             }
-            let pane_grid = TiledPaneGrid::new(
-                &mut self.panes,
-                *self.display_area.borrow(),
-                *self.viewport.borrow(),
-            );
-            let terminal_id_and_split_direction = pane_grid.find_room_for_new_pane();
-            if let Some((terminal_id_to_split, split_direction)) = terminal_id_and_split_direction {
-                let next_terminal_position = self.get_next_terminal_position();
-                let terminal_to_split = self.panes.get_mut(&terminal_id_to_split).unwrap();
-                let terminal_ws = terminal_to_split.position_and_size();
+            if self.tiled_panes.has_room_for_new_pane() {
                 if let PaneId::Terminal(term_pid) = pid {
-                    if let Some((first_winsize, second_winsize)) =
-                        split(split_direction, &terminal_ws)
-                    {
-                        let new_terminal = TerminalPane::new(
-                            term_pid,
-                            second_winsize,
-                            self.colors,
-                            next_terminal_position,
-                            String::new(),
-                            self.link_handler.clone(),
-                        );
-                        terminal_to_split.set_geom(first_winsize);
-                        self.panes.insert(pid, Box::new(new_terminal));
-                        // ¯\_(ツ)_/¯
-                        let relayout_direction = match split_direction {
-                            Direction::Vertical => Direction::Horizontal,
-                            Direction::Horizontal => Direction::Vertical,
-                        };
-                        self.relayout_tab(relayout_direction);
-                    }
-                }
-                if let Some(client_id) = client_id {
-                    if self.session_is_mirrored {
-                        // move all clients
-                        let connected_clients: Vec<ClientId> =
-                            self.connected_clients.iter().copied().collect();
-                        for client_id in connected_clients {
-                            self.active_panes.insert(client_id, pid);
-                        }
-                    } else {
-                        self.active_panes.insert(client_id, pid);
+                    let next_terminal_position = self.get_next_terminal_position();
+                    let new_terminal = TerminalPane::new(
+                        term_pid,
+                        PaneGeom::default(), // the initial size will be set later
+                        self.colors,
+                        next_terminal_position,
+                        String::new(),
+                        self.link_handler.clone(),
+                    );
+                    self.tiled_panes.insert_pane(pid, Box::new(new_terminal));
+                    self.should_clear_display_before_rendering = true;
+                    if let Some(client_id) = client_id {
+                        self.tiled_panes.focus_pane(pid, client_id);
                     }
                 }
             }
         }
     }
     pub fn horizontal_split(&mut self, pid: PaneId, client_id: ClientId) {
+        if self.floating_panes.panes_are_visible() {
+            return;
+        }
         self.close_down_to_max_terminals();
-        if self.fullscreen_is_active {
+        if self.tiled_panes.fullscreen_is_active() {
             self.toggle_active_pane_fullscreen(client_id);
         }
-        if let PaneId::Terminal(term_pid) = pid {
-            let next_terminal_position = self.get_next_terminal_position();
-            let active_pane_id = &self.get_active_pane_id(client_id).unwrap();
-            let active_pane = self.panes.get_mut(active_pane_id).unwrap();
-            if active_pane.rows() < MIN_TERMINAL_HEIGHT * 2 {
-                self.senders
-                    .send_to_pty(PtyInstruction::ClosePane(pid)) // we can't open this pane, close the pty
-                    .unwrap();
-                return;
-            }
-            let terminal_ws = active_pane.position_and_size();
-            if let Some((top_winsize, bottom_winsize)) = split(Direction::Horizontal, &terminal_ws)
-            {
+        if self.tiled_panes.can_split_pane_horizontally(client_id) {
+            if let PaneId::Terminal(term_pid) = pid {
+                let next_terminal_position = self.get_next_terminal_position();
                 let new_terminal = TerminalPane::new(
                     term_pid,
-                    bottom_winsize,
+                    PaneGeom::default(), // the initial size will be set later
                     self.colors,
                     next_terminal_position,
                     String::new(),
                     self.link_handler.clone(),
                 );
-                active_pane.set_geom(top_winsize);
-                self.panes.insert(pid, Box::new(new_terminal));
-
-                if self.session_is_mirrored {
-                    // move all clients
-                    let connected_clients: Vec<ClientId> =
-                        self.connected_clients.iter().copied().collect();
-                    for client_id in connected_clients {
-                        self.active_panes.insert(client_id, pid);
-                    }
-                } else {
-                    self.active_panes.insert(client_id, pid);
-                }
-
-                self.relayout_tab(Direction::Vertical);
+                self.tiled_panes
+                    .split_pane_horizontally(pid, Box::new(new_terminal), client_id);
+                self.should_clear_display_before_rendering = true;
+                self.tiled_panes.focus_pane(pid, client_id);
             }
         }
     }
     pub fn vertical_split(&mut self, pid: PaneId, client_id: ClientId) {
+        if self.floating_panes.panes_are_visible() {
+            return;
+        }
         self.close_down_to_max_terminals();
-        if self.fullscreen_is_active {
+        if self.tiled_panes.fullscreen_is_active() {
             self.toggle_active_pane_fullscreen(client_id);
         }
-        if let PaneId::Terminal(term_pid) = pid {
-            // TODO: check minimum size of active terminal
-            let next_terminal_position = self.get_next_terminal_position();
-            let active_pane_id = &self.get_active_pane_id(client_id).unwrap();
-            let active_pane = self.panes.get_mut(active_pane_id).unwrap();
-            if active_pane.cols() < MIN_TERMINAL_WIDTH * 2 {
-                self.senders
-                    .send_to_pty(PtyInstruction::ClosePane(pid)) // we can't open this pane, close the pty
-                    .unwrap();
-                return;
-            }
-            let terminal_ws = active_pane.position_and_size();
-            if let Some((left_winsize, right_winsize)) = split(Direction::Vertical, &terminal_ws) {
+        if self.tiled_panes.can_split_pane_vertically(client_id) {
+            if let PaneId::Terminal(term_pid) = pid {
+                let next_terminal_position = self.get_next_terminal_position();
                 let new_terminal = TerminalPane::new(
                     term_pid,
-                    right_winsize,
+                    PaneGeom::default(), // the initial size will be set later
                     self.colors,
                     next_terminal_position,
                     String::new(),
                     self.link_handler.clone(),
                 );
-                active_pane.set_geom(left_winsize);
-                self.panes.insert(pid, Box::new(new_terminal));
+                self.tiled_panes
+                    .split_pane_vertically(pid, Box::new(new_terminal), client_id);
+                self.should_clear_display_before_rendering = true;
+                self.tiled_panes.focus_pane(pid, client_id);
             }
-            if self.session_is_mirrored {
-                // move all clients
-                let connected_clients: Vec<ClientId> =
-                    self.connected_clients.iter().copied().collect();
-                for client_id in connected_clients {
-                    self.active_panes.insert(client_id, pid);
-                }
-            } else {
-                self.active_panes.insert(client_id, pid);
-            }
-
-            self.relayout_tab(Direction::Horizontal);
         }
     }
-    pub fn has_active_panes(&self) -> bool {
-        // a tab without active panes is a dead tab and should close
-        // a pane can be active even if there are no connected clients,
-        // we remember that pane for one the client focuses the tab next
-        !self.active_panes.is_empty()
-    }
     pub fn get_active_pane(&self, client_id: ClientId) -> Option<&dyn Pane> {
-        self.get_active_pane_id(client_id)
-            .and_then(|ap| self.panes.get(&ap).map(Box::as_ref))
+        self.get_active_pane_id(client_id).and_then(|ap| {
+            if self.floating_panes.panes_are_visible() {
+                self.floating_panes.get_pane(ap).map(Box::as_ref)
+            } else {
+                self.tiled_panes.get_pane(ap).map(Box::as_ref)
+            }
+        })
     }
     pub fn get_active_pane_mut(&mut self, client_id: ClientId) -> Option<&mut Box<dyn Pane>> {
-        self.get_active_pane_id(client_id)
-            .and_then(|ap| self.panes.get_mut(&ap))
+        self.get_active_pane_id(client_id).and_then(|ap| {
+            if self.floating_panes.panes_are_visible() {
+                self.floating_panes.get_pane_mut(ap)
+            } else {
+                self.tiled_panes.get_pane_mut(ap)
+            }
+        })
     }
     pub fn get_active_pane_or_floating_pane_mut(
         &mut self,
@@ -903,26 +747,29 @@ impl Tab {
             self.get_active_pane_mut(client_id)
         }
     }
-    fn get_active_pane_id(&self, client_id: ClientId) -> Option<PaneId> {
-        // TODO: why do we need this?
-        self.active_panes.get(&client_id).copied()
+    pub fn get_active_pane_id(&self, client_id: ClientId) -> Option<PaneId> {
+        if self.floating_panes.panes_are_visible() {
+            self.floating_panes.get_active_pane_id(client_id)
+        } else {
+            self.tiled_panes.get_active_pane_id(client_id)
+        }
     }
     fn get_active_terminal_id(&self, client_id: ClientId) -> Option<RawFd> {
-        if let Some(PaneId::Terminal(pid)) = self.active_panes.get(&client_id).copied() {
+        if let Some(PaneId::Terminal(pid)) = self.get_active_pane_id(client_id) {
             Some(pid)
         } else {
             None
         }
     }
     pub fn has_terminal_pid(&self, pid: RawFd) -> bool {
-        self.panes.contains_key(&PaneId::Terminal(pid))
+        self.tiled_panes.panes_contain(&PaneId::Terminal(pid))
             || self.floating_panes.panes_contain(&PaneId::Terminal(pid))
     }
     pub fn handle_pty_bytes(&mut self, pid: RawFd, bytes: VteBytes) {
         if let Some(terminal_output) = self
-            .panes
-            .get_mut(&PaneId::Terminal(pid))
-            .or_else(|| self.floating_panes.get_mut(&PaneId::Terminal(pid)))
+            .tiled_panes
+            .get_pane_mut(PaneId::Terminal(pid))
+            .or_else(|| self.floating_panes.get_pane_mut(PaneId::Terminal(pid)))
         {
             // If the pane is scrolled buffer the vte events
             if terminal_output.is_scrolled() {
@@ -949,9 +796,9 @@ impl Tab {
     }
     fn process_pty_bytes(&mut self, pid: RawFd, bytes: VteBytes) {
         if let Some(terminal_output) = self
-            .panes
-            .get_mut(&PaneId::Terminal(pid))
-            .or_else(|| self.floating_panes.get_mut(&PaneId::Terminal(pid)))
+            .tiled_panes
+            .get_pane_mut(PaneId::Terminal(pid))
+            .or_else(|| self.floating_panes.get_pane_mut(PaneId::Terminal(pid)))
         {
             terminal_output.handle_pty_bytes(bytes);
             let messages_to_pty = terminal_output.drain_messages_to_pty();
@@ -969,10 +816,10 @@ impl Tab {
     pub fn write_to_active_terminal(&mut self, input_bytes: Vec<u8>, client_id: ClientId) {
         let pane_id = if self.floating_panes.panes_are_visible() {
             self.floating_panes
-                .active_pane_id(client_id)
-                .unwrap_or_else(|| *self.active_panes.get(&client_id).unwrap())
+                .get_active_pane_id(client_id)
+                .unwrap_or_else(|| self.tiled_panes.get_active_pane_id(client_id).unwrap())
         } else {
-            *self.active_panes.get(&client_id).unwrap()
+            self.tiled_panes.get_active_pane_id(client_id).unwrap()
         };
         self.write_to_pane_id(input_bytes, pane_id);
     }
@@ -996,7 +843,7 @@ impl Tab {
                 let active_terminal = self
                     .floating_panes
                     .get(&pane_id)
-                    .unwrap_or_else(|| self.panes.get(&pane_id).unwrap());
+                    .unwrap_or_else(|| self.tiled_panes.get_pane(pane_id).unwrap());
                 let adjusted_input = active_terminal.adjust_input_to_terminal(input_bytes);
                 self.os_api
                     .write_to_tty_stdin(active_terminal_id, &adjusted_input)
@@ -1021,15 +868,15 @@ impl Tab {
         // (x, y)
         let active_pane_id = if self.floating_panes.panes_are_visible() {
             self.floating_panes
-                .active_pane_id(client_id)
-                .or_else(|| self.active_panes.get(&client_id).copied())?
+                .get_active_pane_id(client_id)
+                .or_else(|| self.tiled_panes.get_active_pane_id(client_id))?
         } else {
-            self.active_panes.get(&client_id).copied()?
+            self.tiled_panes.get_active_pane_id(client_id)?
         };
         let active_terminal = &self
             .floating_panes
             .get(&active_pane_id)
-            .or_else(|| self.panes.get(&active_pane_id))?;
+            .or_else(|| self.tiled_panes.get_pane(active_pane_id))?;
         active_terminal
             .cursor_coordinates()
             .map(|(x_in_terminal, y_in_terminal)| {
@@ -1038,98 +885,20 @@ impl Tab {
                 (x, y)
             })
     }
-    pub fn unset_fullscreen(&mut self) {
-        if self.fullscreen_is_active {
-            let first_client_id = self.connected_clients.iter().next().unwrap(); // this is a temporary hack until we fix the ui for multiple clients
-            let active_pane_id = self.active_panes.get(first_client_id).unwrap();
-            for terminal_id in &self.panes_to_hide {
-                let pane = self.panes.get_mut(terminal_id).unwrap();
-                pane.set_should_render(true);
-                pane.set_should_render_boundaries(true);
-            }
-            let viewport_pane_ids: Vec<_> = self
-                .get_embedded_pane_ids()
-                .into_iter()
-                .filter(|id| !self.is_inside_viewport(id))
-                .collect();
-            for pid in viewport_pane_ids {
-                let viewport_pane = self.panes.get_mut(&pid).unwrap();
-                viewport_pane.reset_size_and_position_override();
-            }
-            self.panes_to_hide.clear();
-            let active_terminal = self.panes.get_mut(active_pane_id).unwrap();
-            active_terminal.reset_size_and_position_override();
-            self.set_force_render();
-            let display_area = *self.display_area.borrow();
-            self.resize_whole_tab(display_area);
-            self.toggle_fullscreen_is_active();
-        }
-    }
     pub fn toggle_active_pane_fullscreen(&mut self, client_id: ClientId) {
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-            if self.fullscreen_is_active {
-                self.unset_fullscreen();
-            } else {
-                let panes = self.get_panes();
-                let pane_ids_to_hide = panes.filter_map(|(&id, _pane)| {
-                    if id != active_pane_id && self.is_inside_viewport(&id) {
-                        Some(id)
-                    } else {
-                        None
-                    }
-                });
-                self.panes_to_hide = pane_ids_to_hide.collect();
-                if self.panes_to_hide.is_empty() {
-                    // nothing to do, pane is already as fullscreen as it can be, let's bail
-                    return;
-                } else {
-                    // For all of the panes outside of the viewport staying on the fullscreen
-                    // screen, switch them to using override positions as well so that the resize
-                    // system doesn't get confused by viewport and old panes that no longer line up
-                    let viewport_pane_ids: Vec<_> = self
-                        .get_embedded_pane_ids()
-                        .into_iter()
-                        .filter(|id| !self.is_inside_viewport(id))
-                        .collect();
-                    for pid in viewport_pane_ids {
-                        let viewport_pane = self.panes.get_mut(&pid).unwrap();
-                        viewport_pane.get_geom_override(viewport_pane.position_and_size());
-                    }
-                    let active_terminal = self.panes.get_mut(&active_pane_id).unwrap();
-                    let viewport = { *self.viewport.borrow() };
-                    let full_screen_geom = PaneGeom {
-                        x: viewport.x,
-                        y: viewport.y,
-                        ..Default::default()
-                    };
-                    active_terminal.get_geom_override(full_screen_geom);
-                }
-                let active_panes: Vec<ClientId> = self.active_panes.keys().copied().collect();
-                for client_id in active_panes {
-                    self.active_panes.insert(client_id, active_pane_id);
-                }
-                self.set_force_render();
-                let display_area = *self.display_area.borrow();
-                self.resize_whole_tab(display_area);
-                self.toggle_fullscreen_is_active();
-            }
+        if self.floating_panes.panes_are_visible() {
+            return;
         }
+        self.tiled_panes.toggle_active_pane_fullscreen(client_id);
     }
     pub fn is_fullscreen_active(&self) -> bool {
-        self.fullscreen_is_active
+        self.tiled_panes.fullscreen_is_active()
     }
     pub fn are_floating_panes_visible(&self) -> bool {
         self.floating_panes.panes_are_visible()
     }
-    pub fn toggle_fullscreen_is_active(&mut self) {
-        self.fullscreen_is_active = !self.fullscreen_is_active;
-    }
     pub fn set_force_render(&mut self) {
-        for pane in self.panes.values_mut() {
-            pane.set_should_render(true);
-            pane.set_should_render_boundaries(true);
-            pane.render_full_viewport();
-        }
+        self.tiled_panes.set_force_render();
         self.floating_panes.set_force_render();
     }
     pub fn is_sync_panes_active(&self) -> bool {
@@ -1139,187 +908,83 @@ impl Tab {
         self.synchronize_is_active = !self.synchronize_is_active;
     }
     pub fn mark_active_pane_for_rerender(&mut self, client_id: ClientId) {
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-            self.panes
-                .get_mut(&active_pane_id)
-                .unwrap()
-                .set_should_render(true)
-        }
-    }
-    pub fn set_pane_frames(&mut self, draw_pane_frames: bool) {
-        self.draw_pane_frames = draw_pane_frames;
-        self.should_clear_display_before_rendering = true;
-        let viewport = *self.viewport.borrow();
-        for pane in self.panes.values_mut() {
-            if !pane.borderless() {
-                pane.set_frame(draw_pane_frames);
-            }
-
-            #[allow(clippy::if_same_then_else)]
-            if draw_pane_frames & !pane.borderless() {
-                // there's definitely a frame around this pane, offset its contents
-                pane.set_content_offset(Offset::frame(1));
-            } else if draw_pane_frames && pane.borderless() {
-                // there's no frame around this pane, and the tab isn't handling the boundaries
-                // between panes (they each draw their own frames as they please)
-                // this one doesn't - do not offset its content
-                pane.set_content_offset(Offset::default());
-            } else if !is_inside_viewport(&viewport, pane) {
-                // this pane is outside the viewport and has no border - it should not have an offset
-                pane.set_content_offset(Offset::default());
-            } else {
-                // no draw_pane_frames and this pane should have a separation to other panes
-                // according to its position in the viewport (eg. no separation if its at the
-                // viewport bottom) - offset its content accordingly
-                let position_and_size = pane.current_geom();
-                let (pane_columns_offset, pane_rows_offset) =
-                    pane_content_offset(&position_and_size, &viewport);
-                pane.set_content_offset(Offset::shift(pane_rows_offset, pane_columns_offset));
-            }
-
-            resize_pty!(pane, self.os_api);
+        if let Some(active_pane) = self.get_active_pane_mut(client_id) {
+            active_pane.set_should_render(true);
         }
-        self.floating_panes.set_pane_frames(&mut self.os_api);
     }
     fn update_active_panes_in_pty_thread(&self) {
         // this is a bit hacky and we should ideally not keep this state in two different places at
         // some point
-        for &connected_client in &self.connected_clients {
+        let connected_clients: Vec<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
+        for client_id in connected_clients {
             self.senders
                 .send_to_pty(PtyInstruction::UpdateActivePane(
-                    self.active_panes.get(&connected_client).copied(),
-                    connected_client,
+                    self.get_active_pane_id(client_id),
+                    client_id,
                 ))
                 .unwrap();
         }
     }
     pub fn render(&mut self, output: &mut Output, overlay: Option<String>) {
-        if self.connected_clients.is_empty() || self.active_panes.is_empty() {
+        let connected_clients: HashSet<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
+        if connected_clients.is_empty() || !self.tiled_panes.has_active_panes() {
             return;
         }
         self.update_active_panes_in_pty_thread();
-        let floating_panes_stack = if self.floating_panes.panes_are_visible() {
-            Some(self.floating_panes.stack())
-        } else {
-            None
-        };
+
+        let floating_panes_stack = self.floating_panes.stack();
         output.add_clients(
-            &self.connected_clients,
+            &connected_clients,
             self.link_handler.clone(),
             floating_panes_stack,
         );
-        let mut client_id_to_boundaries: HashMap<ClientId, Boundaries> = HashMap::new();
+
         self.hide_cursor_and_clear_display_as_needed(output);
-        let active_non_floating_panes = self.active_non_floating_panes();
-        // render panes and their frames
-        for (kind, pane) in self.panes.iter_mut() {
-            if !self.panes_to_hide.contains(&pane.pid()) {
-                let mut active_panes = if self.floating_panes.panes_are_visible() {
-                    active_non_floating_panes.clone()
-                } else {
-                    self.active_panes.clone()
-                };
-                let multiple_users_exist_in_session =
-                    { self.connected_clients_in_app.borrow().len() > 1 };
-                active_panes.retain(|c_id, _| self.connected_clients.contains(c_id));
-                let mut pane_contents_and_ui = PaneContentsAndUi::new(
-                    pane,
-                    output,
-                    self.colors,
-                    &active_panes,
-                    multiple_users_exist_in_session,
-                    None,
-                );
-                for &client_id in &self.connected_clients {
-                    let client_mode = self
-                        .mode_info
-                        .get(&client_id)
-                        .unwrap_or(&self.default_mode_info)
-                        .mode;
-                    if let PaneId::Plugin(..) = kind {
-                        pane_contents_and_ui.render_pane_contents_for_client(client_id);
-                    }
-                    if self.draw_pane_frames {
-                        pane_contents_and_ui.render_pane_frame(
-                            client_id,
-                            client_mode,
-                            self.session_is_mirrored,
-                        );
-                    } else {
-                        let boundaries = client_id_to_boundaries
-                            .entry(client_id)
-                            .or_insert_with(|| Boundaries::new(*self.viewport.borrow()));
-                        pane_contents_and_ui.render_pane_boundaries(
-                            client_id,
-                            client_mode,
-                            boundaries,
-                            self.session_is_mirrored,
-                        );
-                    }
-                    pane_contents_and_ui.render_terminal_title_if_needed(client_id, client_mode);
-                    // this is done for panes that don't have their own cursor (eg. panes of
-                    // another user)
-                    pane_contents_and_ui.render_fake_cursor_if_needed(client_id);
-                }
-                if let PaneId::Terminal(..) = kind {
-                    pane_contents_and_ui.render_pane_contents_to_multiple_clients(
-                        self.connected_clients.iter().copied(),
-                    );
-                }
-            }
-        }
+        self.tiled_panes.render(output);
         if self.floating_panes.panes_are_visible() && self.floating_panes.has_active_panes() {
-            self.floating_panes.render(
-                &self.connected_clients_in_app,
-                &self.connected_clients,
-                &self.mode_info,
-                &self.default_mode_info,
-                self.session_is_mirrored,
-                output,
-                self.colors,
-            );
-        }
-        // render boundaries if needed
-        for (client_id, boundaries) in &mut client_id_to_boundaries {
-            // TODO: add some conditional rendering here so this isn't rendered for every character
-            output.add_character_chunks_to_client(*client_id, boundaries.render(), None);
+            self.floating_panes.render(output);
         }
+
         // FIXME: Once clients can be distinguished
         if let Some(overlay_vte) = &overlay {
             output.add_post_vte_instruction_to_multiple_clients(
-                self.connected_clients.iter().copied(),
+                connected_clients.iter().copied(),
                 overlay_vte,
             );
         }
+
         self.render_cursor(output);
     }
-    fn active_non_floating_panes(&self) -> HashMap<ClientId, PaneId> {
-        let mut active_non_floating_panes = self.active_panes.clone();
-        active_non_floating_panes.retain(|c_id, _| !self.floating_panes.active_panes_contain(c_id));
-        active_non_floating_panes
-    }
     fn hide_cursor_and_clear_display_as_needed(&mut self, output: &mut Output) {
         let hide_cursor = "\u{1b}[?25l";
+        let connected_clients: Vec<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
         output.add_pre_vte_instruction_to_multiple_clients(
-            self.connected_clients.iter().copied(),
+            connected_clients.iter().copied(),
             hide_cursor,
         );
         if self.should_clear_display_before_rendering {
             let clear_display = "\u{1b}[2J";
             output.add_pre_vte_instruction_to_multiple_clients(
-                self.connected_clients.iter().copied(),
+                connected_clients.iter().copied(),
                 clear_display,
             );
             self.should_clear_display_before_rendering = false;
         }
     }
     fn render_cursor(&self, output: &mut Output) {
-        for &client_id in &self.connected_clients {
+        let connected_clients: Vec<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
+        for client_id in connected_clients {
             match self.get_active_terminal_cursor_position(client_id) {
                 Some((cursor_position_x, cursor_position_y)) => {
                     let show_cursor = "\u{1b}[?25h";
-                    let change_cursor_shape =
-                        self.get_active_pane(client_id).unwrap().cursor_shape_csi();
+                    let change_cursor_shape = self
+                        .get_active_pane(client_id)
+                        .map(|ap| ap.cursor_shape_csi())
+                        .unwrap_or_default();
                     let goto_cursor_position = &format!(
                         "\u{1b}[{};{}H\u{1b}[m{}",
                         cursor_position_y + 1,
@@ -1336,83 +1001,43 @@ impl Tab {
             }
         }
     }
-    fn get_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> {
-        self.panes.iter()
+    fn get_tiled_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> {
+        self.tiled_panes.get_panes()
     }
-    fn get_selectable_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> {
-        self.panes.iter().filter(|(_, p)| p.selectable())
+    fn get_selectable_tiled_panes(&self) -> impl Iterator<Item = (&PaneId, &Box<dyn Pane>)> {
+        self.get_tiled_panes().filter(|(_, p)| p.selectable())
     }
     fn get_next_terminal_position(&self) -> usize {
-        self.panes
-            .iter()
+        let tiled_panes_count = self
+            .tiled_panes
+            .get_panes()
             .filter(|(k, _)| match k {
                 PaneId::Plugin(_) => false,
                 PaneId::Terminal(_) => true,
             })
-            .count()
-            + 1
-    }
-    fn has_selectable_panes(&self) -> bool {
-        let mut all_terminals = self.get_selectable_panes();
-        all_terminals.next().is_some()
-    }
-    fn next_active_pane(&self, panes: &[PaneId]) -> Option<PaneId> {
-        let mut panes: Vec<_> = panes
-            .iter()
-            .map(|p_id| self.panes.get(p_id).unwrap())
-            .collect();
-        panes.sort_by_key(|b| Reverse(b.active_at()));
-
-        panes.iter().find(|pane| pane.selectable()).map(|p| p.pid())
+            .count();
+        let floating_panes_count = self
+            .floating_panes
+            .get_panes()
+            .filter(|(k, _)| match k {
+                PaneId::Plugin(_) => false,
+                PaneId::Terminal(_) => true,
+            })
+            .count();
+        tiled_panes_count + floating_panes_count + 1
     }
-    pub fn relayout_tab(&mut self, direction: Direction) {
-        let mut pane_grid = TiledPaneGrid::new(
-            &mut self.panes,
-            *self.display_area.borrow(),
-            *self.viewport.borrow(),
-        );
-        let result = match direction {
-            Direction::Horizontal => {
-                pane_grid.layout(direction, (*self.display_area.borrow()).cols)
-            }
-            Direction::Vertical => pane_grid.layout(direction, (*self.display_area.borrow()).rows),
-        };
-        if let Err(e) = &result {
-            log::error!("{:?} relayout of the tab failed: {}", direction, e);
-        }
-        self.set_pane_frames(self.draw_pane_frames);
+    pub fn has_selectable_panes(&self) -> bool {
+        let selectable_tiled_panes = self.tiled_panes.get_panes().filter(|(_, p)| p.selectable());
+        let selectable_floating_panes = self
+            .floating_panes
+            .get_panes()
+            .filter(|(_, p)| p.selectable());
+        selectable_tiled_panes.count() > 0 || selectable_floating_panes.count() > 0
     }
     pub fn resize_whole_tab(&mut self, new_screen_size: Size) {
         self.floating_panes.resize(new_screen_size);
-        {
-            // this is blocked out to appease the borrow checker
-            let mut display_area = self.display_area.borrow_mut();
-            let mut viewport = self.viewport.borrow_mut();
-            let panes = self
-                .panes
-                .iter_mut()
-                .filter(|(pid, _)| !self.panes_to_hide.contains(pid));
-            let Size { rows, cols } = new_screen_size;
-            let mut pane_grid = TiledPaneGrid::new(panes, *display_area, *viewport);
-            if pane_grid.layout(Direction::Horizontal, cols).is_ok() {
-                let column_difference = cols as isize - display_area.cols as isize;
-                // FIXME: Should the viewport be an Offset?
-                viewport.cols = (viewport.cols as isize + column_difference) as usize;
-                display_area.cols = cols;
-            } else {
-                log::error!("Failed to horizontally resize the tab!!!");
-            }
-            if pane_grid.layout(Direction::Vertical, rows).is_ok() {
-                let row_difference = rows as isize - display_area.rows as isize;
-                viewport.rows = (viewport.rows as isize + row_difference) as usize;
-                display_area.rows = rows;
-            } else {
-                log::error!("Failed to vertically resize the tab!!!");
-            }
-
-            self.should_clear_display_before_rendering = true;
-        }
-        self.set_pane_frames(self.draw_pane_frames);
+        self.tiled_panes.resize(new_screen_size);
+        self.should_clear_display_before_rendering = true;
     }
     pub fn resize_left(&mut self, client_id: ClientId) {
         if self.floating_panes.panes_are_visible() {
@@ -1423,17 +1048,8 @@ impl Tab {
                 self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease
                 return;
             }
-        }
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-            let mut pane_grid = TiledPaneGrid::new(
-                &mut self.panes,
-                *self.display_area.borrow(),
-                *self.viewport.borrow(),
-            );
-            pane_grid.resize_pane_left(&active_pane_id);
-            for pane in self.panes.values_mut() {
-                resize_pty!(pane, self.os_api);
-            }
+        } else {
+            self.tiled_panes.resize_active_pane_left(client_id);
         }
     }
     pub fn resize_right(&mut self, client_id: ClientId) {
@@ -1445,17 +1061,8 @@ impl Tab {
                 self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease
                 return;
             }
-        }
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-            let mut pane_grid = TiledPaneGrid::new(
-                &mut self.panes,
-                *self.display_area.borrow(),
-                *self.viewport.borrow(),
-            );
-            pane_grid.resize_pane_right(&active_pane_id);
-            for pane in self.panes.values_mut() {
-                resize_pty!(pane, self.os_api);
-            }
+        } else {
+            self.tiled_panes.resize_active_pane_right(client_id);
         }
     }
     pub fn resize_down(&mut self, client_id: ClientId) {
@@ -1467,17 +1074,8 @@ impl Tab {
                 self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease
                 return;
             }
-        }
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-            let mut pane_grid = TiledPaneGrid::new(
-                &mut self.panes,
-                *self.display_area.borrow(),
-                *self.viewport.borrow(),
-            );
-            pane_grid.resize_pane_down(&active_pane_id);
-            for pane in self.panes.values_mut() {
-                resize_pty!(pane, self.os_api);
-            }
+        } else {
+            self.tiled_panes.resize_active_pane_down(client_id);
         }
     }
     pub fn resize_up(&mut self, client_id: ClientId) {
@@ -1489,17 +1087,8 @@ impl Tab {
                 self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease
                 return;
             }
-        }
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-            let mut pane_grid = TiledPaneGrid::new(
-                &mut self.panes,
-                *self.display_area.borrow(),
-                *self.viewport.borrow(),
-            );
-            pane_grid.resize_pane_up(&active_pane_id);
-            for pane in self.panes.values_mut() {
-                resize_pty!(pane, self.os_api);
-            }
+        } else {
+            self.tiled_panes.resize_active_pane_up(client_id);
         }
     }
     pub fn resize_increase(&mut self, client_id: ClientId) {
@@ -1511,17 +1100,8 @@ impl Tab {
                 self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease
                 return;
             }
-        }
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-            let mut pane_grid = TiledPaneGrid::new(
-                &mut self.panes,
-                *self.display_area.borrow(),
-                *self.viewport.borrow(),
-            );
-            pane_grid.resize_increase(&active_pane_id);
-            for pane in self.panes.values_mut() {
-                resize_pty!(pane, self.os_api);
-            }
+        } else {
+            self.tiled_panes.resize_active_pane_increase(client_id);
         }
     }
     pub fn resize_decrease(&mut self, client_id: ClientId) {
@@ -1533,408 +1113,109 @@ impl Tab {
                 self.set_force_render(); // we force render here to make sure the panes under the floating pane render and don't leave "garbage" incase of a decrease
                 return;
             }
-        }
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-            let mut pane_grid = TiledPaneGrid::new(
-                &mut self.panes,
-                *self.display_area.borrow(),
-                *self.viewport.borrow(),
-            );
-            pane_grid.resize_decrease(&active_pane_id);
-            for pane in self.panes.values_mut() {
-                resize_pty!(pane, self.os_api);
-            }
+        } else {
+            self.tiled_panes.resize_active_pane_decrease(client_id);
         }
     }
     fn set_pane_active_at(&mut self, pane_id: PaneId) {
-        if let Some(pane) = self.panes.get_mut(&pane_id) {
+        if let Some(pane) = self.tiled_panes.get_pane_mut(pane_id) {
+            pane.set_active_at(Instant::now());
+        } else if let Some(pane) = self.floating_panes.get_pane_mut(pane_id) {
             pane.set_active_at(Instant::now());
         }
     }
-
-    pub fn move_focus(&mut self, client_id: ClientId) {
-        if !self.has_selectable_panes() {
-            return;
-        }
-        if self.fullscreen_is_active {
-            return;
-        }
-        let current_active_pane_id = self.get_active_pane_id(client_id).unwrap();
-        let pane_grid = TiledPaneGrid::new(
-            &mut self.panes,
-            *self.display_area.borrow(),
-            *self.viewport.borrow(),
-        );
-        let next_active_pane_id = pane_grid.next_selectable_pane_id(&current_active_pane_id);
-        let connected_clients: Vec<ClientId> = self.connected_clients.iter().copied().collect();
-        for client_id in connected_clients {
-            self.active_panes.insert(client_id, next_active_pane_id);
-        }
-        self.set_pane_active_at(next_active_pane_id);
-    }
     pub fn focus_next_pane(&mut self, client_id: ClientId) {
         if !self.has_selectable_panes() {
             return;
         }
-        if self.fullscreen_is_active {
+        if self.tiled_panes.fullscreen_is_active() {
             return;
         }
-        let active_pane_id = self.get_active_pane_id(client_id).unwrap();
-        let pane_grid = TiledPaneGrid::new(
-            &mut self.panes,
-            *self.display_area.borrow(),
-            *self.viewport.borrow(),
-        );
-        let next_active_pane_id = pane_grid.next_selectable_pane_id(&active_pane_id);
-        let connected_clients: Vec<ClientId> = self.connected_clients.iter().copied().collect();
-        for client_id in connected_clients {
-            self.active_panes.insert(client_id, next_active_pane_id);
-        }
-        self.set_pane_active_at(next_active_pane_id);
+        self.tiled_panes.focus_next_pane(client_id);
     }
     pub fn focus_previous_pane(&mut self, client_id: ClientId) {
         if !self.has_selectable_panes() {
             return;
         }
-        if self.fullscreen_is_active {
+        if self.tiled_panes.fullscreen_is_active() {
             return;
         }
-        let active_pane_id = self.get_active_pane_id(client_id).unwrap();
-        let pane_grid = TiledPaneGrid::new(
-            &mut self.panes,
-            *self.display_area.borrow(),
-            *self.viewport.borrow(),
-        );
-        let next_active_pane_id = pane_grid.previous_selectable_pane_id(&active_pane_id);
-        let connected_clients: Vec<ClientId> = self.connected_clients.iter().copied().collect();
-        for client_id in connected_clients {
-            self.active_panes.insert(client_id, next_active_pane_id);
-        }
-        self.set_pane_active_at(next_active_pane_id);
+        self.tiled_panes.focus_previous_pane(client_id);
     }
     // returns a boolean that indicates whether the focus moved
     pub fn move_focus_left(&mut self, client_id: ClientId) -> bool {
         if self.floating_panes.panes_are_visible() {
-            self.floating_panes
-                .move_focus_left(client_id, &self.connected_clients)
+            self.floating_panes.move_focus_left(
+                client_id,
+                &self.connected_clients.borrow().iter().copied().collect(),
+            )
         } else {
             if !self.has_selectable_panes() {
                 return false;
             }
-            if self.fullscreen_is_active {
+            if self.tiled_panes.fullscreen_is_active() {
                 return false;
             }
-            let active_pane_id = self.get_active_pane_id(client_id);
-            let updated_active_pane = if let Some(active_pane_id) = active_pane_id {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let next_index = pane_grid.next_selectable_pane_id_to_the_left(&active_pane_id);
-                match next_index {
-                    Some(p) => {
-                        // render previously active pane so that its frame does not remain actively
-                        // colored
-                        let previously_active_pane = self
-                            .panes
-                            .get_mut(self.active_panes.get(&client_id).unwrap())
-                            .unwrap();
-
-                        previously_active_pane.set_should_render(true);
-                        // we render the full viewport to remove any ui elements that might have been
-                        // there before (eg. another user's cursor)
-                        previously_active_pane.render_full_viewport();
-
-                        let next_active_pane = self.panes.get_mut(&p).unwrap();
-                        next_active_pane.set_should_render(true);
-                        // we render the full viewport to remove any ui elements that might have been
-                        // there before (eg. another user's cursor)
-                        next_active_pane.render_full_viewport();
-
-                        if self.session_is_mirrored {
-                            // move all clients
-                            let connected_clients: Vec<ClientId> =
-                                self.connected_clients.iter().copied().collect();
-                            for client_id in connected_clients {
-                                self.active_panes.insert(client_id, p);
-                            }
-                        } else {
-                            self.active_panes.insert(client_id, p);
-                        }
-                        self.set_pane_active_at(p);
-
-                        return true;
-                    }
-                    None => Some(active_pane_id),
-                }
-            } else {
-                active_pane_id
-            };
-            match updated_active_pane {
-                Some(updated_active_pane) => {
-                    let connected_clients: Vec<ClientId> =
-                        self.connected_clients.iter().copied().collect();
-                    for client_id in connected_clients {
-                        self.active_panes.insert(client_id, updated_active_pane);
-                    }
-                    self.set_pane_active_at(updated_active_pane);
-                }
-                None => {
-                    // TODO: can this happen?
-                    self.active_panes.clear();
-                }
-            }
-
-            false
+            self.tiled_panes.move_focus_left(client_id)
         }
     }
-    pub fn move_focus_down(&mut self, client_id: ClientId) {
+    pub fn move_focus_down(&mut self, client_id: ClientId) -> bool {
         if self.floating_panes.panes_are_visible() {
-            self.floating_panes
-                .move_focus_down(client_id, &self.connected_clients);
+            self.floating_panes.move_focus_down(
+                client_id,
+                &self.connected_clients.borrow().iter().copied().collect(),
+            )
         } else {
             if !self.has_selectable_panes() {
-                return;
-            }
-            if self.fullscreen_is_active {
-                return;
+                return false;
             }
-            let active_pane_id = self.get_active_pane_id(client_id);
-            let updated_active_pane = if let Some(active_pane_id) = active_pane_id {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let next_index = pane_grid.next_selectable_pane_id_below(&active_pane_id);
-                match next_index {
-                    Some(p) => {
-                        // render previously active pane so that its frame does not remain actively
-                        // colored
-                        let previously_active_pane = self
-                            .panes
-                            .get_mut(self.active_panes.get(&client_id).unwrap())
-                            .unwrap();
-                        previously_active_pane.set_should_render(true);
-                        // we render the full viewport to remove any ui elements that might have been
-                        // there before (eg. another user's cursor)
-                        previously_active_pane.render_full_viewport();
-                        let next_active_pane = self.panes.get_mut(&p).unwrap();
-                        next_active_pane.set_should_render(true);
-                        // we render the full viewport to remove any ui elements that might have been
-                        // there before (eg. another user's cursor)
-                        next_active_pane.render_full_viewport();
-
-                        Some(p)
-                    }
-                    None => Some(active_pane_id),
-                }
-            } else {
-                active_pane_id
-            };
-            match updated_active_pane {
-                Some(updated_active_pane) => {
-                    if self.session_is_mirrored {
-                        // move all clients
-                        let connected_clients: Vec<ClientId> =
-                            self.connected_clients.iter().copied().collect();
-                        for client_id in connected_clients {
-                            self.active_panes.insert(client_id, updated_active_pane);
-                        }
-                        self.set_pane_active_at(updated_active_pane);
-                    } else {
-                        self.active_panes.insert(client_id, updated_active_pane);
-                        self.set_pane_active_at(updated_active_pane);
-                    }
-                }
-                None => {
-                    // TODO: can this happen?
-                    self.active_panes.clear();
-                }
+            if self.tiled_panes.fullscreen_is_active() {
+                return false;
             }
+            self.tiled_panes.move_focus_down(client_id)
         }
     }
-    pub fn move_focus_up(&mut self, client_id: ClientId) {
+    pub fn move_focus_up(&mut self, client_id: ClientId) -> bool {
         if self.floating_panes.panes_are_visible() {
-            self.floating_panes
-                .move_focus_up(client_id, &self.connected_clients);
+            self.floating_panes.move_focus_up(
+                client_id,
+                &self.connected_clients.borrow().iter().copied().collect(),
+            )
         } else {
             if !self.has_selectable_panes() {
-                return;
-            }
-            if self.fullscreen_is_active {
-                return;
+                return false;
             }
-            let active_pane_id = self.get_active_pane_id(client_id);
-            let updated_active_pane = if let Some(active_pane_id) = active_pane_id {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let next_index = pane_grid.next_selectable_pane_id_above(&active_pane_id);
-                match next_index {
-                    Some(p) => {
-                        // render previously active pane so that its frame does not remain actively
-                        // colored
-                        let previously_active_pane = self
-                            .panes
-                            .get_mut(self.active_panes.get(&client_id).unwrap())
-                            .unwrap();
-                        previously_active_pane.set_should_render(true);
-                        // we render the full viewport to remove any ui elements that might have been
-                        // there before (eg. another user's cursor)
-                        previously_active_pane.render_full_viewport();
-                        let next_active_pane = self.panes.get_mut(&p).unwrap();
-                        next_active_pane.set_should_render(true);
-                        // we render the full viewport to remove any ui elements that might have been
-                        // there before (eg. another user's cursor)
-                        next_active_pane.render_full_viewport();
-
-                        Some(p)
-                    }
-                    None => Some(active_pane_id),
-                }
-            } else {
-                active_pane_id
-            };
-            match updated_active_pane {
-                Some(updated_active_pane) => {
-                    if self.session_is_mirrored {
-                        // move all clients
-                        let connected_clients: Vec<ClientId> =
-                            self.connected_clients.iter().copied().collect();
-                        for client_id in connected_clients {
-                            self.active_panes.insert(client_id, updated_active_pane);
-                        }
-                        self.set_pane_active_at(updated_active_pane);
-                    } else {
-                        self.active_panes.insert(client_id, updated_active_pane);
-                        self.set_pane_active_at(updated_active_pane);
-                    }
-                }
-                None => {
-                    // TODO: can this happen?
-                    self.active_panes.clear();
-                }
+            if self.tiled_panes.fullscreen_is_active() {
+                return false;
             }
+            self.tiled_panes.move_focus_up(client_id)
         }
     }
     // returns a boolean that indicates whether the focus moved
     pub fn move_focus_right(&mut self, client_id: ClientId) -> bool {
         if self.floating_panes.panes_are_visible() {
-            self.floating_panes
-                .move_focus_right(client_id, &self.connected_clients)
+            self.floating_panes.move_focus_right(
+                client_id,
+                &self.connected_clients.borrow().iter().copied().collect(),
+            )
         } else {
             if !self.has_selectable_panes() {
                 return false;
             }
-            if self.fullscreen_is_active {
+            if self.tiled_panes.fullscreen_is_active() {
                 return false;
             }
-            let active_pane_id = self.get_active_pane_id(client_id);
-            let updated_active_pane = if let Some(active_pane_id) = active_pane_id {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let next_index = pane_grid.next_selectable_pane_id_to_the_right(&active_pane_id);
-                match next_index {
-                    Some(p) => {
-                        // render previously active pane so that its frame does not remain actively
-                        // colored
-                        let previously_active_pane = self
-                            .panes
-                            .get_mut(self.active_panes.get(&client_id).unwrap())
-                            .unwrap();
-                        previously_active_pane.set_should_render(true);
-                        // we render the full viewport to remove any ui elements that might have been
-                        // there before (eg. another user's cursor)
-                        previously_active_pane.render_full_viewport();
-                        let next_active_pane = self.panes.get_mut(&p).unwrap();
-                        next_active_pane.set_should_render(true);
-                        // we render the full viewport to remove any ui elements that might have been
-                        // there before (eg. another user's cursor)
-                        next_active_pane.render_full_viewport();
-
-                        if self.session_is_mirrored {
-                            // move all clients
-                            let connected_clients: Vec<ClientId> =
-                                self.connected_clients.iter().copied().collect();
-                            for client_id in connected_clients {
-                                self.active_panes.insert(client_id, p);
-                            }
-                        } else {
-                            self.active_panes.insert(client_id, p);
-                        }
-                        self.set_pane_active_at(p);
-                        return true;
-                    }
-                    None => Some(active_pane_id),
-                }
-            } else {
-                active_pane_id
-            };
-            match updated_active_pane {
-                Some(updated_active_pane) => {
-                    if self.session_is_mirrored {
-                        // move all clients
-                        let connected_clients: Vec<ClientId> =
-                            self.connected_clients.iter().copied().collect();
-                        for client_id in connected_clients {
-                            self.active_panes.insert(client_id, updated_active_pane);
-                        }
-                        self.set_pane_active_at(updated_active_pane);
-                    } else {
-                        self.active_panes.insert(client_id, updated_active_pane);
-                        self.set_pane_active_at(updated_active_pane);
-                    }
-                }
-                None => {
-                    // TODO: can this happen?
-                    self.active_panes.clear();
-                }
-            }
-            false
+            self.tiled_panes.move_focus_right(client_id)
         }
     }
     pub fn move_active_pane(&mut self, client_id: ClientId) {
         if !self.has_selectable_panes() {
             return;
         }
-        if self.fullscreen_is_active {
+        if self.tiled_panes.fullscreen_is_active() {
             return;
         }
-        let active_pane_id = self.get_active_pane_id(client_id).unwrap();
-        let pane_grid = TiledPaneGrid::new(
-            &mut self.panes,
-            *self.display_area.borrow(),
-            *self.viewport.borrow(),
-        );
-        let new_position_id = pane_grid.next_selectable_pane_id(&active_pane_id);
-        let current_position = self.panes.get(&active_pane_id).unwrap();
-        let prev_geom = current_position.position_and_size();
-        let prev_geom_override = current_position.geom_override();
-
-        let new_position = self.panes.get_mut(&new_position_id).unwrap();
-        let next_geom = new_position.position_and_size();
-        let next_geom_override = new_position.geom_override();
-        new_position.set_geom(prev_geom);
-        if let Some(geom) = prev_geom_override {
-            new_position.get_geom_override(geom);
-        }
-        resize_pty!(new_position, self.os_api);
-        new_position.set_should_render(true);
-
-        let current_position = self.panes.get_mut(&active_pane_id).unwrap();
-        current_position.set_geom(next_geom);
-        if let Some(geom) = next_geom_override {
-            current_position.get_geom_override(geom);
-        }
-        resize_pty!(current_position, self.os_api);
-        current_position.set_should_render(true);
+        self.tiled_panes.move_active_pane(client_id);
     }
     pub fn move_active_pane_down(&mut self, client_id: ClientId) {
         if self.floating_panes.panes_are_visible() {
@@ -1944,41 +1225,10 @@ impl Tab {
             if !self.has_selectable_panes() {
                 return;
             }
-            if self.fullscreen_is_active {
+            if self.tiled_panes.fullscreen_is_active() {
                 return;
             }
-            if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let next_index = pane_grid.next_selectable_pane_id_below(&active_pane_id);
-                if let Some(p) = next_index {
-                    let active_pane_id = self.active_panes.get(&client_id).unwrap();
-                    let current_position = self.panes.get(active_pane_id).unwrap();
-                    let prev_geom = current_position.position_and_size();
-                    let prev_geom_override = current_position.geom_override();
-
-                    let new_position = self.panes.get_mut(&p).unwrap();
-                    let next_geom = new_position.position_and_size();
-                    let next_geom_override = new_position.geom_override();
-                    new_position.set_geom(prev_geom);
-                    if let Some(geom) = prev_geom_override {
-                        new_position.get_geom_override(geom);
-                    }
-                    resize_pty!(new_position, self.os_api);
-                    new_position.set_should_render(true);
-
-                    let current_position = self.panes.get_mut(active_pane_id).unwrap();
-                    current_position.set_geom(next_geom);
-                    if let Some(geom) = next_geom_override {
-                        current_position.get_geom_override(geom);
-                    }
-                    resize_pty!(current_position, self.os_api);
-                    current_position.set_should_render(true);
-                }
-            }
+            self.tiled_panes.move_active_pane_down(client_id);
         }
     }
     pub fn move_active_pane_up(&mut self, client_id: ClientId) {
@@ -1989,41 +1239,10 @@ impl Tab {
             if !self.has_selectable_panes() {
                 return;
             }
-            if self.fullscreen_is_active {
+            if self.tiled_panes.fullscreen_is_active() {
                 return;
             }
-            if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let next_index = pane_grid.next_selectable_pane_id_above(&active_pane_id);
-                if let Some(p) = next_index {
-                    let active_pane_id = self.active_panes.get(&client_id).unwrap();
-                    let current_position = self.panes.get(active_pane_id).unwrap();
-                    let prev_geom = current_position.position_and_size();
-                    let prev_geom_override = current_position.geom_override();
-
-                    let new_position = self.panes.get_mut(&p).unwrap();
-                    let next_geom = new_position.position_and_size();
-                    let next_geom_override = new_position.geom_override();
-                    new_position.set_geom(prev_geom);
-                    if let Some(geom) = prev_geom_override {
-                        new_position.get_geom_override(geom);
-                    }
-                    resize_pty!(new_position, self.os_api);
-                    new_position.set_should_render(true);
-
-                    let current_position = self.panes.get_mut(active_pane_id).unwrap();
-                    current_position.set_geom(next_geom);
-                    if let Some(geom) = next_geom_override {
-                        current_position.get_geom_override(geom);
-                    }
-                    resize_pty!(current_position, self.os_api);
-                    current_position.set_should_render(true);
-                }
-            }
+            self.tiled_panes.move_active_pane_up(client_id);
         }
     }
     pub fn move_active_pane_right(&mut self, client_id: ClientId) {
@@ -2034,41 +1253,10 @@ impl Tab {
             if !self.has_selectable_panes() {
                 return;
             }
-            if self.fullscreen_is_active {
+            if self.tiled_panes.fullscreen_is_active() {
                 return;
             }
-            if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let next_index = pane_grid.next_selectable_pane_id_to_the_right(&active_pane_id);
-                if let Some(p) = next_index {
-                    let active_pane_id = self.active_panes.get(&client_id).unwrap();
-                    let current_position = self.panes.get(active_pane_id).unwrap();
-                    let prev_geom = current_position.position_and_size();
-                    let prev_geom_override = current_position.geom_override();
-
-                    let new_position = self.panes.get_mut(&p).unwrap();
-                    let next_geom = new_position.position_and_size();
-                    let next_geom_override = new_position.geom_override();
-                    new_position.set_geom(prev_geom);
-                    if let Some(geom) = prev_geom_override {
-                        new_position.get_geom_override(geom);
-                    }
-                    resize_pty!(new_position, self.os_api);
-                    new_position.set_should_render(true);
-
-                    let current_position = self.panes.get_mut(active_pane_id).unwrap();
-                    current_position.set_geom(next_geom);
-                    if let Some(geom) = next_geom_override {
-                        current_position.get_geom_override(geom);
-                    }
-                    resize_pty!(current_position, self.os_api);
-                    current_position.set_should_render(true);
-                }
-            }
+            self.tiled_panes.move_active_pane_right(client_id);
         }
     }
     pub fn move_active_pane_left(&mut self, client_id: ClientId) {
@@ -2079,46 +1267,15 @@ impl Tab {
             if !self.has_selectable_panes() {
                 return;
             }
-            if self.fullscreen_is_active {
+            if self.tiled_panes.fullscreen_is_active() {
                 return;
             }
-            if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
-                let pane_grid = TiledPaneGrid::new(
-                    &mut self.panes,
-                    *self.display_area.borrow(),
-                    *self.viewport.borrow(),
-                );
-                let next_index = pane_grid.next_selectable_pane_id_to_the_left(&active_pane_id);
-                if let Some(p) = next_index {
-                    let active_pane_id = self.active_panes.get(&client_id).unwrap();
-                    let current_position = self.panes.get(active_pane_id).unwrap();
-                    let prev_geom = current_position.position_and_size();
-                    let prev_geom_override = current_position.geom_override();
-
-                    let new_position = self.panes.get_mut(&p).unwrap();
-                    let next_geom = new_position.position_and_size();
-                    let next_geom_override = new_position.geom_override();
-                    new_position.set_geom(prev_geom);
-                    if let Some(geom) = prev_geom_override {
-                        new_position.get_geom_override(geom);
-                    }
-                    resize_pty!(new_position, self.os_api);
-                    new_position.set_should_render(true);
-
-                    let current_position = self.panes.get_mut(active_pane_id).unwrap();
-                    current_position.set_geom(next_geom);
-                    if let Some(geom) = next_geom_override {
-                        current_position.get_geom_override(geom);
-                    }
-                    resize_pty!(current_position, self.os_api);
-                    current_position.set_should_render(true);
-                }
-            }
+            self.tiled_panes.move_active_pane_left(client_id);
         }
     }
     fn close_down_to_max_terminals(&mut self) {
         if let Some(max_panes) = self.max_panes {
-            let terminals = self.get_embedded_pane_ids();
+            let terminals = self.get_tiled_pane_ids();
             for &pid in terminals.iter().skip(max_panes - 1) {
                 self.senders
                     .send_to_pty(PtyInstruction::ClosePane(pid))
@@ -2127,22 +1284,22 @@ impl Tab {
             }
         }
     }
-    pub fn get_embedded_pane_ids(&self) -> Vec<PaneId> {
-        self.get_panes().map(|(&pid, _)| pid).collect()
+    pub fn get_tiled_pane_ids(&self) -> Vec<PaneId> {
+        self.get_tiled_panes().map(|(&pid, _)| pid).collect()
     }
     pub fn get_all_pane_ids(&self) -> Vec<PaneId> {
         // this is here just as a naming thing to make things more explicit
         self.get_static_and_floating_pane_ids()
     }
     pub fn get_static_and_floating_pane_ids(&self) -> Vec<PaneId> {
-        self.panes
-            .keys()
+        self.tiled_panes
+            .pane_ids()
             .chain(self.floating_panes.pane_ids())
             .copied()
             .collect()
     }
     pub fn set_pane_selectable(&mut self, id: PaneId, selectable: bool) {
-        if let Some(pane) = self.panes.get_mut(&id) {
+        if let Some(pane) = self.tiled_panes.get_pane_mut(id) {
             pane.set_selectable(selectable);
             if !selectable {
                 // there are some edge cases in which this causes a hard crash when there are no
@@ -2156,23 +1313,7 @@ impl Tab {
                 // solve it by adding a "dangling_clients" struct to Tab which we would fill with
                 // the relevant client ids in this case and drain as soon as a new selectable pane
                 // is opened
-                self.move_clients_out_of_pane(id);
-            }
-        }
-    }
-    fn move_clients_out_of_pane(&mut self, pane_id: PaneId) {
-        let active_panes: Vec<(ClientId, PaneId)> = self
-            .active_panes
-            .iter()
-            .map(|(cid, pid)| (*cid, *pid))
-            .collect();
-        for (client_id, active_pane_id) in active_panes {
-            if active_pane_id == pane_id {
-                self.active_panes.insert(
-                    client_id,
-                    self.next_active_pane(&self.get_embedded_pane_ids())
-                        .unwrap(),
-                );
+                self.tiled_panes.move_clients_out_of_pane(id);
             }
         }
     }
@@ -2187,29 +1328,13 @@ impl Tab {
             self.floating_panes.set_force_render();
             closed_pane
         } else {
-            if self.fullscreen_is_active {
-                self.unset_fullscreen();
-            }
-            let mut pane_grid = TiledPaneGrid::new(
-                &mut self.panes,
-                *self.display_area.borrow(),
-                *self.viewport.borrow(),
-            );
-            if pane_grid.fill_space_over_pane(id) {
-                // successfully filled space over pane
-                let closed_pane = self.panes.remove(&id);
-                self.move_clients_out_of_pane(id);
-                for pane in self.panes.values_mut() {
-                    resize_pty!(pane, self.os_api);
-                }
-                closed_pane
-            } else {
-                self.panes.remove(&id);
-                // this is a bit of a roundabout way to say: this is the last pane and so the tab
-                // should be destroyed
-                self.active_panes.clear();
-                None
+            if self.tiled_panes.fullscreen_is_active() {
+                self.tiled_panes.unset_fullscreen();
             }
+            let closed_pane = self.tiled_panes.remove_pane(id);
+            self.set_force_render();
+            self.tiled_panes.set_force_render();
+            closed_pane
         }
     }
     pub fn close_focused_pane(&mut self, client_id: ClientId) {
@@ -2222,7 +1347,7 @@ impl Tab {
                 return;
             }
         }
-        if let Some(active_pane_id) = self.get_active_pane_id(client_id) {
+        if let Some(active_pane_id) = self.tiled_panes.get_active_pane_id(client_id) {
             self.close_pane(active_pane_id);
             self.senders
                 .send_to_pty(PtyInstruction::ClosePane(active_pane_id))
@@ -2343,27 +1468,34 @@ impl Tab {
     ) -> Option<&mut Box<dyn Pane>> {
         if self.floating_panes.panes_are_visible() {
             if let Some(pane_id) = self.floating_panes.get_pane_id_at(point, search_selectable) {
-                return self.floating_panes.get_mut(&pane_id);
+                return self.floating_panes.get_pane_mut(pane_id);
             }
         }
         if let Some(pane_id) = self.get_pane_id_at(point, search_selectable) {
-            self.panes.get_mut(&pane_id)
+            self.tiled_panes.get_pane_mut(pane_id)
         } else {
             None
         }
     }
 
     fn get_pane_id_at(&self, point: &Position, search_selectable: bool) -> Option<PaneId> {
-        if self.fullscreen_is_active && self.is_position_inside_viewport(point) {
-            let first_client_id = self.connected_clients.iter().next().unwrap(); // TODO: instead of doing this, record the pane that is in fullscreen
-            return self.get_active_pane_id(*first_client_id);
+        if self.tiled_panes.fullscreen_is_active() && self.is_position_inside_viewport(point) {
+            let first_client_id = {
+                self.connected_clients
+                    .borrow()
+                    .iter()
+                    .copied()
+                    .next()
+                    .unwrap()
+            }; // TODO: instead of doing this, record the pane that is in fullscreen
+            return self.tiled_panes.get_active_pane_id(first_client_id);
         }
         if search_selectable {
-            self.get_selectable_panes()
+            self.get_selectable_tiled_panes()
                 .find(|(_, p)| p.contains(point))
                 .map(|(&id, _)| id)
         } else {
-            self.get_panes()
+            self.get_tiled_panes()
                 .find(|(_, p)| p.contains(point))
                 .map(|(&id, _)| id)
         }
@@ -2417,27 +1549,13 @@ impl Tab {
     fn focus_pane_at(&mut self, point: &Position, client_id: ClientId) {
         if self.floating_panes.panes_are_visible() {
             if let Some(clicked_pane) = self.floating_panes.get_pane_id_at(point, true) {
-                // move all clients
-                let connected_clients: Vec<ClientId> =
-                    self.connected_clients.iter().copied().collect();
-                for client_id in connected_clients {
-                    self.floating_panes.focus_pane(clicked_pane, client_id);
-                }
+                self.floating_panes.focus_pane(clicked_pane, client_id);
                 self.set_pane_active_at(clicked_pane);
                 return;
             }
         }
         if let Some(clicked_pane) = self.get_pane_id_at(point, true) {
-            if self.session_is_mirrored {
-                // move all clients
-                let connected_clients: Vec<ClientId> =
-                    self.connected_clients.iter().copied().collect();
-                for client_id in connected_clients {
-                    self.active_panes.insert(client_id, clicked_pane);
-                }
-            } else {
-                self.active_panes.insert(client_id, clicked_pane);
-            }
+            self.tiled_panes.focus_pane(clicked_pane, client_id);
             self.set_pane_active_at(clicked_pane);
             if self.floating_panes.panes_are_visible() {
                 self.floating_panes.toggle_show_panes(false);
@@ -2534,8 +1652,10 @@ impl Tab {
 
     fn write_selection_to_clipboard(&self, selection: &str) {
         let mut output = Output::default();
-        output.add_clients(&self.connected_clients, self.link_handler.clone(), None);
-        let client_ids = self.connected_clients.iter().copied();
+        let connected_clients: HashSet<ClientId> =
+            { self.connected_clients.borrow().iter().copied().collect() };
+        output.add_clients(&connected_clients, self.link_handler.clone(), None);
+        let client_ids = connected_clients.iter().copied();
         let clipboard_event =
             match self
                 .clipboard_provider
@@ -2557,11 +1677,6 @@ impl Tab {
             .send_to_plugin(PluginInstruction::Update(None, None, clipboard_event))
             .unwrap();
     }
-    fn is_inside_viewport(&self, pane_id: &PaneId) -> bool {
-        // this is mostly separated to an outside function in order to allow us to pass a clone to
-        // it sometimes when we need to get around the borrow checker
-        is_inside_viewport(&*self.viewport.borrow(), self.panes.get(pane_id).unwrap())
-    }
     fn offset_viewport(&mut self, position_and_size: &Viewport) {
         let mut viewport = self.viewport.borrow_mut();
         if position_and_size.x == viewport.x
@@ -2587,7 +1702,7 @@ impl Tab {
     }
 
     pub fn visible(&self, visible: bool) {
-        let pids_in_this_tab = self.panes.keys().filter_map(|p| match p {
+        let pids_in_this_tab = self.tiled_panes.pane_ids().filter_map(|p| match p {
             PaneId::Plugin(pid) => Some(pid),
             _ => None,
         });
@@ -2605,8 +1720,8 @@ impl Tab {
     pub fn update_active_pane_name(&mut self, buf: Vec<u8>, client_id: ClientId) {
         if let Some(active_terminal_id) = self.get_active_terminal_id(client_id) {
             let active_terminal = self
-                .panes
-                .get_mut(&PaneId::Terminal(active_terminal_id))
+                .tiled_panes
+                .get_pane_mut(PaneId::Terminal(active_terminal_id))
                 .unwrap();
 
             // It only allows printable unicode, delete and backspace keys.
@@ -2631,21 +1746,15 @@ impl Tab {
             && line <= viewport.y + viewport.rows
             && column <= viewport.x + viewport.cols
     }
-}
-
-#[allow(clippy::borrowed_box)]
-pub fn is_inside_viewport(viewport: &Viewport, pane: &Box<dyn Pane>) -> bool {
-    let pane_position_and_size = pane.current_geom();
-    pane_position_and_size.y >= viewport.y
-        && pane_position_and_size.y + pane_position_and_size.rows.as_usize()
-            <= viewport.y + viewport.rows
-}
 
-pub fn pane_geom_is_inside_viewport(viewport: &Viewport, geom: &PaneGeom) -> bool {
-    geom.y >= viewport.y
-        && geom.y + geom.rows.as_usize() <= viewport.y + viewport.rows
-        && geom.x >= viewport.x
-        && geom.x + geom.cols.as_usize() <= viewport.x + viewport.cols
+    pub fn set_pane_frames(&mut self, should_set_pane_frames: bool) {
+        self.tiled_panes.set_pane_frames(should_set_pane_frames);
+        self.should_clear_display_before_rendering = true;
+        self.set_force_render();
+    }
+    pub fn panes_to_hide_count(&self) -> usize {
+        self.tiled_panes.panes_to_hide_count()
+    }
 }
 
 #[cfg(test)]
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__drag_pane_with_mouse.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__drag_pane_with_mouse.snap
index bab72f60..180b7c50 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__drag_pane_with_mouse.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__drag_pane_with_mouse.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                                 │                                                          │                          │
 10 (C): │                                 │                                                          │                          │
 11 (C): │                                 │                   I am scratch terminal                  │                          │
-12 (C): │ ┌ Pane #2 ─────────────── SCROLL│                                                          │────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SCROLL│                                                          │────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                          │EEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                          │EEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                          │EEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__five_new_floating_panes.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__five_new_floating_panes.snap
index 9f4d3777..93fdee06 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__five_new_floating_panes.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__five_new_floating_panes.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│─────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                             │                   I am scratch terminal                  │                              │
 10 (C): │                             │                                                          │                              │
 11 (C): │                             │                                                          │                              │
-12 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #6 ─────────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│─────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__mark_text_inside_floating_pane.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__mark_text_inside_floating_pane.snap
index 38417876..de6f2ecd 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__mark_text_inside_floating_pane.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__mark_text_inside_floating_pane.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                             │                   I am scratch terminal                  │                              │
 10 (C): │                             │                                                          │                              │
 11 (C): │                             │                                                          │                              │
-12 (C): │ ┌ Pane #2 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                          │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_down.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_down.snap
index 96faec6e..c86c5998 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_down.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_down.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                             │                   I am scratch terminal                  │                              │
 10 (C): │                             │                                                          │                              │
 11 (C): │                             │                                                          │                              │
-12 (C): │ ┌ Pane #2 ─────────────── SC│                                                ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SC│                                                ┌ Pane #6 ─────────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└────────────────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_left.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_left.snap
index 38417876..de6f2ecd 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_left.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_left.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                             │                   I am scratch terminal                  │                              │
 10 (C): │                             │                                                          │                              │
 11 (C): │                             │                                                          │                              │
-12 (C): │ ┌ Pane #2 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                          │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_right.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_right.snap
index 95f61793..17bbcb17 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_right.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_right.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ───────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                             │                   I am scratch terminal                  │                              │
 10 (C): │                             │                                                          │                              │
 11 (C): │                             │                                                          │                              │
-12 (C): │ ┌ Pane #2 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                          │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_up.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_up.snap
index 38417876..de6f2ecd 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_up.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_up.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                             │                   I am scratch terminal                  │                              │
 10 (C): │                             │                                                          │                              │
 11 (C): │                             │                                                          │                              │
-12 (C): │ ┌ Pane #2 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                          │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_with_mouse.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_with_mouse.snap
index 38417876..de6f2ecd 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_with_mouse.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__move_floating_pane_focus_with_mouse.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE┌ Pane #2 ─────────────────────────────────────────────────┐EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                             │                   I am scratch terminal                  │                              │
 10 (C): │                             │                                                          │                              │
 11 (C): │                             │                                                          │                              │
-12 (C): │ ┌ Pane #2 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SC│                                                          │────────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                          │EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEE└──────────────────────────────────────────────────────────┘EEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__resize_tab_with_floating_panes.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__resize_tab_with_floating_panes.snap
index 223045ff..33d01c0b 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__resize_tab_with_floating_panes.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__resize_tab_with_floating_panes.snap
@@ -5,9 +5,9 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ────────────────────┌ Pane #2 ─────────────────────────────────────────────────┐─────────┐                     
 01 (C): │                             │                                                          │         │                     
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                  ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                     
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                  ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐                     
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                  │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                     
-04 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐        I am scrat┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                     
+04 (C): │ ┌ Pane #5 ─────────────── SCROLL:  0/1 ┐        I am scrat┌ Pane #6 ─────────────── SCROLL:  0/1 ┐                     
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                  │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                     
 06 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                  │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                     
 07 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                  │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                     
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically.snap
index 7e5a2f06..e0292d16 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically.snap
@@ -5,9 +5,9 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ────────────────────┌ Pane #2 ─────────┐                                                                       
 01 (C): │                             │                  │                                                                       
-02 (C): │ ┌ Pane #┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                                                       
+02 (C): │ ┌ Pane #┌ Pane #4 ─────────────── SCROLL:  0/1 ┐                                                                       
 03 (C): │ │EEEEEEE│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                                       
-04 (C): │ ┌ Pane #┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                                                       
+04 (C): │ ┌ Pane #┌ Pane #6 ─────────────── SCROLL:  0/1 ┐                                                                       
 05 (C): │ │EEEEEEE│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                                       
 06 (C): │ │EEEEEEE│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                                       
 07 (C): │ │EEEEEEE│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                                                       
diff --git a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically_and_expand_back.snap b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically_and_expand_back.snap
index 9f4d3777..93fdee06 100644
--- a/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically_and_expand_back.snap
+++ b/zellij-server/src/tab/unit/snapshots/zellij_server__tab__tab_integration_tests__shrink_whole_tab_with_floating_panes_horizontally_and_vertically_and_expand_back.snap
@@ -5,7 +5,7 @@ expression: snapshot
 ---
 00 (C): ┌ Pane #1 ──────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
 01 (C): │                                                                                                                       │
-02 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+02 (C): │ ┌ Pane #3 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #4 ─────────────── SCROLL:  0/1 ┐ │
 03 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 04 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 05 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│─────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
@@ -15,7 +15,7 @@ expression: snapshot
 09 (C): │                             │                   I am scratch terminal                  │                              │
 10 (C): │                             │                                                          │                              │
 11 (C): │                             │                                                          │                              │
-12 (C): │ ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #2 ─────────────── SCROLL:  0/1 ┐ │
+12 (C): │ ┌ Pane #5 ─────────────── SCROLL:  0/1 ┐                                     ┌ Pane #6 ─────────────── SCROLL:  0/1 ┐ │
 13 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 14 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│─────────────────────────────────────│EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
 15 (C): │ │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│                                     │EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE│ │
diff --git a/zellij-server/src/tab/unit/tab_tests.rs b/zellij-server/src/tab/unit/tab_tests.rs
index 527894aa..64fb0c23 100644
--- a/zellij-server/src/tab/unit/tab_tests.rs
+++ b/zellij-server/src/tab/unit/tab_tests.rs
@@ -134,9 +134,10 @@ fn split_panes_vertically() {
     let mut tab = create_new_tab(size);
     let new_pane_id = PaneId::Terminal(2);
     tab.vertical_split(new_pane_id, 1);
-    assert_eq!(tab.panes.len(), 2, "The tab has two panes");
+    assert_eq!(tab.tiled_panes.panes.len(), 2, "The tab has two panes");
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -145,7 +146,8 @@ fn split_panes_vertically() {
         "first pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -154,7 +156,8 @@ fn split_panes_vertically() {
         "first pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -164,7 +167,8 @@ fn split_panes_vertically() {
         "first pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -174,7 +178,8 @@ fn split_panes_vertically() {
         "first pane row count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -183,7 +188,8 @@ fn split_panes_vertically() {
         "second pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -192,7 +198,8 @@ fn split_panes_vertically() {
         "second pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -202,7 +209,8 @@ fn split_panes_vertically() {
         "second pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -222,10 +230,11 @@ fn split_panes_horizontally() {
     let mut tab = create_new_tab(size);
     let new_pane_id = PaneId::Terminal(2);
     tab.horizontal_split(new_pane_id, 1);
-    assert_eq!(tab.panes.len(), 2, "The tab has two panes");
+    assert_eq!(tab.tiled_panes.panes.len(), 2, "The tab has two panes");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -234,7 +243,8 @@ fn split_panes_horizontally() {
         "first pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -243,7 +253,8 @@ fn split_panes_horizontally() {
         "first pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -253,7 +264,8 @@ fn split_panes_horizontally() {
         "first pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -264,7 +276,8 @@ fn split_panes_horizontally() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -273,7 +286,8 @@ fn split_panes_horizontally() {
         "second pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -282,7 +296,8 @@ fn split_panes_horizontally() {
         "second pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -292,7 +307,8 @@ fn split_panes_horizontally() {
         "second pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -314,10 +330,11 @@ fn split_largest_pane() {
         let new_pane_id = PaneId::Terminal(i);
         tab.new_pane(new_pane_id, Some(1));
     }
-    assert_eq!(tab.panes.len(), 4, "The tab has four panes");
+    assert_eq!(tab.tiled_panes.panes.len(), 4, "The tab has four panes");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -326,7 +343,8 @@ fn split_largest_pane() {
         "first pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -335,7 +353,8 @@ fn split_largest_pane() {
         "first pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -345,7 +364,8 @@ fn split_largest_pane() {
         "first pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -356,7 +376,8 @@ fn split_largest_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -365,7 +386,8 @@ fn split_largest_pane() {
         "second pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -374,7 +396,8 @@ fn split_largest_pane() {
         "second pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -384,7 +407,8 @@ fn split_largest_pane() {
         "second pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -395,7 +419,8 @@ fn split_largest_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -404,7 +429,8 @@ fn split_largest_pane() {
         "third pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -413,7 +439,8 @@ fn split_largest_pane() {
         "third pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -423,7 +450,8 @@ fn split_largest_pane() {
         "third pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -434,7 +462,8 @@ fn split_largest_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -443,7 +472,8 @@ fn split_largest_pane() {
         "fourth pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -452,7 +482,8 @@ fn split_largest_pane() {
         "fourth pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -462,7 +493,8 @@ fn split_largest_pane() {
         "fourth pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -478,7 +510,11 @@ pub fn cannot_split_panes_vertically_when_active_pane_is_too_small() {
     let size = Size { cols: 8, rows: 20 };
     let mut tab = create_new_tab(size);
     tab.vertical_split(PaneId::Terminal(2), 1);
-    assert_eq!(tab.panes.len(), 1, "Tab still has only one pane");
+    assert_eq!(
+        tab.tiled_panes.panes.len(),
+        1,
+        "Tab still has only one pane"
+    );
 }
 
 #[test]
@@ -486,7 +522,11 @@ pub fn cannot_split_panes_horizontally_when_active_pane_is_too_small() {
     let size = Size { cols: 121, rows: 4 };
     let mut tab = create_new_tab(size);
     tab.horizontal_split(PaneId::Terminal(2), 1);
-    assert_eq!(tab.panes.len(), 1, "Tab still has only one pane");
+    assert_eq!(
+        tab.tiled_panes.panes.len(),
+        1,
+        "Tab still has only one pane"
+    );
 }
 
 #[test]
@@ -494,7 +534,11 @@ pub fn cannot_split_largest_pane_when_there_is_no_room() {
     let size = Size { cols: 8, rows: 4 };
     let mut tab = create_new_tab(size);
     tab.new_pane(PaneId::Terminal(2), Some(1));
-    assert_eq!(tab.panes.len(), 1, "Tab still has only one pane");
+    assert_eq!(
+        tab.tiled_panes.panes.len(),
+        1,
+        "Tab still has only one pane"
+    );
 }
 
 #[test]
@@ -510,43 +554,59 @@ pub fn toggle_focused_pane_fullscreen() {
     }
     tab.toggle_active_pane_fullscreen(1);
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().x(),
+        tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().x(),
         0,
         "Pane x is on screen edge"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().y(),
+        tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().y(),
         0,
         "Pane y is on screen edge"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().cols(),
+        tab.tiled_panes
+            .panes
+            .get(&PaneId::Terminal(4))
+            .unwrap()
+            .cols(),
         121,
         "Pane cols match fullscreen cols"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().rows(),
+        tab.tiled_panes
+            .panes
+            .get(&PaneId::Terminal(4))
+            .unwrap()
+            .rows(),
         20,
         "Pane rows match fullscreen rows"
     );
     tab.toggle_active_pane_fullscreen(1);
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().x(),
+        tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().x(),
         61,
         "Pane x is on screen edge"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().y(),
+        tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().y(),
         10,
         "Pane y is on screen edge"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().cols(),
+        tab.tiled_panes
+            .panes
+            .get(&PaneId::Terminal(4))
+            .unwrap()
+            .cols(),
         60,
         "Pane cols match fullscreen cols"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().rows(),
+        tab.tiled_panes
+            .panes
+            .get(&PaneId::Terminal(4))
+            .unwrap()
+            .rows(),
         10,
         "Pane rows match fullscreen rows"
     );
@@ -568,22 +628,30 @@ pub fn move_focus_is_disabled_in_fullscreen() {
     tab.toggle_active_pane_fullscreen(1);
     tab.move_focus_left(1);
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().x(),
+        tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().x(),
         0,
         "Pane x is on screen edge"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().y(),
+        tab.tiled_panes.panes.get(&PaneId::Terminal(4)).unwrap().y(),
         0,
         "Pane y is on screen edge"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().cols(),
+        tab.tiled_panes
+            .panes
+            .get(&PaneId::Terminal(4))
+            .unwrap()
+            .cols(),
         121,
         "Pane cols match fullscreen cols"
     );
     assert_eq!(
-        tab.panes.get(&PaneId::Terminal(4)).unwrap().rows(),
+        tab.tiled_panes
+            .panes
+            .get(&PaneId::Terminal(4))
+            .unwrap()
+            .rows(),
         20,
         "Pane rows match fullscreen rows"
     );
@@ -608,10 +676,11 @@ pub fn close_pane_with_another_pane_above_it() {
     let new_pane_id = PaneId::Terminal(2);
     tab.horizontal_split(new_pane_id, 1);
     tab.close_focused_pane(1);
-    assert_eq!(tab.panes.len(), 1, "One pane left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 1, "One pane left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -620,7 +689,8 @@ pub fn close_pane_with_another_pane_above_it() {
         "remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -629,7 +699,8 @@ pub fn close_pane_with_another_pane_above_it() {
         "remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -639,7 +710,8 @@ pub fn close_pane_with_another_pane_above_it() {
         "remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -670,10 +742,11 @@ pub fn close_pane_with_another_pane_below_it() {
     tab.horizontal_split(new_pane_id, 1);
     tab.move_focus_up(1);
     tab.close_focused_pane(1);
-    assert_eq!(tab.panes.len(), 1, "One pane left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 1, "One pane left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -682,7 +755,8 @@ pub fn close_pane_with_another_pane_below_it() {
         "remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -691,7 +765,8 @@ pub fn close_pane_with_another_pane_below_it() {
         "remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -701,7 +776,8 @@ pub fn close_pane_with_another_pane_below_it() {
         "remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -728,10 +804,11 @@ pub fn close_pane_with_another_pane_to_the_left() {
     let new_pane_id = PaneId::Terminal(2);
     tab.vertical_split(new_pane_id, 1);
     tab.close_focused_pane(1);
-    assert_eq!(tab.panes.len(), 1, "One pane left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 1, "One pane left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -740,7 +817,8 @@ pub fn close_pane_with_another_pane_to_the_left() {
         "remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -749,7 +827,8 @@ pub fn close_pane_with_another_pane_to_the_left() {
         "remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -759,7 +838,8 @@ pub fn close_pane_with_another_pane_to_the_left() {
         "remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -787,10 +867,11 @@ pub fn close_pane_with_another_pane_to_the_right() {
     tab.vertical_split(new_pane_id, 1);
     tab.move_focus_left(1);
     tab.close_focused_pane(1);
-    assert_eq!(tab.panes.len(), 1, "One pane left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 1, "One pane left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -799,7 +880,8 @@ pub fn close_pane_with_another_pane_to_the_right() {
         "remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -808,7 +890,8 @@ pub fn close_pane_with_another_pane_to_the_right() {
         "remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -818,7 +901,8 @@ pub fn close_pane_with_another_pane_to_the_right() {
         "remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -851,10 +935,11 @@ pub fn close_pane_with_multiple_panes_above_it() {
     tab.vertical_split(new_pane_id_2, 1);
     tab.move_focus_down(1);
     tab.close_focused_pane(1);
-    assert_eq!(tab.panes.len(), 2, "Two panes left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 2, "Two panes left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -863,7 +948,8 @@ pub fn close_pane_with_multiple_panes_above_it() {
         "first remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -872,7 +958,8 @@ pub fn close_pane_with_multiple_panes_above_it() {
         "first remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -882,7 +969,8 @@ pub fn close_pane_with_multiple_panes_above_it() {
         "first remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -893,7 +981,8 @@ pub fn close_pane_with_multiple_panes_above_it() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -902,7 +991,8 @@ pub fn close_pane_with_multiple_panes_above_it() {
         "second remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -911,7 +1001,8 @@ pub fn close_pane_with_multiple_panes_above_it() {
         "second remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -921,7 +1012,8 @@ pub fn close_pane_with_multiple_panes_above_it() {
         "second remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -953,10 +1045,11 @@ pub fn close_pane_with_multiple_panes_below_it() {
     tab.vertical_split(new_pane_id_2, 1);
     tab.move_focus_up(1);
     tab.close_focused_pane(1);
-    assert_eq!(tab.panes.len(), 2, "Two panes left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 2, "Two panes left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -965,7 +1058,8 @@ pub fn close_pane_with_multiple_panes_below_it() {
         "first remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -974,7 +1068,8 @@ pub fn close_pane_with_multiple_panes_below_it() {
         "first remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -984,7 +1079,8 @@ pub fn close_pane_with_multiple_panes_below_it() {
         "first remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -995,7 +1091,8 @@ pub fn close_pane_with_multiple_panes_below_it() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1004,7 +1101,8 @@ pub fn close_pane_with_multiple_panes_below_it() {
         "second remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1013,7 +1111,8 @@ pub fn close_pane_with_multiple_panes_below_it() {
         "second remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1023,7 +1122,8 @@ pub fn close_pane_with_multiple_panes_below_it() {
         "second remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1056,10 +1156,11 @@ pub fn close_pane_with_multiple_panes_to_the_left() {
     tab.horizontal_split(new_pane_id_2, 1);
     tab.move_focus_right(1);
     tab.close_focused_pane(1);
-    assert_eq!(tab.panes.len(), 2, "Two panes left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 2, "Two panes left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1068,7 +1169,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() {
         "first remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1077,7 +1179,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() {
         "first remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1087,7 +1190,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() {
         "first remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1098,7 +1202,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1107,7 +1212,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() {
         "second remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1116,7 +1222,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() {
         "second remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1126,7 +1233,8 @@ pub fn close_pane_with_multiple_panes_to_the_left() {
         "second remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1158,10 +1266,11 @@ pub fn close_pane_with_multiple_panes_to_the_right() {
     tab.horizontal_split(new_pane_id_2, 1);
     tab.move_focus_left(1);
     tab.close_focused_pane(1);
-    assert_eq!(tab.panes.len(), 2, "Two panes left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 2, "Two panes left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1170,7 +1279,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() {
         "first remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1179,7 +1289,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() {
         "first remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1189,7 +1300,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() {
         "first remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1200,7 +1312,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1209,7 +1322,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() {
         "second remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1218,7 +1332,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() {
         "second remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1228,7 +1343,8 @@ pub fn close_pane_with_multiple_panes_to_the_right() {
         "second remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1277,10 +1393,11 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
     tab.move_focus_down(1);
     tab.close_focused_pane(1);
 
-    assert_eq!(tab.panes.len(), 6, "Six panes left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 6, "Six panes left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1289,7 +1406,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "first remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1298,7 +1416,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "first remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1308,7 +1427,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "first remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1319,7 +1439,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1328,7 +1449,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "second remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1337,7 +1459,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "second remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1347,7 +1470,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "second remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1358,7 +1482,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1367,7 +1492,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "third remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1376,7 +1502,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "third remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1386,7 +1513,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "third remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1397,7 +1525,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1406,7 +1535,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "fourth remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1415,7 +1545,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "fourth remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1425,7 +1556,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "fourth remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1436,7 +1568,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -1445,7 +1578,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "sixths remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -1454,7 +1588,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "sixths remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -1464,7 +1599,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "sixths remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -1475,7 +1611,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -1484,7 +1621,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "seventh remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -1493,7 +1631,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "seventh remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -1503,7 +1642,8 @@ pub fn close_pane_with_multiple_panes_above_it_away_from_screen_edges() {
         "seventh remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -1552,10 +1692,11 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
     tab.move_focus_up(1);
     tab.close_focused_pane(1);
 
-    assert_eq!(tab.panes.len(), 6, "Six panes left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 6, "Six panes left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1564,7 +1705,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "first remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1573,7 +1715,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "first remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1583,7 +1726,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "first remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1594,7 +1738,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1603,7 +1748,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "third remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1612,7 +1758,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "third remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1622,7 +1769,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "third remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1633,7 +1781,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1642,7 +1791,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "fourth remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1651,7 +1801,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "fourth remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1661,7 +1812,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "fourth remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1672,7 +1824,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -1681,7 +1834,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "second remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -1690,7 +1844,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "second remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -1700,7 +1855,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "second remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -1711,7 +1867,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -1720,7 +1877,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "sixths remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -1729,7 +1887,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "sixths remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -1739,7 +1898,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "sixths remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -1750,7 +1910,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -1759,7 +1920,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "seventh remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -1768,7 +1930,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "seventh remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -1778,7 +1941,8 @@ pub fn close_pane_with_multiple_panes_below_it_away_from_screen_edges() {
         "seventh remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -1832,10 +1996,11 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
     tab.move_focus_right(1);
     tab.close_focused_pane(1);
 
-    assert_eq!(tab.panes.len(), 6, "Six panes left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 6, "Six panes left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1844,7 +2009,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "first remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1853,7 +2019,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "first remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1863,7 +2030,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "first remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -1874,7 +2042,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1883,7 +2052,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "third remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1892,7 +2062,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "third remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1902,7 +2073,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "third remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -1913,7 +2085,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1922,7 +2095,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "fourth remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1931,7 +2105,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "fourth remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1941,7 +2116,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "fourth remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -1952,7 +2128,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1961,7 +2138,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "second remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1970,7 +2148,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "second remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1980,7 +2159,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "second remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -1991,7 +2171,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -2000,7 +2181,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "sixths remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -2009,7 +2191,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "sixths remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -2019,7 +2202,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "sixths remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -2030,7 +2214,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -2039,7 +2224,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "seventh remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -2048,7 +2234,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "seventh remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -2058,7 +2245,8 @@ pub fn close_pane_with_multiple_panes_to_the_left_away_from_screen_edges() {
         "seventh remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -2111,10 +2299,11 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
     tab.move_focus_left(1);
     tab.close_focused_pane(1);
 
-    assert_eq!(tab.panes.len(), 6, "Six panes left in tab");
+    assert_eq!(tab.tiled_panes.panes.len(), 6, "Six panes left in tab");
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2123,7 +2312,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "first remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2132,7 +2322,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "first remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2142,7 +2333,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "first remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2153,7 +2345,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -2162,7 +2355,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "fourth remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -2171,7 +2365,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "fourth remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -2181,7 +2376,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "fourth remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -2192,7 +2388,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -2201,7 +2398,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "second remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -2210,7 +2408,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "second remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -2220,7 +2419,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "second remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -2231,7 +2431,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -2240,7 +2441,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "third remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -2249,7 +2451,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "third remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -2259,7 +2462,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "third remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -2270,7 +2474,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -2279,7 +2484,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "sixths remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -2288,7 +2494,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "sixths remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -2298,7 +2505,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "sixths remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -2309,7 +2517,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -2318,7 +2527,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "seventh remaining pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -2327,7 +2537,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "seventh remaining pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -2337,7 +2548,8 @@ pub fn close_pane_with_multiple_panes_to_the_right_away_from_screen_edges() {
         "seventh remaining pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -2803,17 +3015,28 @@ pub fn resize_down_with_pane_above() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes.get(&new_pane_id).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "focused pane x position"
     );
     assert_eq!(
-        tab.panes.get(&new_pane_id).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id)
+            .unwrap()
+            .position_and_size()
+            .y,
         11,
         "focused pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id)
             .unwrap()
             .position_and_size()
@@ -2823,7 +3046,8 @@ pub fn resize_down_with_pane_above() {
         "focused pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id)
             .unwrap()
             .position_and_size()
@@ -2834,7 +3058,8 @@ pub fn resize_down_with_pane_above() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2843,7 +3068,8 @@ pub fn resize_down_with_pane_above() {
         "pane above x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2852,7 +3078,8 @@ pub fn resize_down_with_pane_above() {
         "pane above y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2862,7 +3089,8 @@ pub fn resize_down_with_pane_above() {
         "pane above column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2894,17 +3122,28 @@ pub fn resize_down_with_pane_below() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes.get(&new_pane_id).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "pane below x position"
     );
     assert_eq!(
-        tab.panes.get(&new_pane_id).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id)
+            .unwrap()
+            .position_and_size()
+            .y,
         11,
         "pane below y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id)
             .unwrap()
             .position_and_size()
@@ -2914,7 +3153,8 @@ pub fn resize_down_with_pane_below() {
         "pane below column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id)
             .unwrap()
             .position_and_size()
@@ -2925,7 +3165,8 @@ pub fn resize_down_with_pane_below() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2934,7 +3175,8 @@ pub fn resize_down_with_pane_below() {
         "focused pane x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2943,7 +3185,8 @@ pub fn resize_down_with_pane_below() {
         "focused pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2953,7 +3196,8 @@ pub fn resize_down_with_pane_below() {
         "focused pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -2992,17 +3236,28 @@ pub fn resize_down_with_panes_above_and_below() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes.get(&new_pane_id_1).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id_1)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "focused pane x position"
     );
     assert_eq!(
-        tab.panes.get(&new_pane_id_1).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id_1)
+            .unwrap()
+            .position_and_size()
+            .y,
         15,
         "focused pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id_1)
             .unwrap()
             .position_and_size()
@@ -3012,7 +3267,8 @@ pub fn resize_down_with_panes_above_and_below() {
         "focused pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id_1)
             .unwrap()
             .position_and_size()
@@ -3023,17 +3279,28 @@ pub fn resize_down_with_panes_above_and_below() {
     );
 
     assert_eq!(
-        tab.panes.get(&new_pane_id_2).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id_2)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "pane below x position"
     );
     assert_eq!(
-        tab.panes.get(&new_pane_id_2).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id_2)
+            .unwrap()
+            .position_and_size()
+            .y,
         24,
         "pane below y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id_2)
             .unwrap()
             .position_and_size()
@@ -3043,7 +3310,8 @@ pub fn resize_down_with_panes_above_and_below() {
         "pane below column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id_2)
             .unwrap()
             .position_and_size()
@@ -3054,17 +3322,28 @@ pub fn resize_down_with_panes_above_and_below() {
     );
 
     assert_eq!(
-        tab.panes.get(&first_pane_id).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&first_pane_id)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "pane above x position"
     );
     assert_eq!(
-        tab.panes.get(&first_pane_id).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&first_pane_id)
+            .unwrap()
+            .position_and_size()
+            .y,
         0,
         "pane above y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&first_pane_id)
             .unwrap()
             .position_and_size()
@@ -3074,7 +3353,8 @@ pub fn resize_down_with_panes_above_and_below() {
         "pane above column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&first_pane_id)
             .unwrap()
             .position_and_size()
@@ -3110,17 +3390,28 @@ pub fn resize_down_with_multiple_panes_above() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes.get(&new_pane_id_1).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id_1)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "focused pane x position"
     );
     assert_eq!(
-        tab.panes.get(&new_pane_id_1).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id_1)
+            .unwrap()
+            .position_and_size()
+            .y,
         16,
         "focused pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id_1)
             .unwrap()
             .position_and_size()
@@ -3130,7 +3421,8 @@ pub fn resize_down_with_multiple_panes_above() {
         "focused pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id_1)
             .unwrap()
             .position_and_size()
@@ -3141,17 +3433,28 @@ pub fn resize_down_with_multiple_panes_above() {
     );
 
     assert_eq!(
-        tab.panes.get(&new_pane_id_2).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id_2)
+            .unwrap()
+            .position_and_size()
+            .x,
         61,
         "first pane above x position"
     );
     assert_eq!(
-        tab.panes.get(&new_pane_id_2).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&new_pane_id_2)
+            .unwrap()
+            .position_and_size()
+            .y,
         0,
         "first pane above y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id_2)
             .unwrap()
             .position_and_size()
@@ -3161,7 +3464,8 @@ pub fn resize_down_with_multiple_panes_above() {
         "first pane above column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&new_pane_id_2)
             .unwrap()
             .position_and_size()
@@ -3172,17 +3476,28 @@ pub fn resize_down_with_multiple_panes_above() {
     );
 
     assert_eq!(
-        tab.panes.get(&first_pane_id).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&first_pane_id)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "second pane above x position"
     );
     assert_eq!(
-        tab.panes.get(&first_pane_id).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&first_pane_id)
+            .unwrap()
+            .position_and_size()
+            .y,
         0,
         "second pane above y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&first_pane_id)
             .unwrap()
             .position_and_size()
@@ -3192,7 +3507,8 @@ pub fn resize_down_with_multiple_panes_above() {
         "second pane above column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&first_pane_id)
             .unwrap()
             .position_and_size()
@@ -3230,17 +3546,28 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes.get(&focused_pane).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&focused_pane)
+            .unwrap()
+            .position_and_size()
+            .x,
         61,
         "focused pane x position"
     );
     assert_eq!(
-        tab.panes.get(&focused_pane).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&focused_pane)
+            .unwrap()
+            .position_and_size()
+            .y,
         16,
         "focused pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&focused_pane)
             .unwrap()
             .position_and_size()
@@ -3250,7 +3577,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
         "focused pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&focused_pane)
             .unwrap()
             .position_and_size()
@@ -3261,7 +3589,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above_and_left)
             .unwrap()
             .position_and_size()
@@ -3270,7 +3599,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
         "pane above and to the left x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above_and_left)
             .unwrap()
             .position_and_size()
@@ -3279,7 +3609,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
         "pane above and to the left y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above_and_left)
             .unwrap()
             .position_and_size()
@@ -3289,7 +3620,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
         "pane above and to the left column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above_and_left)
             .unwrap()
             .position_and_size()
@@ -3300,17 +3632,28 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes.get(&pane_above).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&pane_above)
+            .unwrap()
+            .position_and_size()
+            .x,
         61,
         "pane above x position"
     );
     assert_eq!(
-        tab.panes.get(&pane_above).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&pane_above)
+            .unwrap()
+            .position_and_size()
+            .y,
         0,
         "pane above y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above)
             .unwrap()
             .position_and_size()
@@ -3320,7 +3663,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
         "pane above column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above)
             .unwrap()
             .position_and_size()
@@ -3331,7 +3675,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_left)
             .unwrap()
             .position_and_size()
@@ -3340,7 +3685,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
         "pane to the left x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_left)
             .unwrap()
             .position_and_size()
@@ -3349,7 +3695,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
         "pane to the left y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_left)
             .unwrap()
             .position_and_size()
@@ -3359,7 +3706,8 @@ pub fn resize_down_with_panes_above_aligned_left_with_current_pane() {
         "pane to the left column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_left)
             .unwrap()
             .position_and_size()
@@ -3397,17 +3745,28 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes.get(&focused_pane).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&focused_pane)
+            .unwrap()
+            .position_and_size()
+            .x,
         61,
         "focused pane x position"
     );
     assert_eq!(
-        tab.panes.get(&focused_pane).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&focused_pane)
+            .unwrap()
+            .position_and_size()
+            .y,
         0,
         "focused pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&focused_pane)
             .unwrap()
             .position_and_size()
@@ -3417,7 +3776,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
         "focused pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&focused_pane)
             .unwrap()
             .position_and_size()
@@ -3428,7 +3788,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_left)
             .unwrap()
             .position_and_size()
@@ -3437,7 +3798,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
         "pane above and to the left x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_left)
             .unwrap()
             .position_and_size()
@@ -3446,7 +3808,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
         "pane above and to the left y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_left)
             .unwrap()
             .position_and_size()
@@ -3456,7 +3819,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
         "pane above and to the left column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_left)
             .unwrap()
             .position_and_size()
@@ -3467,17 +3831,28 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes.get(&pane_below).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&pane_below)
+            .unwrap()
+            .position_and_size()
+            .x,
         61,
         "pane above x position"
     );
     assert_eq!(
-        tab.panes.get(&pane_below).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&pane_below)
+            .unwrap()
+            .position_and_size()
+            .y,
         16,
         "pane above y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below)
             .unwrap()
             .position_and_size()
@@ -3487,7 +3862,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
         "pane above column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below)
             .unwrap()
             .position_and_size()
@@ -3498,7 +3874,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below_and_left)
             .unwrap()
             .position_and_size()
@@ -3507,7 +3884,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
         "pane to the left x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below_and_left)
             .unwrap()
             .position_and_size()
@@ -3516,7 +3894,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
         "pane to the left y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below_and_left)
             .unwrap()
             .position_and_size()
@@ -3526,7 +3905,8 @@ pub fn resize_down_with_panes_below_aligned_left_with_current_pane() {
         "pane to the left column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below_and_left)
             .unwrap()
             .position_and_size()
@@ -3566,17 +3946,28 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes.get(&focused_pane).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&focused_pane)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "focused pane x position"
     );
     assert_eq!(
-        tab.panes.get(&focused_pane).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&focused_pane)
+            .unwrap()
+            .position_and_size()
+            .y,
         16,
         "focused pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&focused_pane)
             .unwrap()
             .position_and_size()
@@ -3586,7 +3977,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
         "focused pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&focused_pane)
             .unwrap()
             .position_and_size()
@@ -3597,17 +3989,28 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes.get(&pane_above).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&pane_above)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "pane above x position"
     );
     assert_eq!(
-        tab.panes.get(&pane_above).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&pane_above)
+            .unwrap()
+            .position_and_size()
+            .y,
         0,
         "pane above y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above)
             .unwrap()
             .position_and_size()
@@ -3617,7 +4020,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
         "pane above column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above)
             .unwrap()
             .position_and_size()
@@ -3628,7 +4032,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_right)
             .unwrap()
             .position_and_size()
@@ -3637,7 +4042,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
         "pane to the right x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_right)
             .unwrap()
             .position_and_size()
@@ -3646,7 +4052,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
         "pane to the right y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_right)
             .unwrap()
             .position_and_size()
@@ -3656,7 +4063,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
         "pane to the right column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_right)
             .unwrap()
             .position_and_size()
@@ -3667,7 +4075,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above_and_right)
             .unwrap()
             .position_and_size()
@@ -3676,7 +4085,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
         "pane above and to the right x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above_and_right)
             .unwrap()
             .position_and_size()
@@ -3685,7 +4095,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
         "pane above and to the right y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above_and_right)
             .unwrap()
             .position_and_size()
@@ -3695,7 +4106,8 @@ pub fn resize_down_with_panes_above_aligned_right_with_current_pane() {
         "pane above and to the right column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_above_and_right)
             .unwrap()
             .position_and_size()
@@ -3734,17 +4146,28 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes.get(&focused_pane).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&focused_pane)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "focused pane x position"
     );
     assert_eq!(
-        tab.panes.get(&focused_pane).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&focused_pane)
+            .unwrap()
+            .position_and_size()
+            .y,
         0,
         "focused pane y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&focused_pane)
             .unwrap()
             .position_and_size()
@@ -3754,7 +4177,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
         "focused pane column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&focused_pane)
             .unwrap()
             .position_and_size()
@@ -3765,17 +4189,28 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes.get(&pane_below).unwrap().position_and_size().x,
+        tab.tiled_panes
+            .panes
+            .get(&pane_below)
+            .unwrap()
+            .position_and_size()
+            .x,
         0,
         "pane below x position"
     );
     assert_eq!(
-        tab.panes.get(&pane_below).unwrap().position_and_size().y,
+        tab.tiled_panes
+            .panes
+            .get(&pane_below)
+            .unwrap()
+            .position_and_size()
+            .y,
         16,
         "pane below y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below)
             .unwrap()
             .position_and_size()
@@ -3785,7 +4220,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
         "pane below column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below)
             .unwrap()
             .position_and_size()
@@ -3796,7 +4232,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below_and_right)
             .unwrap()
             .position_and_size()
@@ -3805,7 +4242,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
         "pane below and to the right x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below_and_right)
             .unwrap()
             .position_and_size()
@@ -3814,7 +4252,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
         "pane below and to the right y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below_and_right)
             .unwrap()
             .position_and_size()
@@ -3824,7 +4263,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
         "pane below and to the right column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_below_and_right)
             .unwrap()
             .position_and_size()
@@ -3835,7 +4275,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_right)
             .unwrap()
             .position_and_size()
@@ -3844,7 +4285,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
         "pane to the right x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_right)
             .unwrap()
             .position_and_size()
@@ -3853,7 +4295,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
         "pane to the right y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_right)
             .unwrap()
             .position_and_size()
@@ -3863,7 +4306,8 @@ pub fn resize_down_with_panes_below_aligned_right_with_current_pane() {
         "pane to the right column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&pane_to_the_right)
             .unwrap()
             .position_and_size()
@@ -3901,7 +4345,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -3910,7 +4355,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -3919,7 +4365,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -3929,7 +4376,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -3940,7 +4388,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -3949,7 +4398,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -3958,7 +4408,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -3968,7 +4419,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -3979,7 +4431,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -3988,7 +4441,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -3997,7 +4451,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4007,7 +4462,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4018,7 +4474,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4027,7 +4484,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4036,7 +4494,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4046,7 +4505,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4057,7 +4517,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4066,7 +4527,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4075,7 +4537,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4085,7 +4548,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4096,7 +4560,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4105,7 +4570,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4114,7 +4580,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4124,7 +4591,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4161,7 +4629,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4170,7 +4639,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4179,7 +4649,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4189,7 +4660,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4200,7 +4672,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4209,7 +4682,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4218,7 +4692,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4228,7 +4703,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4239,7 +4715,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4248,7 +4725,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4257,7 +4735,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4267,7 +4746,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4278,7 +4758,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4287,7 +4768,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4296,7 +4778,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4306,7 +4789,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4317,7 +4801,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4326,7 +4811,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4335,7 +4821,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4345,7 +4832,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4356,7 +4844,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4365,7 +4854,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4374,7 +4864,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4384,7 +4875,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4425,7 +4917,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4434,7 +4927,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4443,7 +4937,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4453,7 +4948,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4464,7 +4960,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4473,7 +4970,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4482,7 +4980,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4492,7 +4991,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4503,7 +5003,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4512,7 +5013,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4521,7 +5023,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4531,7 +5034,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4542,7 +5046,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4551,7 +5056,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4560,7 +5066,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4570,7 +5077,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4581,7 +5089,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4590,7 +5099,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4599,7 +5109,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4609,7 +5120,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4620,7 +5132,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4629,7 +5142,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4638,7 +5152,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4648,7 +5163,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4659,7 +5175,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -4668,7 +5185,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 7 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -4677,7 +5195,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 7 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -4687,7 +5206,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 7 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -4698,7 +5218,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -4707,7 +5228,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 8 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -4716,7 +5238,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 8 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -4726,7 +5249,8 @@ pub fn resize_down_with_panes_above_aligned_left_and_right_with_panes_to_the_lef
         "pane 8 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -4769,7 +5293,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4778,7 +5303,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4787,7 +5313,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4797,7 +5324,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -4808,7 +5336,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4817,7 +5346,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4826,7 +5356,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4836,7 +5367,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -4847,7 +5379,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4856,7 +5389,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4865,7 +5399,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4875,7 +5410,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -4886,7 +5422,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4895,7 +5432,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4904,7 +5442,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4914,7 +5453,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -4925,7 +5465,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4934,7 +5475,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4943,7 +5485,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4953,7 +5496,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -4964,7 +5508,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4973,7 +5518,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4982,7 +5528,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -4992,7 +5539,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -5003,7 +5551,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -5012,7 +5561,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 7 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -5021,7 +5571,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 7 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -5031,7 +5582,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 7 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -5042,7 +5594,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -5051,7 +5604,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 8 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -5060,7 +5614,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 8 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -5070,7 +5625,8 @@ pub fn resize_down_with_panes_below_aligned_left_and_right_with_to_the_left_and_
         "pane 8 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -5100,7 +5656,8 @@ pub fn cannot_resize_down_when_pane_below_is_at_minimum_height() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5110,7 +5667,8 @@ pub fn cannot_resize_down_when_pane_below_is_at_minimum_height() {
         "pane 1 height stayed the same"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5139,7 +5697,8 @@ pub fn resize_left_with_pane_to_the_left() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5148,7 +5707,8 @@ pub fn resize_left_with_pane_to_the_left() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5157,7 +5717,8 @@ pub fn resize_left_with_pane_to_the_left() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5167,7 +5728,8 @@ pub fn resize_left_with_pane_to_the_left() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5178,7 +5740,8 @@ pub fn resize_left_with_pane_to_the_left() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5187,7 +5750,8 @@ pub fn resize_left_with_pane_to_the_left() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5196,7 +5760,8 @@ pub fn resize_left_with_pane_to_the_left() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5206,7 +5771,8 @@ pub fn resize_left_with_pane_to_the_left() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5235,7 +5801,8 @@ pub fn resize_left_with_pane_to_the_right() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5244,7 +5811,8 @@ pub fn resize_left_with_pane_to_the_right() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5253,7 +5821,8 @@ pub fn resize_left_with_pane_to_the_right() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5263,7 +5832,8 @@ pub fn resize_left_with_pane_to_the_right() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5274,7 +5844,8 @@ pub fn resize_left_with_pane_to_the_right() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5283,7 +5854,8 @@ pub fn resize_left_with_pane_to_the_right() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5292,7 +5864,8 @@ pub fn resize_left_with_pane_to_the_right() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5302,7 +5875,8 @@ pub fn resize_left_with_pane_to_the_right() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5333,7 +5907,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5342,7 +5917,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5351,7 +5927,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5361,7 +5938,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5372,7 +5950,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5381,7 +5960,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5390,7 +5970,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5400,7 +5981,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5411,7 +5993,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5420,7 +6003,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5429,7 +6013,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5439,7 +6024,8 @@ pub fn resize_left_with_panes_to_the_left_and_right() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5470,7 +6056,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5479,7 +6066,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5488,7 +6076,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5498,7 +6087,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5509,7 +6099,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5518,7 +6109,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5527,7 +6119,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5537,7 +6130,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5548,7 +6142,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5557,7 +6152,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5566,7 +6162,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5576,7 +6173,8 @@ pub fn resize_left_with_multiple_panes_to_the_left() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5609,7 +6207,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5618,7 +6217,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5627,7 +6227,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5637,7 +6238,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5648,7 +6250,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5657,7 +6260,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5666,7 +6270,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5676,7 +6281,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5687,7 +6293,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5696,7 +6303,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5705,7 +6313,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5715,7 +6324,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5726,7 +6336,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -5735,7 +6346,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -5744,7 +6356,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -5754,7 +6367,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -5788,7 +6402,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5797,7 +6412,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5806,7 +6422,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5816,7 +6433,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5827,7 +6445,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5836,7 +6455,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5845,7 +6465,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5855,7 +6476,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -5866,7 +6488,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5875,7 +6498,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5884,7 +6508,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5894,7 +6519,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -5905,7 +6531,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -5914,7 +6541,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -5923,7 +6551,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -5933,7 +6562,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -5965,7 +6595,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5974,7 +6605,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5983,7 +6615,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -5993,7 +6626,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6004,7 +6638,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6013,7 +6648,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6022,7 +6658,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6032,7 +6669,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6043,7 +6681,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6052,7 +6691,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6061,7 +6701,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6071,7 +6712,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6082,7 +6724,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6091,7 +6734,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6100,7 +6744,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6110,7 +6755,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6143,7 +6789,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6152,7 +6799,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6161,7 +6809,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6171,7 +6820,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6182,7 +6832,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6191,7 +6842,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6200,7 +6852,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6210,7 +6863,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6221,7 +6875,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6230,7 +6885,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6239,7 +6895,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6249,7 +6906,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6260,7 +6918,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6269,7 +6928,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6278,7 +6938,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6288,7 +6949,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6326,7 +6988,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6335,7 +6998,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6344,7 +7008,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6354,7 +7019,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6365,7 +7031,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6374,7 +7041,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6383,7 +7051,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6393,7 +7062,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6404,7 +7074,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6413,7 +7084,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6422,7 +7094,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6432,7 +7105,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6443,7 +7117,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6452,7 +7127,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6461,7 +7137,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6471,7 +7148,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6482,7 +7160,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -6491,7 +7170,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -6500,7 +7180,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -6510,7 +7191,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -6521,7 +7203,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -6530,7 +7213,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -6539,7 +7223,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -6549,7 +7234,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_current_pa
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -6588,7 +7274,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6597,7 +7284,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6606,7 +7294,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6616,7 +7305,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6627,7 +7317,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6636,7 +7327,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6645,7 +7337,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6655,7 +7348,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6666,7 +7360,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6675,7 +7370,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6684,7 +7380,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6694,7 +7391,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6705,7 +7403,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6714,7 +7413,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6723,7 +7423,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6733,7 +7434,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6744,7 +7446,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -6753,7 +7456,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -6762,7 +7466,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -6772,7 +7477,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -6783,7 +7489,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -6792,7 +7499,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -6801,7 +7509,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -6811,7 +7520,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_current_p
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -6853,7 +7563,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6862,7 +7573,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6871,7 +7583,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6881,7 +7594,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -6892,7 +7606,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6901,7 +7616,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6910,7 +7626,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6920,7 +7637,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -6931,7 +7649,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6940,7 +7659,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6949,7 +7669,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6959,7 +7680,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -6970,7 +7692,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6979,7 +7702,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6988,7 +7712,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -6998,7 +7723,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -7009,7 +7735,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -7018,7 +7745,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -7027,7 +7755,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -7037,7 +7766,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -7048,7 +7778,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -7057,7 +7788,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -7066,7 +7798,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -7076,7 +7809,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -7087,7 +7821,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -7096,7 +7831,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 7 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -7105,7 +7841,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 7 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -7115,7 +7852,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 7 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -7126,7 +7864,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -7135,7 +7874,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 8 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -7144,7 +7884,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 8 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -7154,7 +7895,8 @@ pub fn resize_left_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abov
         "pane 8 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -7197,7 +7939,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7206,7 +7949,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7215,7 +7959,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7225,7 +7970,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7236,7 +7982,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7245,7 +7992,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7254,7 +8002,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7264,7 +8013,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7275,7 +8025,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7284,7 +8035,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7293,7 +8045,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7303,7 +8056,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7314,7 +8068,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -7323,7 +8078,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -7332,7 +8088,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -7342,7 +8099,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -7353,7 +8111,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -7362,7 +8121,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -7371,7 +8131,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -7381,7 +8142,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -7392,7 +8154,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -7401,7 +8164,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -7410,7 +8174,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -7420,7 +8185,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -7431,7 +8197,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -7440,7 +8207,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 7 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -7449,7 +8217,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 7 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -7459,7 +8228,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 7 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -7470,7 +8240,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -7479,7 +8250,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 8 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -7488,7 +8260,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 8 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -7498,7 +8271,8 @@ pub fn resize_left_with_panes_to_the_right_aligned_top_and_bottom_with_panes_abo
         "pane 8 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -7524,7 +8298,8 @@ pub fn cannot_resize_left_when_pane_to_the_left_is_at_minimum_width() {
     tab.resize_left(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7534,7 +8309,8 @@ pub fn cannot_resize_left_when_pane_to_the_left_is_at_minimum_width() {
         "pane 1 columns stayed the same"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7563,7 +8339,8 @@ pub fn resize_right_with_pane_to_the_left() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7572,7 +8349,8 @@ pub fn resize_right_with_pane_to_the_left() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7581,7 +8359,8 @@ pub fn resize_right_with_pane_to_the_left() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7591,7 +8370,8 @@ pub fn resize_right_with_pane_to_the_left() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7602,7 +8382,8 @@ pub fn resize_right_with_pane_to_the_left() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7611,7 +8392,8 @@ pub fn resize_right_with_pane_to_the_left() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7620,7 +8402,8 @@ pub fn resize_right_with_pane_to_the_left() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7630,7 +8413,8 @@ pub fn resize_right_with_pane_to_the_left() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7660,7 +8444,8 @@ pub fn resize_right_with_pane_to_the_right() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7669,7 +8454,8 @@ pub fn resize_right_with_pane_to_the_right() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7678,7 +8464,8 @@ pub fn resize_right_with_pane_to_the_right() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7688,7 +8475,8 @@ pub fn resize_right_with_pane_to_the_right() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7699,7 +8487,8 @@ pub fn resize_right_with_pane_to_the_right() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7708,7 +8497,8 @@ pub fn resize_right_with_pane_to_the_right() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7717,7 +8507,8 @@ pub fn resize_right_with_pane_to_the_right() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7727,7 +8518,8 @@ pub fn resize_right_with_pane_to_the_right() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7758,7 +8550,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7767,7 +8560,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7776,7 +8570,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7786,7 +8581,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7797,7 +8593,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7806,7 +8603,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7815,7 +8613,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7825,7 +8624,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7836,7 +8636,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7845,7 +8646,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7854,7 +8656,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7864,7 +8667,8 @@ pub fn resize_right_with_panes_to_the_left_and_right() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7896,7 +8700,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7905,7 +8710,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7914,7 +8720,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7924,7 +8731,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -7935,7 +8743,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7944,7 +8753,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7953,7 +8763,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7963,7 +8774,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -7974,7 +8786,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7983,7 +8796,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -7992,7 +8806,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8002,7 +8817,8 @@ pub fn resize_right_with_multiple_panes_to_the_left() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8035,7 +8851,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8044,7 +8861,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8053,7 +8871,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8063,7 +8882,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8074,7 +8894,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8083,7 +8904,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8092,7 +8914,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8102,7 +8925,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8113,7 +8937,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8122,7 +8947,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8131,7 +8957,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8141,7 +8968,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8152,7 +8980,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8161,7 +8990,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8170,7 +9000,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8180,7 +9011,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8213,7 +9045,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8222,7 +9055,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8231,7 +9065,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8241,7 +9076,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8252,7 +9088,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8261,7 +9098,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8270,7 +9108,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8280,7 +9119,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8291,7 +9131,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8300,7 +9141,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8309,7 +9151,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8319,7 +9162,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8330,7 +9174,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8339,7 +9184,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8348,7 +9194,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8358,7 +9205,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8392,7 +9240,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8401,7 +9250,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8410,7 +9260,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8420,7 +9271,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8431,7 +9283,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8440,7 +9293,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8449,7 +9303,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8459,7 +9314,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8470,7 +9326,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8479,7 +9336,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8488,7 +9346,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8498,7 +9357,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8509,7 +9369,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8518,7 +9379,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8527,7 +9389,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8537,7 +9400,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_bottom_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8572,7 +9436,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8581,7 +9446,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8590,7 +9456,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8600,7 +9467,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8611,7 +9479,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8620,7 +9489,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8629,7 +9499,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8639,7 +9510,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8650,7 +9522,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8659,7 +9532,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8668,7 +9542,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8678,7 +9553,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8689,7 +9565,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8698,7 +9575,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8707,7 +9585,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8717,7 +9596,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_bottom_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8755,7 +9635,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8764,7 +9645,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8773,7 +9655,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8783,7 +9666,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -8794,7 +9678,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8803,7 +9688,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8812,7 +9698,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8822,7 +9709,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -8833,7 +9721,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8842,7 +9731,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8851,7 +9741,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8861,7 +9752,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -8872,7 +9764,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8881,7 +9774,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8890,7 +9784,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8900,7 +9795,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -8911,7 +9807,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -8920,7 +9817,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -8929,7 +9827,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -8939,7 +9838,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -8950,7 +9850,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -8959,7 +9860,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -8968,7 +9870,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -8978,7 +9881,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_current_p
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9016,7 +9920,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9025,7 +9930,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9034,7 +9940,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9044,7 +9951,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9055,7 +9963,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9064,7 +9973,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9073,7 +9983,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9083,7 +9994,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9094,7 +10006,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9103,7 +10016,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9112,7 +10026,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9122,7 +10037,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9133,7 +10049,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9142,7 +10059,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9151,7 +10069,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9161,7 +10080,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9172,7 +10092,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9181,7 +10102,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9190,7 +10112,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9200,7 +10123,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9211,7 +10135,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9220,7 +10145,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9229,7 +10155,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9239,7 +10166,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_current_
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9280,7 +10208,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9289,7 +10218,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9298,7 +10228,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9308,7 +10239,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9319,7 +10251,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9328,7 +10261,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9337,7 +10271,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9347,7 +10282,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9358,7 +10294,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9367,7 +10304,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9376,7 +10314,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9386,7 +10325,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9397,7 +10337,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9406,7 +10347,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9415,7 +10357,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9425,7 +10368,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9436,7 +10380,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9445,7 +10390,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9454,7 +10400,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9464,7 +10411,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9475,7 +10423,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9484,7 +10433,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9493,7 +10443,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9503,7 +10454,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9514,7 +10466,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -9523,7 +10476,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 7 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -9532,7 +10486,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 7 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -9542,7 +10497,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 7 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -9553,7 +10509,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -9562,7 +10519,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 8 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -9571,7 +10529,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 8 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -9581,7 +10540,8 @@ pub fn resize_right_with_panes_to_the_left_aligned_top_and_bottom_with_panes_abo
         "pane 8 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -9623,7 +10583,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9632,7 +10593,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9641,7 +10603,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9651,7 +10614,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9662,7 +10626,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9671,7 +10636,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9680,7 +10646,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9690,7 +10657,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9701,7 +10669,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9710,7 +10679,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9719,7 +10689,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9729,7 +10700,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -9740,7 +10712,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9749,7 +10722,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9758,7 +10732,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9768,7 +10743,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -9779,7 +10755,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9788,7 +10765,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9797,7 +10775,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9807,7 +10786,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -9818,7 +10798,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9827,7 +10808,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9836,7 +10818,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9846,7 +10829,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -9857,7 +10841,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -9866,7 +10851,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 7 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -9875,7 +10861,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 7 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -9885,7 +10872,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 7 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -9896,7 +10884,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -9905,7 +10894,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 8 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -9914,7 +10904,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 8 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -9924,7 +10915,8 @@ pub fn resize_right_with_panes_to_the_right_aligned_top_and_bottom_with_panes_ab
         "pane 8 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -9949,7 +10941,8 @@ pub fn cannot_resize_right_when_pane_to_the_left_is_at_minimum_width() {
     tab.resize_right(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9959,7 +10952,8 @@ pub fn cannot_resize_right_when_pane_to_the_left_is_at_minimum_width() {
         "pane 1 columns stayed the same"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -9989,7 +10983,8 @@ pub fn resize_up_with_pane_above() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -9998,7 +10993,8 @@ pub fn resize_up_with_pane_above() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10007,7 +11003,8 @@ pub fn resize_up_with_pane_above() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10017,7 +11014,8 @@ pub fn resize_up_with_pane_above() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10028,7 +11026,8 @@ pub fn resize_up_with_pane_above() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10037,7 +11036,8 @@ pub fn resize_up_with_pane_above() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10046,7 +11046,8 @@ pub fn resize_up_with_pane_above() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10056,7 +11057,8 @@ pub fn resize_up_with_pane_above() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10087,7 +11089,8 @@ pub fn resize_up_with_pane_below() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10096,7 +11099,8 @@ pub fn resize_up_with_pane_below() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10105,7 +11109,8 @@ pub fn resize_up_with_pane_below() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10115,7 +11120,8 @@ pub fn resize_up_with_pane_below() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10126,7 +11132,8 @@ pub fn resize_up_with_pane_below() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10135,7 +11142,8 @@ pub fn resize_up_with_pane_below() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10144,7 +11152,8 @@ pub fn resize_up_with_pane_below() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10154,7 +11163,8 @@ pub fn resize_up_with_pane_below() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10189,7 +11199,8 @@ pub fn resize_up_with_panes_above_and_below() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10198,7 +11209,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10207,7 +11219,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10217,7 +11230,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10228,7 +11242,8 @@ pub fn resize_up_with_panes_above_and_below() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10237,7 +11252,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10246,7 +11262,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10256,7 +11273,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10267,7 +11285,8 @@ pub fn resize_up_with_panes_above_and_below() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10276,7 +11295,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10285,7 +11305,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10295,7 +11316,8 @@ pub fn resize_up_with_panes_above_and_below() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10327,7 +11349,8 @@ pub fn resize_up_with_multiple_panes_above() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10336,7 +11359,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10345,7 +11369,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10355,7 +11380,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10366,7 +11392,8 @@ pub fn resize_up_with_multiple_panes_above() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10375,7 +11402,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10384,7 +11412,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10394,7 +11423,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10405,7 +11435,8 @@ pub fn resize_up_with_multiple_panes_above() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10414,7 +11445,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10423,7 +11455,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10433,7 +11466,8 @@ pub fn resize_up_with_multiple_panes_above() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10465,7 +11499,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10474,7 +11509,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10483,7 +11519,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10493,7 +11530,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10504,7 +11542,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10513,7 +11552,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10522,7 +11562,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10532,7 +11573,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10543,7 +11585,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10552,7 +11595,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10561,7 +11605,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10571,7 +11616,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10582,7 +11628,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10591,7 +11638,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10600,7 +11648,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10610,7 +11659,8 @@ pub fn resize_up_with_panes_above_aligned_left_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10645,7 +11695,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10654,7 +11705,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10663,7 +11715,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10673,7 +11726,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10684,7 +11738,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10693,7 +11748,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10702,7 +11758,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10712,7 +11769,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10723,7 +11781,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10732,7 +11791,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10741,7 +11801,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10751,7 +11812,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10762,7 +11824,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10771,7 +11834,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10780,7 +11844,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10790,7 +11855,8 @@ pub fn resize_up_with_panes_below_aligned_left_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10825,7 +11891,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10834,7 +11901,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10843,7 +11911,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10853,7 +11922,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -10864,7 +11934,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10873,7 +11944,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10882,7 +11954,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10892,7 +11965,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -10903,7 +11977,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10912,7 +11987,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10921,7 +11997,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10931,7 +12008,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -10942,7 +12020,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10951,7 +12030,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10960,7 +12040,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -10970,7 +12051,8 @@ pub fn resize_up_with_panes_above_aligned_right_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11006,7 +12088,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11015,7 +12098,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11024,7 +12108,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11034,7 +12119,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11045,7 +12131,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11054,7 +12141,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11063,7 +12151,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11073,7 +12162,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11084,7 +12174,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11093,7 +12184,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11102,7 +12194,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11112,7 +12205,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11123,7 +12217,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11132,7 +12227,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11141,7 +12237,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11151,7 +12248,8 @@ pub fn resize_up_with_panes_below_aligned_right_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11187,7 +12285,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11196,7 +12295,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11205,7 +12305,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11215,7 +12316,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11226,7 +12328,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11235,7 +12338,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11244,7 +12348,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11254,7 +12359,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11265,7 +12371,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11274,7 +12381,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11283,7 +12391,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11293,7 +12402,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11304,7 +12414,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11313,7 +12424,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11322,7 +12434,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11332,7 +12445,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11343,7 +12457,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11352,7 +12467,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11361,7 +12477,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11371,7 +12488,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11382,7 +12500,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11391,7 +12510,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11400,7 +12520,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11410,7 +12531,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_current_pane() {
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11447,7 +12569,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11456,7 +12579,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11465,7 +12589,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11475,7 +12600,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11486,7 +12612,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11495,7 +12622,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11504,7 +12632,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11514,7 +12643,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11525,7 +12655,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11534,7 +12665,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11543,7 +12675,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11553,7 +12686,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11564,7 +12698,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11573,7 +12708,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11582,7 +12718,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11592,7 +12729,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11603,7 +12741,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11612,7 +12751,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11621,7 +12761,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11631,7 +12772,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11642,7 +12784,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11651,7 +12794,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11660,7 +12804,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11670,7 +12815,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_current_pane() {
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11710,7 +12856,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11719,7 +12866,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11728,7 +12876,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11738,7 +12887,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -11749,7 +12899,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11758,7 +12909,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11767,7 +12919,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11777,7 +12930,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -11788,7 +12942,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11797,7 +12952,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11806,7 +12962,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11816,7 +12973,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -11827,7 +12985,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11836,7 +12995,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11845,7 +13005,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11855,7 +13016,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -11866,7 +13028,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11875,7 +13038,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11884,7 +13048,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11894,7 +13059,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -11905,7 +13071,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11914,7 +13081,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11923,7 +13091,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11933,7 +13102,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -11944,7 +13114,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -11953,7 +13124,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 7 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -11962,7 +13134,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 7 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -11972,7 +13145,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 7 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -11983,7 +13157,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -11992,7 +13167,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 8 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -12001,7 +13177,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 8 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -12011,7 +13188,8 @@ pub fn resize_up_with_panes_above_aligned_left_and_right_with_panes_to_the_left_
         "pane 8 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -12052,7 +13230,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
     tab.resize_up(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -12061,7 +13240,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 1 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -12070,7 +13250,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 1 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -12080,7 +13261,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 1 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -12091,7 +13273,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12100,7 +13283,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12109,7 +13293,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12119,7 +13304,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12130,7 +13316,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -12139,7 +13326,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 3 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -12148,7 +13336,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 3 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -12158,7 +13347,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 3 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -12169,7 +13359,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -12178,7 +13369,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 4 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -12187,7 +13379,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 4 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -12197,7 +13390,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 4 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(4))
             .unwrap()
             .position_and_size()
@@ -12208,7 +13402,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -12217,7 +13412,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 5 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -12226,7 +13422,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 5 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -12236,7 +13433,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 5 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(5))
             .unwrap()
             .position_and_size()
@@ -12247,7 +13445,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -12256,7 +13455,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 6 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -12265,7 +13465,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 6 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -12275,7 +13476,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 6 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(6))
             .unwrap()
             .position_and_size()
@@ -12286,7 +13488,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -12295,7 +13498,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 7 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -12304,7 +13508,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 7 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -12314,7 +13519,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 7 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(7))
             .unwrap()
             .position_and_size()
@@ -12325,7 +13531,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
     );
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -12334,7 +13541,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 8 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -12343,7 +13551,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 8 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -12353,7 +13562,8 @@ pub fn resize_up_with_panes_below_aligned_left_and_right_with_to_the_left_and_ri
         "pane 8 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(8))
             .unwrap()
             .position_and_size()
@@ -12382,7 +13592,8 @@ pub fn cannot_resize_up_when_pane_above_is_at_minimum_height() {
     tab.resize_down(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(1))
             .unwrap()
             .position_and_size()
@@ -12392,7 +13603,8 @@ pub fn cannot_resize_up_when_pane_above_is_at_minimum_height() {
         "pane 1 height stayed the same"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12438,7 +13650,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_left() {
 
     // should behave like `resize_left_with_pane_to_the_left`
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12447,7 +13660,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_left() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12472,7 +13686,8 @@ pub fn nondirectional_resize_increase_with_2_panes_to_left() {
 
     // should behave like `resize_left_with_multiple_panes_to_the_left`
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12481,7 +13696,8 @@ pub fn nondirectional_resize_increase_with_2_panes_to_left() {
         "pane 2 x position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12490,7 +13706,8 @@ pub fn nondirectional_resize_increase_with_2_panes_to_left() {
         "pane 2 y position"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12500,7 +13717,8 @@ pub fn nondirectional_resize_increase_with_2_panes_to_left() {
         "pane 2 column count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12524,7 +13742,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_above() {
     tab.resize_increase(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -12533,7 +13752,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_above() {
         "Pane 3 y coordinate"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -12542,7 +13762,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_above() {
         "Pane 3 x coordinate"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -12552,7 +13773,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_above() {
         "Pane 3 row count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(3))
             .unwrap()
             .position_and_size()
@@ -12576,7 +13798,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_to_left() {
     tab.resize_increase(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12585,7 +13808,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_to_left() {
         "Pane 3 y coordinate"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12594,7 +13818,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_to_left() {
         "Pane 3 x coordinate"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12604,7 +13829,8 @@ pub fn nondirectional_resize_increase_with_1_pane_to_right_1_pane_to_left() {
         "Pane 3 row count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12628,7 +13854,8 @@ pub fn nondirectional_resize_increase_with_pane_above_aligned_right_with_current
     tab.resize_increase(1);
 
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12637,7 +13864,8 @@ pub fn nondirectional_resize_increase_with_pane_above_aligned_right_with_current
         "Pane 3 y coordinate"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12646,7 +13874,8 @@ pub fn nondirectional_resize_increase_with_pane_above_aligned_right_with_current
         "Pane 3 x coordinate"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
@@ -12656,7 +13885,8 @@ pub fn nondirectional_resize_increase_with_pane_above_aligned_right_with_current
         "Pane 3 row count"
     );
     assert_eq!(
-        tab.panes
+        tab.tiled_panes
+            .panes
             .get(&PaneId::Terminal(2))
             .unwrap()
             .position_and_size()
diff --git a/zellij-server/src/unit/screen_tests.rs b/zellij-server/src/unit/screen_tests.rs
index dd88d5eb..cf9b89b5 100644
--- a/zellij-server/src/unit/screen_tests.rs
+++ b/zellij-server/src/unit/screen_tests.rs
@@ -458,10 +458,9 @@ fn switch_to_tab_with_fullscreen() {
         screen
             .get_active_tab(1)
             .unwrap()
-            .active_panes
-            .get(&1)
+            .get_active_pane_id(1)
             .unwrap(),
-        &PaneId::Terminal(2),
+        PaneId::Terminal(2),
         "Active pane is still the fullscreen pane"
     );
 }