diff --git a/crates/dock/src/dock.rs b/crates/dock/src/dock.rs
index 87ca560..1813149 100644
--- a/crates/dock/src/dock.rs
+++ b/crates/dock/src/dock.rs
@@ -24,6 +24,12 @@ impl Render for ResizePanel {
     }
 }
 
+/// Where to place a panel.
+///
+/// The [`DockArea`] has a fixed left dock and a center area. `Left` targets
+/// the left dock; `Center` adds a tab to the center; `Right` and `Bottom`
+/// split the center so the new panel lands on the given side of the existing
+/// center content.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
 pub enum DockPlacement {
     #[serde(rename = "center")]
@@ -37,7 +43,8 @@ pub enum DockPlacement {
 }
 
 impl DockPlacement {
-    fn axis(&self) -> Axis {
+    /// The split axis used when the placement splits the center area.
+    pub(crate) fn axis(&self) -> Axis {
         match self {
             Self::Left | Self::Right => Axis::Horizontal,
             Self::Bottom => Axis::Vertical,
@@ -48,24 +55,16 @@ impl DockPlacement {
     pub fn is_left(&self) -> bool {
         matches!(self, Self::Left)
     }
-
-    pub fn is_bottom(&self) -> bool {
-        matches!(self, Self::Bottom)
-    }
-
-    pub fn is_right(&self) -> bool {
-        matches!(self, Self::Right)
-    }
 }
 
-/// The Dock is a fixed container that places at left, bottom, right of the Windows.
+/// The Dock is a fixed container that places at the left side of the window.
 ///
 /// This is unlike Panel, it can't be move or add any other panel.
 pub struct Dock {
     pub(super) placement: DockPlacement,
     dock_area: WeakEntity<DockArea>,
     pub(crate) panel: DockItem,
-    /// The size is means the width or height of the Dock, if the placement is left or right, the size is width, otherwise the size is height.
+    /// The width of the dock.
     pub(super) size: Pixels,
     pub(super) open: bool,
     /// Whether the Dock is collapsible, default: true
@@ -117,22 +116,6 @@ impl Dock {
         Self::new(dock_area, DockPlacement::Left, window, cx)
     }
 
-    pub fn bottom(
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        Self::new(dock_area, DockPlacement::Bottom, window, cx)
-    }
-
-    pub fn right(
-        dock_area: WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        Self::new(dock_area, DockPlacement::Right, window, cx)
-    }
-
     /// Update the Dock to be collapsible or not.
     ///
     /// And if the Dock is not collapsible, it will be open.
@@ -212,16 +195,6 @@ impl Dock {
                     }
                 });
             }
-            DockItem::Tiles { view, .. } => {
-                window.defer(cx, {
-                    let view = view.clone();
-                    move |window, cx| {
-                        _ = dock_area.update(cx, |this, cx| {
-                            this.subscribe_panel(&view, window, cx);
-                        });
-                    }
-                });
-            }
             DockItem::Panel { .. } => {
                 // Not supported
             }
@@ -275,8 +248,7 @@ impl Dock {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        self.panel
-            .add_panel(panel, &self.dock_area, None, window, cx);
+        self.panel.add_panel(panel, &self.dock_area, window, cx);
         cx.notify();
     }
 
@@ -328,52 +300,10 @@ impl Dock {
             .expect("DockArea is missing")
             .read(cx);
         let area_bounds = dock_area.bounds;
-        let mut left_dock_size = px(0.0);
-        let mut right_dock_size = px(0.0);
 
-        // Get the size of the left dock if it's open and not the current dock
-        if let Some(left_dock) = &dock_area.left_dock
-            && left_dock.entity_id() != cx.entity().entity_id()
-        {
-            let left_dock_read = left_dock.read(cx);
-            if left_dock_read.is_open() {
-                left_dock_size = left_dock_read.size;
-            }
-        }
-
-        // Get the size of the right dock if it's open and not the current dock
-        if let Some(right_dock) = &dock_area.right_dock
-            && right_dock.entity_id() != cx.entity().entity_id()
-        {
-            let right_dock_read = right_dock.read(cx);
-            if right_dock_read.is_open() {
-                right_dock_size = right_dock_read.size;
-            }
-        }
-
-        let size = match self.placement {
-            DockPlacement::Left => mouse_position.x - area_bounds.left(),
-            DockPlacement::Right => area_bounds.right() - mouse_position.x,
-            DockPlacement::Bottom => area_bounds.bottom() - mouse_position.y,
-            DockPlacement::Center => unreachable!(),
-        };
-        match self.placement {
-            DockPlacement::Left => {
-                let max_size =
-                    (area_bounds.size.width - PANEL_MIN_SIZE - right_dock_size).max(PANEL_MIN_SIZE);
-                self.size = size.clamp(PANEL_MIN_SIZE, max_size);
-            }
-            DockPlacement::Right => {
-                let max_size =
-                    (area_bounds.size.width - PANEL_MIN_SIZE - left_dock_size).max(PANEL_MIN_SIZE);
-                self.size = size.clamp(PANEL_MIN_SIZE, max_size);
-            }
-            DockPlacement::Bottom => {
-                let max_size = (area_bounds.size.height - PANEL_MIN_SIZE).max(PANEL_MIN_SIZE);
-                self.size = size.clamp(PANEL_MIN_SIZE, max_size);
-            }
-            DockPlacement::Center => unreachable!(),
-        }
+        let size = mouse_position.x - area_bounds.left();
+        let max_size = (area_bounds.size.width - PANEL_MIN_SIZE).max(PANEL_MIN_SIZE);
+        self.size = size.clamp(PANEL_MIN_SIZE, max_size);
 
         cx.notify();
     }
@@ -394,7 +324,7 @@ impl Dock {
 
 impl Render for Dock {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl gpui::IntoElement {
-        if !self.open && !self.placement.is_bottom() {
+        if !self.open {
             return div();
         }
 
@@ -403,21 +333,13 @@ impl Render for Dock {
         div()
             .relative()
             .overflow_hidden()
-            .map(|this| match self.placement {
-                DockPlacement::Left | DockPlacement::Right => this.h_flex().h_full().w(self.size),
-                DockPlacement::Bottom => this.w_full().h(self.size),
-                DockPlacement::Center => unreachable!(),
-            })
-            // Bottom Dock should keep the title bar, then user can click the Toggle button
-            .when(!self.open && self.placement.is_bottom(), |this| {
-                this.h(px(29.))
-            })
+            .h_flex()
+            .h_full()
+            .w(self.size)
             .map(|this| match &self.panel {
                 DockItem::Split { view, .. } => this.child(view.clone()),
                 DockItem::Tabs { view, .. } => this.child(view.clone()),
                 DockItem::Panel { view, .. } => this.child(view.clone().view().cached(cache_style)),
-                // Not support to render Tiles and Tile into Dock
-                DockItem::Tiles { .. } => this,
             })
             .child(self.render_resize_handle(window, cx))
             .child(DockElement {
diff --git a/crates/dock/src/fixtures/layout.json b/crates/dock/src/fixtures/layout.json
index 13b7a76..d1ceb41 100644
--- a/crates/dock/src/fixtures/layout.json
+++ b/crates/dock/src/fixtures/layout.json
@@ -169,7 +169,10 @@
     ],
     "info": {
       "stack": {
-        "sizes": [704.0, 263.0],
+        "sizes": [
+          704.0,
+          263.0
+        ],
         "axis": 1
       }
     }
@@ -198,64 +201,5 @@
     "size": 350.0,
     "open": true,
     "resizeable": true
-  },
-  "right_dock": {
-    "panel": {
-      "panel_name": "TabPanel",
-      "children": [
-        {
-          "panel_name": "StoryContainer",
-          "children": [],
-          "info": {
-            "panel": {
-              "story_klass": "ImageStory"
-            }
-          }
-        }
-      ],
-      "info": {
-        "tabs": {
-          "active_index": 0
-        }
-      }
-    },
-    "placement": "right",
-    "size": 320.0,
-    "open": true,
-    "resizeable": true
-  },
-  "bottom_dock": {
-    "panel": {
-      "panel_name": "TabPanel",
-      "children": [
-        {
-          "panel_name": "StoryContainer",
-          "children": [],
-          "info": {
-            "panel": {
-              "story_klass": "TextStory"
-            }
-          }
-        },
-        {
-          "panel_name": "StoryContainer",
-          "children": [],
-          "info": {
-            "panel": {
-              "story_klass": "IconStory"
-            }
-          }
-        }
-      ],
-      "info": {
-        "tabs": {
-          "active_index": 0
-        }
-      }
-    },
-    "placement": "bottom",
-    "size": 200.0,
-    "open": true,
-    "resizeable": true
   }
-}
+}
\ No newline at end of file
diff --git a/crates/dock/src/lib.rs b/crates/dock/src/lib.rs
index a902e39..1d5a461 100644
--- a/crates/dock/src/lib.rs
+++ b/crates/dock/src/lib.rs
@@ -5,7 +5,6 @@ mod resize_handle;
 mod stack_panel;
 mod state;
 mod tab_panel;
-mod tiles;
 mod window_controls;
 
 use std::sync::Arc;
@@ -23,7 +22,6 @@ pub use panel::*;
 pub use stack_panel::*;
 pub use state::*;
 pub use tab_panel::*;
-pub use tiles::*;
 
 /// Initialize the dock, registering the [`PanelRegistry`] global.
 ///
@@ -54,6 +52,20 @@ pub(crate) fn t(key: &'static str) -> &'static str {
     }
 }
 
+/// A host-owned drag item, dragged into the dock by the application.
+#[derive(Clone, Debug)]
+pub struct AnyDrag {
+    pub value: Arc<dyn std::any::Any + Send + Sync>,
+}
+
+impl AnyDrag {
+    pub fn new<T: 'static + Send + Sync>(value: T) -> Self {
+        Self {
+            value: Arc::new(value),
+        }
+    }
+}
+
 pub enum DockEvent {
     /// The layout of the dock has changed, subscribers this to save the layout.
     ///
@@ -68,10 +80,6 @@ pub enum DockEvent {
 /// Where a host-owned drag landed, and how much the container can say about it.
 #[derive(Clone, Debug)]
 pub enum DropTarget {
-    /// Dropped on a [`Tiles`] canvas, where the landing position is just the
-    /// cursor position and the host can read it directly.
-    Canvas,
-
     /// Dropped on a [`TabPanel`] in a split layout. A split layout has no free
     /// coordinates, so the container reports the panel and the edge it resolved
     /// from the cursor instead.
@@ -95,10 +103,6 @@ pub struct DockArea {
     center: DockItem,
     /// The left dock of the dock_area.
     left_dock: Option<Entity<Dock>>,
-    /// The bottom dock of the dock_area.
-    bottom_dock: Option<Entity<Dock>>,
-    /// The right dock of the dock_area.
-    right_dock: Option<Entity<Dock>>,
 
     /// The entity_id of the [`TabPanel`](TabPanel) where each toggle button should be displayed,
     toggle_button_panels: Edges<Option<EntityId>>,
@@ -144,13 +148,6 @@ pub enum DockItem {
         size: Option<Pixels>,
         view: Arc<dyn PanelView>,
     },
-    /// Tiles layout
-    Tiles {
-        /// Self size, only used for build split panels
-        size: Option<Pixels>,
-        items: Vec<TileItem>,
-        view: Entity<Tiles>,
-    },
 }
 
 impl std::fmt::Debug for DockItem {
@@ -172,7 +169,6 @@ impl std::fmt::Debug for DockItem {
                 .field("active_ix", active_ix)
                 .finish(),
             DockItem::Panel { .. } => f.debug_struct("Panel").finish(),
-            DockItem::Tiles { .. } => f.debug_struct("Tiles").finish(),
         }
     }
 }
@@ -184,7 +180,6 @@ impl DockItem {
             Self::Split { size, .. } => *size,
             Self::Tabs { size, .. } => *size,
             Self::Panel { size, .. } => *size,
-            Self::Tiles { size, .. } => *size,
         }
     }
 
@@ -194,7 +189,6 @@ impl DockItem {
         match self {
             Self::Split { ref mut size, .. } => *size = new_size,
             Self::Tabs { ref mut size, .. } => *size = new_size,
-            Self::Tiles { ref mut size, .. } => *size = new_size,
             Self::Panel { ref mut size, .. } => *size = new_size,
         }
         self
@@ -303,60 +297,6 @@ impl DockItem {
         }
     }
 
-    /// Create DockItem with tiles layout
-    ///
-    /// This items and metas should have the same length.
-    pub fn tiles(
-        items: Vec<DockItem>,
-        metas: Vec<impl Into<TileMeta> + Copy>,
-        dock_area: &WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut App,
-    ) -> Self {
-        assert!(items.len() == metas.len());
-
-        let tile_panel = cx.new(|cx| {
-            let mut tiles = Tiles::new(window, cx);
-            for (ix, item) in items.clone().into_iter().enumerate() {
-                match item {
-                    DockItem::Tabs { view, .. } => {
-                        let meta: TileMeta = metas[ix].into();
-                        let tile_item =
-                            TileItem::new(Arc::new(view), meta.bounds).z_index(meta.z_index);
-                        tiles.add_item(tile_item, dock_area, window, cx);
-                    }
-                    DockItem::Panel { view, .. } => {
-                        let meta: TileMeta = metas[ix].into();
-                        let tile_item =
-                            TileItem::new(view.clone(), meta.bounds).z_index(meta.z_index);
-                        tiles.add_item(tile_item, dock_area, window, cx);
-                    }
-                    _ => {
-                        // Ignore non-tabs items
-                    }
-                }
-            }
-            tiles
-        });
-
-        window.defer(cx, {
-            let tile_panel = tile_panel.clone();
-            let dock_area = dock_area.clone();
-            move |window, cx| {
-                _ = dock_area.update(cx, |this, cx| {
-                    this.subscribe_panel(&tile_panel, window, cx);
-                    this.subscribe_tiles_item_drop(&tile_panel, window, cx);
-                });
-            }
-        });
-
-        Self::Tiles {
-            size: None,
-            items: tile_panel.read(cx).panels.clone(),
-            view: tile_panel,
-        }
-    }
-
     /// Create DockItem with tabs layout, items are displayed as tabs.
     ///
     /// The `active_ix` is the index of the active tab, if `None` the first tab is active.
@@ -412,7 +352,6 @@ impl DockItem {
         match self {
             Self::Split { view, .. } => Arc::new(view.clone()),
             Self::Tabs { view, .. } => Arc::new(view.clone()),
-            Self::Tiles { view, .. } => Arc::new(view.clone()),
             Self::Panel { view, .. } => view.clone(),
         }
     }
@@ -440,13 +379,6 @@ impl DockItem {
             if let Ok(tabs) = view.clone().downcast::<TabPanel>() {
                 return tabs.read(cx).panels.iter().all(|panel| is_empty(panel, cx));
             }
-            if let Ok(tiles) = view.downcast::<Tiles>() {
-                return tiles
-                    .read(cx)
-                    .panels()
-                    .iter()
-                    .all(|item| is_empty(&item.panel, cx));
-            }
 
             !panel.visible(cx)
         }
@@ -462,15 +394,6 @@ impl DockItem {
             }
             Self::Tabs { items, .. } => items.iter().find(|item| *item == &panel).cloned(),
             Self::Panel { view, .. } => Some(view.clone()),
-            Self::Tiles { items, .. } => items.iter().find_map(|item| {
-                // `==` on `Arc<dyn PanelView>` moves the captured `panel`
-                // inside the closure; `eq` borrows both sides.
-                if item.panel.eq(&panel) {
-                    Some(item.panel.clone())
-                } else {
-                    None
-                }
-            }),
         }
     }
 
@@ -479,7 +402,6 @@ impl DockItem {
         &mut self,
         panel: Arc<dyn PanelView>,
         dock_area: &WeakEntity<DockArea>,
-        bounds: Option<Bounds<Pixels>>,
         window: &mut Window,
         cx: &mut App,
     ) {
@@ -508,21 +430,6 @@ impl DockItem {
                     stack_panel.add_panel(new_item.view(), None, dock_area.clone(), window, cx);
                 });
             }
-            Self::Tiles { view, items, .. } => {
-                let tile_item = TileItem::new(
-                    Arc::new(cx.new(|cx| {
-                        let mut tab_panel = TabPanel::new(None, dock_area.clone(), window, cx);
-                        tab_panel.add_panel(panel.clone(), window, cx);
-                        tab_panel
-                    })),
-                    bounds.unwrap_or_else(|| TileMeta::default().bounds),
-                );
-
-                items.push(tile_item.clone());
-                view.update(cx, |tiles, cx| {
-                    tiles.add_item(tile_item, dock_area, window, cx);
-                });
-            }
             Self::Panel { .. } => {}
         }
     }
@@ -544,11 +451,6 @@ impl DockItem {
                     split.remove_panel(panel, window, cx);
                 });
             }
-            DockItem::Tiles { view, .. } => {
-                view.update(cx, |tiles, cx| {
-                    tiles.remove(panel, window, cx);
-                });
-            }
             DockItem::Panel { .. } => {}
         }
     }
@@ -566,7 +468,6 @@ impl DockItem {
                     item.set_collapsed(collapsed, window, cx);
                 }
             }
-            DockItem::Tiles { .. } => {}
             DockItem::Panel { view, .. } => view.set_active(!collapsed, window, cx),
         }
     }
@@ -576,17 +477,6 @@ impl DockItem {
         match self {
             DockItem::Tabs { view, .. } => Some(view.clone()),
             DockItem::Split { view, .. } => view.read(cx).left_top_tab_panel(true, cx),
-            DockItem::Tiles { .. } => None,
-            DockItem::Panel { .. } => None,
-        }
-    }
-
-    /// Recursively traverses to find the right-most and top-most TabPanel.
-    pub(crate) fn right_top_tab_panel(&self, cx: &App) -> Option<Entity<TabPanel>> {
-        match self {
-            DockItem::Tabs { view, .. } => Some(view.clone()),
-            DockItem::Split { view, .. } => view.read(cx).right_top_tab_panel(true, cx),
-            DockItem::Tiles { .. } => None,
             DockItem::Panel { .. } => None,
         }
     }
@@ -615,8 +505,6 @@ impl DockArea {
             bounds: Bounds::default(),
             center: dock_item,
             left_dock: None,
-            right_dock: None,
-            bottom_dock: None,
             zoom_view: None,
             toggle_button_panels: Edges::default(),
             toggle_button_visible: true,
@@ -635,22 +523,6 @@ impl DockArea {
         self.bounds
     }
 
-    /// Subscribe to the tiles item drag item drop event
-    fn subscribe_tiles_item_drop(
-        &mut self,
-        tile_panel: &Entity<Tiles>,
-        _: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self._subscriptions
-            .push(cx.subscribe(tile_panel, move |_, _, evt: &DragDrop, cx| {
-                cx.emit(DockEvent::DragDrop {
-                    item: evt.0.clone(),
-                    target: DropTarget::Canvas,
-                });
-            }));
-    }
-
     /// Set the panel style of the dock area.
     pub fn panel_style(mut self, style: PanelStyle) -> Self {
         self.panel_style = style;
@@ -681,31 +553,11 @@ impl DockArea {
         self.left_dock.as_ref()
     }
 
-    /// Return the bottom dock item.
-    pub fn bottom_dock(&self) -> Option<&Entity<Dock>> {
-        self.bottom_dock.as_ref()
-    }
-
-    /// Return the right dock item.
-    pub fn right_dock(&self) -> Option<&Entity<Dock>> {
-        self.right_dock.as_ref()
-    }
-
     /// Remove the left dock.
     pub fn remove_left_dock(&mut self, _: &mut Window, _: &mut Context<Self>) {
         self.left_dock = None;
     }
 
-    /// Remove the bottom dock.
-    pub fn remove_bottom_dock(&mut self, _: &mut Window, _: &mut Context<Self>) {
-        self.bottom_dock = None;
-    }
-
-    /// Remove the right dock.
-    pub fn remove_right_dock(&mut self, _: &mut Window, _: &mut Context<Self>) {
-        self.right_dock = None;
-    }
-
     /// The the DockItem as the center of the dock area.
     ///
     /// This is used to render at the Center of the DockArea.
@@ -738,50 +590,6 @@ impl DockArea {
         self.update_toggle_button_tab_panels(window, cx);
     }
 
-    pub fn set_bottom_dock(
-        &mut self,
-        panel: DockItem,
-        size: Option<Pixels>,
-        open: bool,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.subscribe_item(&panel, window, cx);
-        let weak_self = cx.entity().downgrade();
-        self.bottom_dock = Some(cx.new(|cx| {
-            let mut dock = Dock::bottom(weak_self.clone(), window, cx);
-            if let Some(size) = size {
-                dock.set_size(size, window, cx);
-            }
-            dock.set_panel(panel, window, cx);
-            dock.set_open(open, window, cx);
-            dock
-        }));
-        self.update_toggle_button_tab_panels(window, cx);
-    }
-
-    pub fn set_right_dock(
-        &mut self,
-        panel: DockItem,
-        size: Option<Pixels>,
-        open: bool,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        self.subscribe_item(&panel, window, cx);
-        let weak_self = cx.entity().downgrade();
-        self.right_dock = Some(cx.new(|cx| {
-            let mut dock = Dock::right(weak_self.clone(), window, cx);
-            if let Some(size) = size {
-                dock.set_size(size, window, cx);
-            }
-            dock.set_panel(panel, window, cx);
-            dock.set_open(open, window, cx);
-            dock
-        }));
-        self.update_toggle_button_tab_panels(window, cx);
-    }
-
     /// Set locked state of the dock area, if locked, the dock area cannot be split or move, but allows to resize panels.
     pub fn set_locked(&mut self, locked: bool, _window: &mut Window, _cx: &mut App) {
         self.locked = locked;
@@ -797,9 +605,7 @@ impl DockArea {
     pub fn has_dock(&self, placement: DockPlacement) -> bool {
         match placement {
             DockPlacement::Left => self.left_dock.is_some(),
-            DockPlacement::Bottom => self.bottom_dock.is_some(),
-            DockPlacement::Right => self.right_dock.is_some(),
-            DockPlacement::Center => false,
+            DockPlacement::Center | DockPlacement::Right | DockPlacement::Bottom => false,
         }
     }
 
@@ -811,23 +617,13 @@ impl DockArea {
                 .as_ref()
                 .map(|dock| dock.read(cx).is_open())
                 .unwrap_or(false),
-            DockPlacement::Bottom => self
-                .bottom_dock
-                .as_ref()
-                .map(|dock| dock.read(cx).is_open())
-                .unwrap_or(false),
-            DockPlacement::Right => self
-                .right_dock
-                .as_ref()
-                .map(|dock| dock.read(cx).is_open())
-                .unwrap_or(false),
-            DockPlacement::Center => false,
+            DockPlacement::Center | DockPlacement::Right | DockPlacement::Bottom => false,
         }
     }
 
     /// Set the dock at the given placement to be open or closed.
     ///
-    /// Only the left, bottom, right dock can be toggled.
+    /// Only the left dock can be toggled.
     pub fn set_dock_collapsible(
         &mut self,
         collapsible_edges: Edges<bool>,
@@ -839,18 +635,6 @@ impl DockArea {
                 dock.set_collapsible(collapsible_edges.left, window, cx);
             });
         }
-
-        if let Some(bottom_dock) = self.bottom_dock.as_ref() {
-            bottom_dock.update(cx, |dock, cx| {
-                dock.set_collapsible(collapsible_edges.bottom, window, cx);
-            });
-        }
-
-        if let Some(right_dock) = self.right_dock.as_ref() {
-            right_dock.update(cx, |dock, cx| {
-                dock.set_collapsible(collapsible_edges.right, window, cx);
-            });
-        }
     }
 
     /// Determine if the dock at the given placement is collapsible.
@@ -861,17 +645,7 @@ impl DockArea {
                 .as_ref()
                 .map(|dock| dock.read(cx).collapsible)
                 .unwrap_or(false),
-            DockPlacement::Bottom => self
-                .bottom_dock
-                .as_ref()
-                .map(|dock| dock.read(cx).collapsible)
-                .unwrap_or(false),
-            DockPlacement::Right => self
-                .right_dock
-                .as_ref()
-                .map(|dock| dock.read(cx).collapsible)
-                .unwrap_or(false),
-            DockPlacement::Center => false,
+            DockPlacement::Center | DockPlacement::Right | DockPlacement::Bottom => false,
         }
     }
 
@@ -882,14 +656,9 @@ impl DockArea {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let dock = match placement {
-            DockPlacement::Left => &self.left_dock,
-            DockPlacement::Bottom => &self.bottom_dock,
-            DockPlacement::Right => &self.right_dock,
-            DockPlacement::Center => return,
-        };
-
-        if let Some(dock) = dock {
+        if let DockPlacement::Left = placement
+            && let Some(dock) = self.left_dock.as_ref()
+        {
             dock.update(cx, |view, cx| {
                 view.toggle_open(window, cx);
             })
@@ -902,11 +671,17 @@ impl DockArea {
     }
 
     /// Add a panel item to the dock area at the given placement.
+    ///
+    /// - [`DockPlacement::Left`] adds the panel to the left dock (creating it
+    ///   if needed).
+    /// - [`DockPlacement::Center`] adds the panel as a tab in the center.
+    /// - [`DockPlacement::Right`] and [`DockPlacement::Bottom`] split the
+    ///   center so the panel lands on the given side of the existing center
+    ///   content.
     pub fn add_panel(
         &mut self,
         panel: Arc<dyn PanelView>,
         placement: DockPlacement,
-        bounds: Option<Bounds<Pixels>>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
@@ -925,39 +700,69 @@ impl DockArea {
                     );
                 }
             }
-            DockPlacement::Bottom => {
-                if let Some(dock) = self.bottom_dock.as_ref() {
-                    dock.update(cx, |dock, cx| dock.add_panel(panel, window, cx))
-                } else {
-                    self.set_bottom_dock(
-                        DockItem::tabs(vec![panel], &weak_self, window, cx),
-                        None,
-                        true,
-                        window,
-                        cx,
-                    );
-                }
-            }
-            DockPlacement::Right => {
-                if let Some(dock) = self.right_dock.as_ref() {
-                    dock.update(cx, |dock, cx| dock.add_panel(panel, window, cx))
-                } else {
-                    self.set_right_dock(
-                        DockItem::tabs(vec![panel], &weak_self, window, cx),
-                        None,
-                        true,
-                        window,
-                        cx,
-                    );
-                }
+            DockPlacement::Right | DockPlacement::Bottom => {
+                self.add_panel_to_center_side(panel, placement, window, cx);
             }
             DockPlacement::Center => {
                 self.center
-                    .add_panel(panel, &cx.entity().downgrade(), bounds, window, cx);
+                    .add_panel(panel, &cx.entity().downgrade(), window, cx);
             }
         }
     }
 
+    /// Split the center so the new panel lands on the given side of the
+    /// existing center content (right of it for [`DockPlacement::Right`],
+    /// below it for [`DockPlacement::Bottom`]).
+    ///
+    /// The existing center keeps its place. Repeating adds with the same axis
+    /// appends further tab groups to the split; a different axis wraps the
+    /// current center in a new split. An empty center is added to directly.
+    fn add_panel_to_center_side(
+        &mut self,
+        panel: Arc<dyn PanelView>,
+        placement: DockPlacement,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        debug_assert!(matches!(
+            placement,
+            DockPlacement::Right | DockPlacement::Bottom
+        ));
+
+        let weak_self = cx.entity().downgrade();
+
+        if self.center.is_empty(cx) {
+            self.center.add_panel(panel, &weak_self, window, cx);
+        } else if let DockItem::Split {
+            axis,
+            size: _,
+            items,
+            sizes,
+            view,
+        } = &mut self.center
+            && *axis == placement.axis()
+        {
+            // The center is already split along this axis: append a new tab group.
+            let new_item = DockItem::tabs(vec![panel], &weak_self, window, cx);
+            items.push(new_item.clone());
+            sizes.push(None);
+            view.update(cx, |stack, cx| {
+                stack.add_panel(new_item.view(), None, weak_self.clone(), window, cx);
+            });
+        } else {
+            // Wrap the existing center in a new split.
+            let existing = self.center.clone();
+            let new_item = DockItem::tabs(vec![panel], &weak_self, window, cx);
+            let items = vec![existing, new_item];
+            let sizes = vec![None; items.len()];
+            self.center =
+                DockItem::split_with_sizes(placement.axis(), items, sizes, &weak_self, window, cx);
+        }
+
+        self.update_toggle_button_tab_panels(window, cx);
+        cx.notify();
+    }
+
     /// Remove panel from the DockArea at the given placement.
     pub fn remove_panel(
         &mut self,
@@ -974,23 +779,13 @@ impl DockArea {
                     });
                 }
             }
-            DockPlacement::Right => {
-                if let Some(dock) = self.right_dock.as_mut() {
-                    dock.update(cx, |dock, cx| {
-                        dock.remove_panel(panel, window, cx);
-                    });
-                }
-            }
-            DockPlacement::Bottom => {
-                if let Some(dock) = self.bottom_dock.as_mut() {
-                    dock.update(cx, |dock, cx| {
-                        dock.remove_panel(panel, window, cx);
-                    });
-                }
-            }
             DockPlacement::Center => {
                 self.center.remove_panel(panel, window, cx);
             }
+            DockPlacement::Right | DockPlacement::Bottom => {
+                // The panel lives in the center; splits are part of it.
+                self.center.remove_panel(panel, window, cx);
+            }
         }
         cx.notify();
     }
@@ -1004,8 +799,6 @@ impl DockArea {
     ) {
         self.remove_panel(panel.clone(), DockPlacement::Center, window, cx);
         self.remove_panel(panel.clone(), DockPlacement::Left, window, cx);
-        self.remove_panel(panel.clone(), DockPlacement::Right, window, cx);
-        self.remove_panel(panel.clone(), DockPlacement::Bottom, window, cx);
     }
 
     /// Load the state of the DockArea from the DockAreaState.
@@ -1024,14 +817,6 @@ impl DockArea {
             self.left_dock = Some(left_dock_state.to_dock(weak_self.clone(), window, cx));
         }
 
-        if let Some(right_dock_state) = state.right_dock {
-            self.right_dock = Some(right_dock_state.to_dock(weak_self.clone(), window, cx));
-        }
-
-        if let Some(bottom_dock_state) = state.bottom_dock {
-            self.bottom_dock = Some(bottom_dock_state.to_dock(weak_self.clone(), window, cx));
-        }
-
         self.center = state.center.to_item(weak_self, window, cx);
         self.update_toggle_button_tab_panels(window, cx);
         Ok(())
@@ -1048,21 +833,11 @@ impl DockArea {
             .left_dock
             .as_ref()
             .map(|dock| DockState::new(dock.clone(), cx));
-        let right_dock = self
-            .right_dock
-            .as_ref()
-            .map(|dock| DockState::new(dock.clone(), cx));
-        let bottom_dock = self
-            .bottom_dock
-            .as_ref()
-            .map(|dock| DockState::new(dock.clone(), cx));
 
         DockAreaState {
             version: self.version,
             center,
             left_dock,
-            right_dock,
-            bottom_dock,
         }
     }
 
@@ -1094,9 +869,6 @@ impl DockArea {
             DockItem::Tabs { .. } => {
                 // We subscribe to the tab panel event in StackPanel's insert_panel
             }
-            DockItem::Tiles { .. } => {
-                // We subscribe to the tab panel event in Tiles's [`add_item`](Tiles::add_item)
-            }
             DockItem::Panel { .. } => {
                 // Not supported
             }
@@ -1171,30 +943,16 @@ impl DockArea {
         match &self.center {
             DockItem::Split { view, .. } => view.clone().into_any_element(),
             DockItem::Tabs { view, .. } => view.clone().into_any_element(),
-            DockItem::Tiles { view, .. } => view.clone().into_any_element(),
             DockItem::Panel { view, .. } => view.clone().view().into_any_element(),
         }
     }
 
     pub fn update_toggle_button_tab_panels(&mut self, _: &mut Window, cx: &mut Context<Self>) {
-        // Left toggle button
+        // The left dock's toggle button lives in the center's top-left tab panel.
         self.toggle_button_panels.left = self
             .center
             .left_top_tab_panel(cx)
             .map(|view| view.entity_id());
-
-        // Right toggle button
-        self.toggle_button_panels.right = self
-            .center
-            .right_top_tab_panel(cx)
-            .map(|view| view.entity_id());
-
-        // Bottom toggle button
-        self.toggle_button_panels.bottom = self
-            .bottom_dock
-            .as_ref()
-            .and_then(|dock| dock.read(cx).panel.left_top_tab_panel(cx))
-            .map(|view| view.entity_id());
     }
 }
 impl EventEmitter<DockEvent> for DockArea {}
@@ -1212,48 +970,24 @@ impl Render for DockArea {
                 if let Some(zoom_view) = self.zoom_view.clone() {
                     this.child(zoom_view)
                 } else {
-                    match &self.center {
-                        DockItem::Tiles { view, .. } => {
-                            // render tiles
-                            this.child(view.clone())
-                        }
-                        _ => {
-                            // render dock
-                            this.child(
+                    // render dock
+                    this.child(
+                        div()
+                            .flex()
+                            .flex_row()
+                            .h_full()
+                            // Left dock
+                            .when_some(self.left_dock.clone(), |this, dock| {
+                                this.child(div().flex().flex_none().child(dock))
+                            })
+                            // Center
+                            .child(
                                 div()
-                                    .flex()
-                                    .flex_row()
-                                    .h_full()
-                                    // Left dock
-                                    .when_some(self.left_dock.clone(), |this, dock| {
-                                        this.child(div().flex().flex_none().child(dock))
-                                    })
-                                    // Center
-                                    .child(
-                                        div()
-                                            .flex()
-                                            .flex_1()
-                                            .flex_col()
-                                            .overflow_hidden()
-                                            // Top center
-                                            .child(
-                                                div()
-                                                    .flex_1()
-                                                    .overflow_hidden()
-                                                    .child(self.render_items(window, cx)),
-                                            )
-                                            // Bottom Dock
-                                            .when_some(self.bottom_dock.clone(), |this, dock| {
-                                                this.child(dock)
-                                            }),
-                                    )
-                                    // Right Dock
-                                    .when_some(self.right_dock.clone(), |this, dock| {
-                                        this.child(div().flex().flex_none().child(dock))
-                                    }),
-                            )
-                        }
-                    }
+                                    .flex_1()
+                                    .overflow_hidden()
+                                    .child(self.render_items(window, cx)),
+                            ),
+                    )
                 }
             })
     }
diff --git a/crates/dock/src/stack_panel.rs b/crates/dock/src/stack_panel.rs
index 5d64a55..de47643 100644
--- a/crates/dock/src/stack_panel.rs
+++ b/crates/dock/src/stack_panel.rs
@@ -6,8 +6,8 @@ use gpui::{
     Window,
 };
 use gpui_component::{
-    ActiveTheme, AxisExt as _, Placement, ResizablePanelEvent, ResizablePanelGroup, ResizableState,
-    h_flex, resizable_panel,
+    ActiveTheme, Placement, ResizablePanelEvent, ResizablePanelGroup, ResizableState, h_flex,
+    resizable_panel,
 };
 use smallvec::SmallVec;
 
@@ -354,38 +354,6 @@ impl StackPanel {
         }
     }
 
-    /// Find the first top right in the stack.
-    pub(super) fn right_top_tab_panel(
-        &self,
-        check_parent: bool,
-        cx: &App,
-    ) -> Option<Entity<TabPanel>> {
-        if check_parent
-            && let Some(parent) = self.parent.as_ref().and_then(|parent| parent.upgrade())
-            && let Some(panel) = parent.read(cx).right_top_tab_panel(true, cx)
-        {
-            return Some(panel);
-        }
-
-        let panel = if self.axis.is_vertical() {
-            self.panels.first()
-        } else {
-            self.panels.last()
-        };
-
-        if let Some(view) = panel {
-            if let Ok(tab_panel) = view.view().downcast::<TabPanel>() {
-                Some(tab_panel)
-            } else if let Ok(stack_panel) = view.view().downcast::<StackPanel>() {
-                stack_panel.read(cx).right_top_tab_panel(false, cx)
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-
     /// Remove all panels from the stack.
     pub(super) fn remove_all_panels(&mut self, _: &mut Window, cx: &mut Context<Self>) {
         self.panels.clear();
diff --git a/crates/dock/src/state.rs b/crates/dock/src/state.rs
index acfc406..389bd3c 100644
--- a/crates/dock/src/state.rs
+++ b/crates/dock/src/state.rs
@@ -1,4 +1,4 @@
-use gpui::{App, AppContext, Axis, Bounds, Entity, Pixels, WeakEntity, Window, point, px, size};
+use gpui::{App, AppContext, Axis, Entity, Pixels, WeakEntity, Window};
 use itertools::Itertools as _;
 use serde::{Deserialize, Serialize};
 
@@ -15,10 +15,6 @@ pub struct DockAreaState {
     pub center: PanelState,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub left_dock: Option<DockState>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub right_dock: Option<DockState>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub bottom_dock: Option<DockState>,
 }
 
 /// Used to serialize and deserialize the Dock
@@ -72,30 +68,6 @@ pub struct PanelState {
     pub info: PanelInfo,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
-pub struct TileMeta {
-    pub bounds: Bounds<Pixels>,
-    pub z_index: usize,
-}
-
-impl Default for TileMeta {
-    fn default() -> Self {
-        Self {
-            bounds: Bounds {
-                origin: point(px(10.), px(10.)),
-                size: size(px(200.), px(200.)),
-            },
-            z_index: 0,
-        }
-    }
-}
-
-impl From<Bounds<Pixels>> for TileMeta {
-    fn from(bounds: Bounds<Pixels>) -> Self {
-        Self { bounds, z_index: 0 }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum PanelInfo {
     #[serde(rename = "stack")]
@@ -107,8 +79,6 @@ pub enum PanelInfo {
     Tabs { active_index: usize },
     #[serde(rename = "panel")]
     Panel(serde_json::Value),
-    #[serde(rename = "tiles")]
-    Tiles { metas: Vec<TileMeta> },
 }
 
 impl PanelInfo {
@@ -127,10 +97,6 @@ impl PanelInfo {
         Self::Panel(info)
     }
 
-    pub fn tiles(metas: Vec<TileMeta>) -> Self {
-        Self::Tiles { metas }
-    }
-
     pub fn axis(&self) -> Option<Axis> {
         match self {
             Self::Stack { axis, .. } => Some(if *axis == 0 {
@@ -232,7 +198,6 @@ impl PanelState {
                 );
                 DockItem::tabs(vec![view.into()], &dock_area, window, cx)
             }
-            PanelInfo::Tiles { metas } => DockItem::tiles(items, metas, &dock_area, window, cx),
         }
     }
 }
@@ -264,19 +229,5 @@ mod tests {
         assert_eq!(left_dock.panel.panel_name, "TabPanel");
         assert_eq!(left_dock.panel.children.len(), 1);
         assert_eq!(left_dock.panel.children[0].panel_name, "StoryContainer");
-
-        let bottom_dock = state.bottom_dock.unwrap();
-        assert!(bottom_dock.open);
-        assert_eq!(bottom_dock.size, px(200.0));
-        assert_eq!(bottom_dock.panel.panel_name, "TabPanel");
-        assert_eq!(bottom_dock.panel.children.len(), 2);
-        assert_eq!(bottom_dock.panel.children[0].panel_name, "StoryContainer");
-
-        let right_dock = state.right_dock.unwrap();
-        assert!(right_dock.open);
-        assert_eq!(right_dock.size, px(320.0));
-        assert_eq!(right_dock.panel.panel_name, "TabPanel");
-        assert_eq!(right_dock.panel.children.len(), 1);
-        assert_eq!(right_dock.panel.children[0].panel_name, "StoryContainer");
     }
 }
diff --git a/crates/dock/src/tab_panel.rs b/crates/dock/src/tab_panel.rs
index 32d4dbb..a2caa6a 100644
--- a/crates/dock/src/tab_panel.rs
+++ b/crates/dock/src/tab_panel.rs
@@ -152,8 +152,6 @@ pub struct TabPanel {
     will_split_placement: Option<Placement>,
     drop_placeholder_animation: Option<DropPlaceholderAnimation>,
     drop_placeholder_animation_name: SharedString,
-    /// Is TabPanel used in Tiles.
-    in_tiles: bool,
 
     /// Bounds of the title bar row (the wrapper around the tab bar), in
     /// window coordinates. Measured via `on_prepaint` to position the
@@ -183,9 +181,8 @@ impl Panel for TabPanel {
             return false;
         }
 
-        // 1. When is the final panel in the dock, it will not able to close.
-        // 2. When is in the Tiles, it will always able to close (by active panel state).
-        if !self.draggable(cx) && !self.in_tiles {
+        // The final panel in the dock is not closable.
+        if !self.draggable(cx) {
             return false;
         }
 
@@ -314,18 +311,12 @@ impl TabPanel {
             zoomed: false,
             collapsed: false,
             closable: true,
-            in_tiles: false,
             title_bar_bounds: None,
             title_bar_strip_bounds: None,
             title_bar_suffix_bounds: None,
         }
     }
 
-    /// Mark the TabPanel as being used in Tiles.
-    pub(super) fn set_in_tiles(&mut self, in_tiles: bool) {
-        self.in_tiles = in_tiles;
-    }
-
     pub(super) fn set_parent(&mut self, view: WeakEntity<StackPanel>) {
         self.stack_panel = Some(view);
     }
@@ -717,6 +708,11 @@ impl TabPanel {
         _: &mut Window,
         cx: &mut Context<Self>,
     ) -> Option<Button> {
+        // Only the left dock can be toggled.
+        if placement != DockPlacement::Left {
+            return None;
+        }
+
         if self.zoomed {
             return None;
         }
@@ -733,47 +729,15 @@ impl TabPanel {
         let toggle_button_panels = dock_area.toggle_button_panels;
 
         // Check if current TabPanel's entity_id matches the one stored in DockArea for this placement
-        if !match placement {
-            DockPlacement::Left => {
-                dock_area.left_dock.is_some() && toggle_button_panels.left == Some(view_entity_id)
-            }
-            DockPlacement::Right => {
-                dock_area.right_dock.is_some() && toggle_button_panels.right == Some(view_entity_id)
-            }
-            DockPlacement::Bottom => {
-                dock_area.bottom_dock.is_some()
-                    && toggle_button_panels.bottom == Some(view_entity_id)
-            }
-            DockPlacement::Center => unreachable!(),
-        } {
+        if dock_area.left_dock.is_none() || toggle_button_panels.left != Some(view_entity_id) {
             return None;
         }
 
         let is_open = dock_area.is_dock_open(placement, cx);
-
-        let icon = match placement {
-            DockPlacement::Left => {
-                if is_open {
-                    IconName::PanelLeft
-                } else {
-                    IconName::PanelLeftOpen
-                }
-            }
-            DockPlacement::Right => {
-                if is_open {
-                    IconName::PanelRight
-                } else {
-                    IconName::PanelRightOpen
-                }
-            }
-            DockPlacement::Bottom => {
-                if is_open {
-                    IconName::PanelBottom
-                } else {
-                    IconName::PanelBottomOpen
-                }
-            }
-            DockPlacement::Center => unreachable!(),
+        let icon = if is_open {
+            IconName::PanelLeft
+        } else {
+            IconName::PanelLeftOpen
         };
 
         Some(
@@ -810,11 +774,7 @@ impl TabPanel {
         };
 
         let left_dock_button = self.render_dock_toggle_button(DockPlacement::Left, window, cx);
-        let bottom_dock_button = self.render_dock_toggle_button(DockPlacement::Bottom, window, cx);
-        let right_dock_button = self.render_dock_toggle_button(DockPlacement::Right, window, cx);
-        let has_extend_dock_button = left_dock_button.is_some() || bottom_dock_button.is_some();
-
-        let is_bottom_dock = bottom_dock_button.is_some();
+        let has_extend_dock_button = left_dock_button.is_some();
 
         // macOS: the traffic lights overlay the window's top-left corner. The
         // left dock (sidebar) normally clears them; when it is closed or
@@ -849,7 +809,6 @@ impl TabPanel {
                     .pr_2()
                     .when(left_dock_button.is_some(), |this| this.pl_2())
                     .when(needs_traffic_light_padding, |this| this.pl(px(80.)))
-                    .when(right_dock_button.is_some(), |this| this.pr_2())
                     .when_some(title_style, |this, theme| {
                         this.bg(theme.background).text_color(theme.foreground)
                     })
@@ -859,8 +818,7 @@ impl TabPanel {
                                 .flex_shrink_0()
                                 .mr_1()
                                 .gap_1()
-                                .children(left_dock_button)
-                                .children(bottom_dock_button),
+                                .children(left_dock_button),
                         )
                     })
                     .child(
@@ -889,8 +847,7 @@ impl TabPanel {
                             .flex_shrink_0()
                             .ml_1()
                             .gap_1()
-                            .child(self.render_toolbar(state, window, cx))
-                            .children(right_dock_button),
+                            .child(self.render_toolbar(state, window, cx)),
                     ),
                 window,
                 cx,
@@ -973,17 +930,13 @@ impl TabPanel {
                                             .top_0()
                                             // Right -1 for avoid border overlap with the first tab
                                             .right(-px(1.))
-                                            .border_r_1()
-                                            .border_b_1()
                                             .h_full()
-                                            .border_color(cx.theme().border)
                                             .bg(cx.theme().tokens.tab_bar)
                                             .px_2()
                                             .when(needs_traffic_light_padding, |this| {
                                                 this.pl(px(80.))
                                             })
-                                            .children(left_dock_button)
-                                            .children(bottom_dock_button),
+                                            .children(left_dock_button),
                                     )
                                 },
                             )
@@ -1017,21 +970,8 @@ impl TabPanel {
                                         })
                                         .selected(active)
                                         .on_click(cx.listener({
-                                            let is_collapsed = self.collapsed;
-                                            let dock_area = self.dock_area.clone();
                                             move |view, _, window, cx| {
                                                 view.set_active_ix(ix, window, cx);
-
-                                                // Open dock if clicked on the collapsed bottom dock
-                                                if is_bottom_dock && is_collapsed {
-                                                    _ = dock_area.update(cx, |dock_area, cx| {
-                                                        dock_area.toggle_dock(
-                                                            DockPlacement::Bottom,
-                                                            window,
-                                                            cx,
-                                                        );
-                                                    });
-                                                }
                                             }
                                         }))
                                         .when(!droppable, |this| {
@@ -1060,23 +1000,18 @@ impl TabPanel {
                                                     this.on_drop(drag, Some(ix), true, window, cx)
                                                 },
                                             ))
-                                            .when(
-                                                !self.in_tiles,
-                                                |this| {
-                                                    this.drag_over::<AnyDrag>(|this, _, _, cx| {
-                                                        this.rounded_l_none()
-                                                            .border_l_2()
-                                                            .border_r_0()
-                                                            .border_color(cx.theme().drag_border)
-                                                    })
-                                                    .on_drop(cx.listener(
-                                                        |this, item: &AnyDrag, _, cx| {
-                                                            this.will_split_placement = None;
-                                                            this.emit_drag_drop(item, None, cx);
-                                                        },
-                                                    ))
+                                            .drag_over::<AnyDrag>(|this, _, _, cx| {
+                                                this.rounded_l_none()
+                                                    .border_l_2()
+                                                    .border_r_0()
+                                                    .border_color(cx.theme().drag_border)
+                                            })
+                                            .on_drop(cx.listener(
+                                                |this, item: &AnyDrag, _, cx| {
+                                                    this.will_split_placement = None;
+                                                    this.emit_drag_drop(item, None, cx);
                                                 },
-                                            )
+                                            ))
                                                 },
                                             )
                                         }),
@@ -1120,19 +1055,14 @@ impl TabPanel {
                                                 this.on_drop(drag, ix, false, window, cx)
                                             },
                                         ))
-                                        .when(
-                                            !self.in_tiles,
-                                            |this| {
-                                                this.drag_over::<AnyDrag>(|this, _, _, cx| {
-                                                    this.bg(cx.theme().tokens.drop_target)
-                                                })
-                                                .on_drop(cx.listener(
-                                                    |this, item: &AnyDrag, _, cx| {
-                                                        this.will_split_placement = None;
-                                                        this.emit_drag_drop(item, None, cx);
-                                                    },
-                                                ))
-                                            },
+                                        .drag_over::<AnyDrag>(|this, _, _, cx| {
+                                            this.bg(cx.theme().tokens.drop_target)
+                                        })
+                                        .on_drop(
+                                            cx.listener(|this, item: &AnyDrag, _, cx| {
+                                                this.will_split_placement = None;
+                                                this.emit_drag_drop(item, None, cx);
+                                            }),
                                         )
                                     }),
                             )
@@ -1142,10 +1072,7 @@ impl TabPanel {
                                         .items_center()
                                         .top_0()
                                         .right_0()
-                                        .border_l_1()
-                                        .border_b_1()
                                         .h_full()
-                                        .border_color(cx.theme().border)
                                         .bg(cx.theme().tokens.tab_bar)
                                         .px_2()
                                         .gap_1()
@@ -1165,8 +1092,7 @@ impl TabPanel {
                                             self.active_panel(cx)
                                                 .and_then(|panel| panel.title_suffix(window, cx)),
                                         )
-                                        .child(self.render_toolbar(state, window, cx))
-                                        .when_some(right_dock_button, |this, btn| this.child(btn)),
+                                        .child(self.render_toolbar(state, window, cx)),
                                 )
                             }),
                     )
@@ -1214,9 +1140,7 @@ impl TabPanel {
             )
             .when(state.droppable, |this| {
                 this.on_drag_move(cx.listener(Self::on_panel_drag_move))
-                    .when(!self.in_tiles, |this| {
-                        this.on_drag_move(cx.listener(Self::on_item_drag_move))
-                    })
+                    .on_drag_move(cx.listener(Self::on_item_drag_move))
                     .child(
                         div()
                             .invisible()
@@ -1233,13 +1157,11 @@ impl TabPanel {
                             .on_drop(cx.listener(|this, drag: &DragPanel, window, cx| {
                                 this.on_drop(drag, None, true, window, cx)
                             }))
-                            .when(!self.in_tiles, |this| {
-                                this.group_drag_over::<AnyDrag>("", |this| this.visible())
-                                    .on_drop(cx.listener(|this, item: &AnyDrag, _, cx| {
-                                        let placement = this.will_split_placement.take();
-                                        this.emit_drag_drop(item, placement, cx);
-                                    }))
-                            })
+                            .group_drag_over::<AnyDrag>("", |this| this.visible())
+                            .on_drop(cx.listener(|this, item: &AnyDrag, _, cx| {
+                                let placement = this.will_split_placement.take();
+                                this.emit_drag_drop(item, placement, cx);
+                            }))
                             .when_some(placeholder, |this, animation| {
                                 let from = animation.from.origin - animation.to.origin;
                                 this.child(
@@ -1601,9 +1523,8 @@ impl TabPanel {
             self.remove_panel(panel, window, cx);
         }
 
-        // Remove self from the parent DockArea.
-        // This is ensure to remove from Tiles
-        if self.panels.is_empty() && self.in_tiles {
+        // Remove self from the parent DockArea when the last panel is closed.
+        if self.panels.is_empty() {
             let tab_panel = Arc::new(cx.entity());
             window.defer(cx, {
                 let dock_area = self.dock_area.clone();
@@ -1681,12 +1602,12 @@ mod tests {
     use std::sync::Mutex;
     use std::sync::atomic::{AtomicBool, Ordering};
 
-    use gpui::{TestAppContext, VisualTestContext, WindowHandle, WindowOptions, size};
+    use gpui::{Axis, TestAppContext, VisualTestContext, WindowHandle, WindowOptions, size};
     use gpui_component::tab::{Tab, TabBar};
     use gpui_component::{Root, Theme, v_flex};
 
     use super::*;
-    use crate::{DockItem, TileMeta};
+    use crate::DockItem;
 
     #[test]
     fn drop_placeholder_bounds_cover_each_target_placement() {
@@ -2018,49 +1939,6 @@ mod tests {
         assert!(cx.read(|cx| fixture.dock_area.read(cx).is_center_empty(cx)));
     }
 
-    /// A `TabPanel` inside `Tiles` has no parent `StackPanel` to remove itself
-    /// from, so emptying it leaves the tile behind and the walk has to recurse.
-    #[gpui::test]
-    fn center_holding_only_empty_tiles_is_empty(cx: &mut TestAppContext) {
-        let fixture = setup(cx);
-        let mut cx = VisualTestContext::from_window(fixture.window.into(), cx);
-
-        let (tabs, tab_panel, panels) = build_tabs(&fixture, &["A"], None, &mut cx);
-        let weak_dock_area = fixture.dock_area.downgrade();
-        cx.update(|window, cx| {
-            let tiles = DockItem::tiles(
-                vec![tabs],
-                vec![TileMeta::default()],
-                &weak_dock_area,
-                window,
-                cx,
-            );
-            fixture
-                .dock_area
-                .update(cx, |area, cx| area.set_center(tiles, window, cx))
-        });
-        cx.run_until_parked();
-        assert!(!cx.read(|cx| fixture.dock_area.read(cx).is_center_empty(cx)));
-
-        for panel in panels {
-            cx.update(|window, cx| {
-                tab_panel.update(cx, |tab_panel, cx| {
-                    tab_panel.remove_panel(Arc::new(panel.clone()), window, cx)
-                })
-            });
-        }
-        cx.run_until_parked();
-
-        let tiles = cx.read(|cx| {
-            let DockItem::Tiles { view, .. } = fixture.dock_area.read(cx).center() else {
-                unreachable!("the centre is a Tiles item");
-            };
-            view.read(cx).panels().len()
-        });
-        assert_eq!(tiles, 1, "the emptied TabPanel is still listed as a tile");
-        assert!(cx.read(|cx| fixture.dock_area.read(cx).is_center_empty(cx)));
-    }
-
     #[gpui::test]
     fn single_panel_group_receives_initial_active(cx: &mut TestAppContext) {
         let fixture = setup(cx);
@@ -2287,6 +2165,59 @@ mod tests {
         assert_eq!(drain(&fixture.log), [("A", false)]);
     }
 
+    /// Adding a panel to the right of the center splits it horizontally;
+    /// a later bottom add wraps the split in a vertical one.
+    #[gpui::test]
+    fn add_panel_splits_the_center(cx: &mut TestAppContext) {
+        let fixture = setup(cx);
+        let mut cx = VisualTestContext::from_window(fixture.window.into(), cx);
+
+        let (item_a, _, _) = build_tabs(&fixture, &["A"], None, &mut cx);
+        let (_item_b, _, panels_b) = build_tabs(&fixture, &["B"], None, &mut cx);
+        let (_item_c, _, panels_c) = build_tabs(&fixture, &["C"], None, &mut cx);
+
+        cx.update(|window, cx| {
+            fixture.dock_area.update(cx, |dock_area, cx| {
+                dock_area.set_center(item_a, window, cx);
+                dock_area.add_panel(
+                    Arc::new(panels_b[0].clone()),
+                    DockPlacement::Right,
+                    window,
+                    cx,
+                );
+            });
+        });
+
+        let (axis, len) = cx.read(|cx| match fixture.dock_area.read(cx).center() {
+            DockItem::Split { axis, items, .. } => (*axis, items.len()),
+            other => panic!("center must be a horizontal split, got {other:?}"),
+        });
+        assert_eq!(axis, Axis::Horizontal);
+        assert_eq!(len, 2, "the right panel must be appended to the split");
+
+        cx.update(|window, cx| {
+            fixture.dock_area.update(cx, |dock_area, cx| {
+                dock_area.add_panel(
+                    Arc::new(panels_c[0].clone()),
+                    DockPlacement::Bottom,
+                    window,
+                    cx,
+                );
+            });
+        });
+
+        cx.read(|cx| match fixture.dock_area.read(cx).center() {
+            DockItem::Split {
+                axis, items, sizes, ..
+            } => {
+                assert_eq!(*axis, Axis::Vertical);
+                assert_eq!(items.len(), 2);
+                assert_eq!(sizes.len(), 2);
+            }
+            other => panic!("center must be wrapped in a vertical split, got {other:?}"),
+        });
+    }
+
     #[derive(Default)]
     struct ProbeFlags {
         empty_down: AtomicBool,
diff --git a/crates/dock/src/tiles.rs b/crates/dock/src/tiles.rs
deleted file mode 100644
index bee394a..0000000
--- a/crates/dock/src/tiles.rs
+++ /dev/null
@@ -1,1440 +0,0 @@
-use std::any::Any;
-use std::fmt::{Debug, Formatter};
-use std::sync::Arc;
-
-use gpui::prelude::FluentBuilder;
-use gpui::{
-    AnyElement, App, AppContext, Bounds, Context, DismissEvent, Div, DragMoveEvent, Empty,
-    EntityId, EventEmitter, FocusHandle, Focusable, InteractiveElement, IntoElement, MouseButton,
-    MouseDownEvent, MouseUpEvent, ParentElement, Pixels, Point, Render, ScrollHandle, Size,
-    StatefulInteractiveElement, Styled, WeakEntity, Window, actions, div, px, size,
-};
-use gpui_component::history::{History, HistoryItem};
-use gpui_component::scroll::{Scrollbar, ScrollbarMode};
-use gpui_component::{ActiveTheme, ElementExt, Icon, IconName, h_flex, v_flex};
-
-use super::{
-    DockArea, Panel, PanelEvent, PanelInfo, PanelState, PanelView, StackPanel, TabPanel, TileMeta,
-};
-
-// See the note in [`crate::init`]: unique group name to avoid colliding with
-// gpui-component's `tiles::` actions.
-actions!(signed_tiles, [Undo, Redo]);
-
-const MINIMUM_SIZE: Size<Pixels> = size(px(100.), px(100.));
-const DRAG_BAR_HEIGHT: Pixels = px(30.);
-const HANDLE_SIZE: Pixels = px(5.0);
-
-#[derive(Clone, PartialEq, Debug)]
-struct TileChange {
-    tile_id: EntityId,
-    old_bounds: Option<Bounds<Pixels>>,
-    new_bounds: Option<Bounds<Pixels>>,
-    old_order: Option<usize>,
-    new_order: Option<usize>,
-    version: usize,
-}
-
-impl HistoryItem for TileChange {
-    fn version(&self) -> usize {
-        self.version
-    }
-
-    fn set_version(&mut self, version: usize) {
-        self.version = version;
-    }
-}
-
-#[derive(Clone)]
-pub struct DragMoving(EntityId);
-impl Render for DragMoving {
-    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
-        Empty
-    }
-}
-
-#[derive(Clone, PartialEq)]
-enum ResizeSide {
-    Left,
-    Right,
-    Top,
-    Bottom,
-    BottomRight,
-}
-
-#[derive(Clone)]
-pub struct DragResizing(EntityId);
-
-impl Render for DragResizing {
-    fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
-        Empty
-    }
-}
-
-#[derive(Clone)]
-struct ResizeDrag {
-    side: ResizeSide,
-    last_position: Point<Pixels>,
-    last_bounds: Bounds<Pixels>,
-}
-
-/// TileItem is a moveable and resizable panel that can be added to a Tiles view.
-#[derive(Clone)]
-pub struct TileItem {
-    id: EntityId,
-    pub(crate) panel: Arc<dyn PanelView>,
-    bounds: Bounds<Pixels>,
-    z_index: usize,
-}
-
-impl Debug for TileItem {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("TileItem")
-            .field("bounds", &self.bounds)
-            .field("z_index", &self.z_index)
-            .finish()
-    }
-}
-
-impl TileItem {
-    pub fn new(panel: Arc<dyn PanelView>, bounds: Bounds<Pixels>) -> Self {
-        Self {
-            id: panel.view().entity_id(),
-            panel,
-            bounds,
-            z_index: 0,
-        }
-    }
-
-    pub fn z_index(mut self, z_index: usize) -> Self {
-        self.z_index = z_index;
-        self
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct AnyDrag {
-    pub value: Arc<dyn Any>,
-}
-
-impl AnyDrag {
-    pub fn new(value: impl Any) -> Self {
-        Self {
-            value: Arc::new(value),
-        }
-    }
-}
-
-/// Tiles is a canvas that can contain multiple panels, each of which can be dragged and resized.
-pub struct Tiles {
-    focus_handle: FocusHandle,
-    pub(crate) panels: Vec<TileItem>,
-    dragging_id: Option<EntityId>,
-    dragging_initial_mouse: Point<Pixels>,
-    dragging_initial_bounds: Bounds<Pixels>,
-    resizing_id: Option<EntityId>,
-    resizing_drag_data: Option<ResizeDrag>,
-    bounds: Bounds<Pixels>,
-    history: History<TileChange>,
-    scroll_handle: ScrollHandle,
-    scrollbar_mode: Option<ScrollbarMode>,
-}
-
-impl Panel for Tiles {
-    fn panel_name(&self) -> &'static str {
-        "Tiles"
-    }
-
-    fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        "Tiles".into_any_element()
-    }
-
-    fn dump(&self, cx: &App) -> PanelState {
-        let panels = self
-            .panels
-            .iter()
-            .map(|item: &TileItem| item.panel.dump(cx))
-            .collect();
-
-        let metas = self
-            .panels
-            .iter()
-            .map(|item: &TileItem| TileMeta {
-                bounds: item.bounds,
-                z_index: item.z_index,
-            })
-            .collect();
-
-        let mut state = PanelState::new(self);
-        state.panel_name = self.panel_name().to_string();
-        state.children = panels;
-        state.info = PanelInfo::Tiles { metas };
-        state
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct DragDrop(pub AnyDrag);
-
-impl EventEmitter<DragDrop> for Tiles {}
-
-impl Tiles {
-    pub fn new(_: &mut Window, cx: &mut Context<Self>) -> Self {
-        Self {
-            focus_handle: cx.focus_handle(),
-            panels: vec![],
-            dragging_id: None,
-            dragging_initial_mouse: Point::default(),
-            dragging_initial_bounds: Bounds::default(),
-            resizing_id: None,
-            scrollbar_mode: None,
-            resizing_drag_data: None,
-            bounds: Bounds::default(),
-            history: History::new().group_interval(std::time::Duration::from_millis(100)),
-            scroll_handle: ScrollHandle::default(),
-        }
-    }
-
-    /// Set the scrollbar show mode [`ScrollbarMode`], if not set use the `cx.theme().scrollbar_mode`.
-    pub fn set_scrollbar_mode(
-        &mut self,
-        scrollbar_mode: Option<ScrollbarMode>,
-        cx: &mut Context<Self>,
-    ) {
-        self.scrollbar_mode = scrollbar_mode;
-        cx.notify();
-    }
-
-    pub fn panels(&self) -> &[TileItem] {
-        &self.panels
-    }
-
-    fn sorted_panels(&self) -> Vec<TileItem> {
-        let mut items: Vec<(usize, TileItem)> = self.panels.iter().cloned().enumerate().collect();
-        items.sort_by(|a, b| a.1.z_index.cmp(&b.1.z_index).then_with(|| a.0.cmp(&b.0)));
-        items.into_iter().map(|(_, item)| item).collect()
-    }
-
-    /// Return the index of the panel.
-    #[inline]
-    pub(crate) fn index_of(&self, id: &EntityId) -> Option<usize> {
-        self.panels.iter().position(|p| &p.id == id)
-    }
-
-    #[inline]
-    pub(crate) fn panel(&self, id: &EntityId) -> Option<&TileItem> {
-        self.panels.iter().find(|p| &p.id == id)
-    }
-
-    /// Remove panel from the children.
-    pub fn remove(&mut self, panel: Arc<dyn PanelView>, _: &mut Window, cx: &mut Context<Self>) {
-        if let Some(ix) = self.index_of(&panel.panel_id(cx)) {
-            self.panels.remove(ix);
-
-            cx.emit(PanelEvent::LayoutChanged);
-        }
-    }
-
-    /// Calculate magnetic snap position for the dragging panel
-    fn calculate_magnetic_snap(
-        &self,
-        dragging_bounds: Bounds<Pixels>,
-        item_ix: usize,
-        snap_threshold: Pixels,
-    ) -> (Option<Pixels>, Option<Pixels>) {
-        // Only check nearby panels
-        let search_bounds = Bounds {
-            origin: Point {
-                x: dragging_bounds.left() - snap_threshold,
-                y: dragging_bounds.top() - snap_threshold,
-            },
-            size: Size {
-                width: dragging_bounds.size.width + snap_threshold * 2.0,
-                height: dragging_bounds.size.height + snap_threshold * 2.0,
-            },
-        };
-
-        let mut snap_x: Option<Pixels> = None;
-        let mut snap_y: Option<Pixels> = None;
-        let mut min_x_dist = snap_threshold;
-        let mut min_y_dist = snap_threshold;
-
-        // Pre-calculate dragging bounds edges to avoid repeated method calls
-        let drag_left = dragging_bounds.left();
-        let drag_right = dragging_bounds.right();
-        let drag_top = dragging_bounds.top();
-        let drag_bottom = dragging_bounds.bottom();
-        let drag_width = dragging_bounds.size.width;
-        let drag_height = dragging_bounds.size.height;
-
-        // Check for edge snapping first (top and left boundaries)
-        let edge_snap_pos = px(0.);
-
-        // Snap to top edge
-        let top_dist = drag_top.abs();
-        if top_dist < snap_threshold {
-            snap_y = Some(edge_snap_pos);
-            min_y_dist = top_dist;
-        }
-
-        // Snap to left edge
-        let left_dist = drag_left.abs();
-        if left_dist < snap_threshold {
-            snap_x = Some(edge_snap_pos);
-            min_x_dist = left_dist;
-        }
-
-        // If both edges are snapped, return early
-        if snap_x.is_some() && snap_y.is_some() {
-            return (snap_x, snap_y);
-        }
-
-        for (ix, other) in self.panels.iter().enumerate() {
-            if ix == item_ix {
-                continue;
-            }
-
-            // Pre-calculate other bounds edges
-            let other_left = other.bounds.left();
-            let other_right = other.bounds.right();
-            let other_top = other.bounds.top();
-            let other_bottom = other.bounds.bottom();
-
-            // Skip panels that are far away
-            if other_right < search_bounds.left()
-                || other_left > search_bounds.right()
-                || other_bottom < search_bounds.top()
-                || other_top > search_bounds.bottom()
-            {
-                continue;
-            }
-
-            // Horizontal snapping (X axis) - find closest snap point
-            if snap_x.is_none() {
-                let candidates = [
-                    ((drag_left - other_left).abs(), other_left),
-                    ((drag_left - other_right).abs(), other_right),
-                    ((drag_right - other_left).abs(), other_left - drag_width),
-                    ((drag_right - other_right).abs(), other_right - drag_width),
-                ];
-
-                for (dist, snap_pos) in candidates {
-                    if dist < min_x_dist {
-                        min_x_dist = dist;
-                        snap_x = Some(snap_pos);
-                    }
-                }
-            }
-
-            // Vertical snapping (Y axis) - find closest snap point
-            if snap_y.is_none() {
-                let candidates = [
-                    ((drag_top - other_top).abs(), other_top),
-                    ((drag_top - other_bottom).abs(), other_bottom),
-                    ((drag_bottom - other_top).abs(), other_top - drag_height),
-                    (
-                        (drag_bottom - other_bottom).abs(),
-                        other_bottom - drag_height,
-                    ),
-                ];
-
-                for (dist, snap_pos) in candidates {
-                    if dist < min_y_dist {
-                        min_y_dist = dist;
-                        snap_y = Some(snap_pos);
-                    }
-                }
-            }
-
-            // Early exit if both axes are snapped
-            if snap_x.is_some() && snap_y.is_some() {
-                break;
-            }
-        }
-
-        (snap_x, snap_y)
-    }
-
-    /// Apply boundary constraints to the panel origin
-    fn apply_boundary_constraints(&self, mut origin: Point<Pixels>) -> Point<Pixels> {
-        // Top boundary
-        if origin.y < px(0.) {
-            origin.y = px(0.);
-        }
-
-        // Left boundary (allow partial off-screen but keep 64px visible)
-        let min_left = -self.dragging_initial_bounds.size.width + px(64.);
-        if origin.x < min_left {
-            origin.x = min_left;
-        }
-
-        origin
-    }
-
-    fn update_position(&mut self, mouse_position: Point<Pixels>, cx: &mut Context<Self>) {
-        let Some(dragging_id) = self.dragging_id else {
-            return;
-        };
-
-        let Some(item_ix) = self.panels.iter().position(|p| p.id == dragging_id) else {
-            return;
-        };
-
-        let previous_bounds = self.panels[item_ix].bounds;
-        let adjusted_position = mouse_position - self.bounds.origin;
-        let delta = adjusted_position - self.dragging_initial_mouse;
-        let mut new_origin = self.dragging_initial_bounds.origin + delta;
-
-        // Apply magnetic snap before boundary checks
-        let snap_threshold = cx.theme().tile_grid_size;
-        let dragging_bounds = Bounds {
-            origin: new_origin,
-            size: self.dragging_initial_bounds.size,
-        };
-
-        let (snap_x, snap_y) =
-            self.calculate_magnetic_snap(dragging_bounds, item_ix, snap_threshold);
-
-        // Apply snapping
-        if let Some(x) = snap_x {
-            new_origin.x = x;
-        }
-        if let Some(y) = snap_y {
-            new_origin.y = y;
-        }
-
-        // Apply boundary constraints after snapping
-        new_origin = self.apply_boundary_constraints(new_origin);
-
-        // Update position without grid rounding (smooth dragging)
-        if new_origin != previous_bounds.origin {
-            self.panels[item_ix].bounds.origin = new_origin;
-            let item = &self.panels[item_ix];
-            let bounds = item.bounds;
-            let entity_id = item.panel.view().entity_id();
-
-            if !self.history.is_ignoring() {
-                self.history.push(TileChange {
-                    tile_id: entity_id,
-                    old_bounds: Some(previous_bounds),
-                    new_bounds: Some(bounds),
-                    old_order: None,
-                    new_order: None,
-                    version: 0,
-                });
-            }
-            cx.notify();
-        }
-    }
-
-    fn resize(
-        &mut self,
-        new_x: Option<Pixels>,
-        new_y: Option<Pixels>,
-        new_width: Option<Pixels>,
-        new_height: Option<Pixels>,
-        _: &mut Window,
-        cx: &mut Context<'_, Self>,
-    ) {
-        let Some(resizing_id) = self.resizing_id else {
-            return;
-        };
-
-        let grid_size = cx.theme().tile_grid_size;
-        // Neighbor bounds drive magnetic edge snapping (exclude the resizing panel).
-        let other_bounds: Vec<Bounds<Pixels>> = self
-            .panels
-            .iter()
-            .filter(|item| item.id != resizing_id)
-            .map(|item| item.bounds)
-            .collect();
-
-        let Some(item) = self.panels.iter_mut().find(|item| item.id == resizing_id) else {
-            return;
-        };
-
-        let previous_bounds = item.bounds;
-        let new_bounds = compute_resized_bounds(
-            previous_bounds,
-            new_x,
-            new_y,
-            new_width,
-            new_height,
-            &other_bounds,
-            grid_size,
-        );
-
-        // Only push to history if the geometry actually changed.
-        if new_bounds.origin.x != previous_bounds.origin.x
-            || new_bounds.origin.y != previous_bounds.origin.y
-            || new_bounds.size.width != previous_bounds.size.width
-            || new_bounds.size.height != previous_bounds.size.height
-        {
-            item.bounds = new_bounds;
-
-            // Only push if not during history operations
-            if !self.history.is_ignoring() {
-                self.history.push(TileChange {
-                    tile_id: item.panel.view().entity_id(),
-                    old_bounds: Some(previous_bounds),
-                    new_bounds: Some(item.bounds),
-                    old_order: None,
-                    new_order: None,
-                    version: 0,
-                });
-            }
-        }
-
-        cx.notify();
-    }
-
-    pub fn add_item(
-        &mut self,
-        item: TileItem,
-        dock_area: &WeakEntity<DockArea>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) {
-        let Ok(tab_panel) = item.panel.view().downcast::<TabPanel>() else {
-            panic!("only allows to add TabPanel type")
-        };
-
-        tab_panel.update(cx, |tab_panel, _| {
-            tab_panel.set_in_tiles(true);
-        });
-
-        self.panels.push(item.clone());
-        window.defer(cx, {
-            let panel = item.panel.clone();
-            let dock_area = dock_area.clone();
-
-            move |window, cx| {
-                // Subscribe to the panel's layout change event.
-                _ = dock_area.update(cx, |this, cx| {
-                    if let Ok(tab_panel) = panel.view().downcast::<TabPanel>() {
-                        this.subscribe_panel(&tab_panel, window, cx);
-                    }
-                });
-            }
-        });
-
-        cx.emit(PanelEvent::LayoutChanged);
-        cx.notify();
-    }
-
-    #[inline]
-    fn reset_current_index(&mut self) {
-        self.dragging_id = None;
-        self.resizing_id = None;
-    }
-
-    /// Bring the panel of target_index to front, returns (old_index, new_index) if successful
-    fn bring_to_front(
-        &mut self,
-        target_id: Option<EntityId>,
-        cx: &mut Context<Self>,
-    ) -> Option<EntityId> {
-        let old_id = target_id?;
-
-        let old_ix = self.panels.iter().position(|item| item.id == old_id)?;
-        if old_ix < self.panels.len() {
-            let item = self.panels.remove(old_ix);
-            self.panels.push(item);
-            let new_ix = self.panels.len() - 1;
-            let new_id = self.panels[new_ix].id;
-            self.history.push(TileChange {
-                tile_id: new_id,
-                old_bounds: None,
-                new_bounds: None,
-                old_order: Some(old_ix),
-                new_order: Some(new_ix),
-                version: 0,
-            });
-            cx.notify();
-            return Some(new_id);
-        }
-        None
-    }
-
-    /// Handle the undo action
-    pub fn undo(&mut self, _: &mut Window, cx: &mut Context<Self>) {
-        self.history.set_ignoring(true);
-
-        if let Some(changes) = self.history.undo() {
-            for change in changes {
-                if let Some(index) = self
-                    .panels
-                    .iter()
-                    .position(|item| item.panel.view().entity_id() == change.tile_id)
-                {
-                    if let Some(old_bounds) = change.old_bounds {
-                        self.panels[index].bounds = old_bounds;
-                    }
-                    if let Some(old_order) = change.old_order {
-                        let item = self.panels.remove(index);
-                        self.panels.insert(old_order, item);
-                    }
-                }
-            }
-            cx.emit(PanelEvent::LayoutChanged);
-        }
-
-        self.history.set_ignoring(false);
-        cx.notify();
-    }
-
-    /// Handle the redo action
-    pub fn redo(&mut self, _: &mut Window, cx: &mut Context<Self>) {
-        self.history.set_ignoring(true);
-
-        if let Some(changes) = self.history.redo() {
-            for change in changes {
-                if let Some(index) = self
-                    .panels
-                    .iter()
-                    .position(|item| item.panel.view().entity_id() == change.tile_id)
-                {
-                    if let Some(new_bounds) = change.new_bounds {
-                        self.panels[index].bounds = new_bounds;
-                    }
-                    if let Some(new_order) = change.new_order {
-                        let item = self.panels.remove(index);
-                        self.panels.insert(new_order, item);
-                    }
-                }
-            }
-            cx.emit(PanelEvent::LayoutChanged);
-        }
-
-        self.history.set_ignoring(false);
-        cx.notify();
-    }
-
-    /// Returns the active panel, if any.
-    pub fn active_panel(&self, cx: &App) -> Option<Arc<dyn PanelView>> {
-        self.panels.last().and_then(|item| {
-            if let Ok(tab_panel) = item.panel.view().downcast::<TabPanel>() {
-                tab_panel.read(cx).active_panel(cx)
-            } else if item.panel.view().downcast::<StackPanel>().is_ok() {
-                None
-            } else {
-                Some(item.panel.clone())
-            }
-        })
-    }
-
-    /// Produce a vector of AnyElement representing the three possible resize handles
-    fn render_resize_handles(
-        &mut self,
-        _: &mut Window,
-        cx: &mut Context<Self>,
-        entity_id: EntityId,
-        item: &TileItem,
-    ) -> Vec<AnyElement> {
-        let item_id = item.id;
-        let item_bounds = item.bounds;
-        let handle_offset = -HANDLE_SIZE + px(1.);
-
-        let mut elements = Vec::new();
-
-        // Left resize handle
-        elements.push(
-            div()
-                .id("left-resize-handle")
-                .cursor_ew_resize()
-                .absolute()
-                .top_0()
-                .left(handle_offset)
-                .w(HANDLE_SIZE)
-                .h(item_bounds.size.height)
-                .on_mouse_down(
-                    MouseButton::Left,
-                    cx.listener({
-                        move |this, event: &MouseDownEvent, window, cx| {
-                            this.on_resize_handle_mouse_down(
-                                ResizeSide::Left,
-                                item_id,
-                                item_bounds,
-                                event,
-                                window,
-                                cx,
-                            );
-                        }
-                    }),
-                )
-                .on_drag(DragResizing(entity_id), |drag, _, _, cx| {
-                    cx.stop_propagation();
-                    cx.new(|_| drag.clone())
-                })
-                .on_drag_move(cx.listener(
-                    move |this, e: &DragMoveEvent<DragResizing>, window, cx| match e.drag(cx) {
-                        DragResizing(id) => {
-                            if *id != entity_id {
-                                return;
-                            }
-
-                            let Some(ref drag_data) = this.resizing_drag_data else {
-                                return;
-                            };
-                            if drag_data.side != ResizeSide::Left {
-                                return;
-                            }
-
-                            let pos = e.event.position;
-                            let delta = drag_data.last_position.x - pos.x;
-                            let new_x = (drag_data.last_bounds.origin.x - delta).max(px(0.0));
-                            let size_delta = drag_data.last_bounds.origin.x - new_x;
-                            let new_width = (drag_data.last_bounds.size.width + size_delta)
-                                .max(MINIMUM_SIZE.width);
-                            this.resize(Some(new_x), None, Some(new_width), None, window, cx);
-                        }
-                    },
-                ))
-                .into_any_element(),
-        );
-
-        // Right resize handle
-        elements.push(
-            div()
-                .id("right-resize-handle")
-                .cursor_ew_resize()
-                .absolute()
-                .top_0()
-                .right(handle_offset)
-                .w(HANDLE_SIZE)
-                .h(item_bounds.size.height)
-                .on_mouse_down(
-                    MouseButton::Left,
-                    cx.listener({
-                        move |this, event: &MouseDownEvent, window, cx| {
-                            this.on_resize_handle_mouse_down(
-                                ResizeSide::Right,
-                                item_id,
-                                item_bounds,
-                                event,
-                                window,
-                                cx,
-                            );
-                        }
-                    }),
-                )
-                .on_drag(DragResizing(entity_id), |drag, _, _, cx| {
-                    cx.stop_propagation();
-                    cx.new(|_| drag.clone())
-                })
-                .on_drag_move(cx.listener(
-                    move |this, e: &DragMoveEvent<DragResizing>, window, cx| match e.drag(cx) {
-                        DragResizing(id) => {
-                            if *id != entity_id {
-                                return;
-                            }
-
-                            let Some(ref drag_data) = this.resizing_drag_data else {
-                                return;
-                            };
-
-                            if drag_data.side != ResizeSide::Right {
-                                return;
-                            }
-
-                            let pos = e.event.position;
-                            let delta = pos.x - drag_data.last_position.x;
-                            let new_width =
-                                (drag_data.last_bounds.size.width + delta).max(MINIMUM_SIZE.width);
-                            this.resize(None, None, Some(new_width), None, window, cx);
-                        }
-                    },
-                ))
-                .into_any_element(),
-        );
-
-        // Top resize handle
-        elements.push(
-            div()
-                .id("top-resize-handle")
-                .cursor_ns_resize()
-                .absolute()
-                .left(px(0.0))
-                .top(handle_offset)
-                .w(item_bounds.size.width)
-                .h(HANDLE_SIZE)
-                .on_mouse_down(
-                    MouseButton::Left,
-                    cx.listener({
-                        move |this, event: &MouseDownEvent, window, cx| {
-                            this.on_resize_handle_mouse_down(
-                                ResizeSide::Top,
-                                item_id,
-                                item_bounds,
-                                event,
-                                window,
-                                cx,
-                            );
-                        }
-                    }),
-                )
-                .on_drag(DragResizing(entity_id), |drag, _, _, cx| {
-                    cx.stop_propagation();
-                    cx.new(|_| drag.clone())
-                })
-                .on_drag_move(cx.listener(
-                    move |this, e: &DragMoveEvent<DragResizing>, window, cx| match e.drag(cx) {
-                        DragResizing(id) => {
-                            if *id != entity_id {
-                                return;
-                            }
-
-                            let Some(ref drag_data) = this.resizing_drag_data else {
-                                return;
-                            };
-                            if drag_data.side != ResizeSide::Top {
-                                return;
-                            }
-
-                            let pos = e.event.position;
-                            let delta = drag_data.last_position.y - pos.y;
-                            let new_y = (drag_data.last_bounds.origin.y - delta).max(px(0.));
-                            let size_delta = drag_data.last_bounds.origin.y - new_y;
-                            let new_height = (drag_data.last_bounds.size.height + size_delta)
-                                .max(MINIMUM_SIZE.height);
-                            this.resize(None, Some(new_y), None, Some(new_height), window, cx);
-                        }
-                    },
-                ))
-                .into_any_element(),
-        );
-
-        // Bottom resize handle
-        elements.push(
-            div()
-                .id("bottom-resize-handle")
-                .cursor_ns_resize()
-                .absolute()
-                .left(px(0.0))
-                .bottom(handle_offset)
-                .w(item_bounds.size.width)
-                .h(HANDLE_SIZE)
-                .on_mouse_down(
-                    MouseButton::Left,
-                    cx.listener({
-                        move |this, event: &MouseDownEvent, window, cx| {
-                            this.on_resize_handle_mouse_down(
-                                ResizeSide::Bottom,
-                                item_id,
-                                item_bounds,
-                                event,
-                                window,
-                                cx,
-                            );
-                        }
-                    }),
-                )
-                .on_drag(DragResizing(entity_id), |drag, _, _, cx| {
-                    cx.stop_propagation();
-                    cx.new(|_| drag.clone())
-                })
-                .on_drag_move(cx.listener(
-                    move |this, e: &DragMoveEvent<DragResizing>, window, cx| match e.drag(cx) {
-                        DragResizing(id) => {
-                            if *id != entity_id {
-                                return;
-                            }
-
-                            let Some(ref drag_data) = this.resizing_drag_data else {
-                                return;
-                            };
-
-                            if drag_data.side != ResizeSide::Bottom {
-                                return;
-                            }
-
-                            let pos = e.event.position;
-                            let delta = pos.y - drag_data.last_position.y;
-                            let new_height = (drag_data.last_bounds.size.height + delta)
-                                .max(MINIMUM_SIZE.height);
-                            this.resize(None, None, None, Some(new_height), window, cx);
-                        }
-                    },
-                ))
-                .into_any_element(),
-        );
-
-        // Anchor resize handle
-        elements.push(
-            div()
-                .child(
-                    Icon::new(IconName::ResizeCorner)
-                        .size_3()
-                        .absolute()
-                        .right(px(1.))
-                        .bottom(px(1.))
-                        .text_color(cx.theme().muted_foreground.opacity(0.5)),
-                )
-                .child(
-                    div()
-                        .id("corner-resize-handle")
-                        .cursor_nwse_resize()
-                        .absolute()
-                        .right(handle_offset)
-                        .bottom(handle_offset)
-                        .size_3()
-                        .on_mouse_down(
-                            MouseButton::Left,
-                            cx.listener({
-                                move |this, event: &MouseDownEvent, window, cx| {
-                                    this.on_resize_handle_mouse_down(
-                                        ResizeSide::BottomRight,
-                                        item_id,
-                                        item_bounds,
-                                        event,
-                                        window,
-                                        cx,
-                                    );
-                                }
-                            }),
-                        )
-                        .on_drag(DragResizing(entity_id), |drag, _, _, cx| {
-                            cx.stop_propagation();
-                            cx.new(|_| drag.clone())
-                        })
-                        .on_drag_move(cx.listener(
-                            move |this, e: &DragMoveEvent<DragResizing>, window, cx| {
-                                match e.drag(cx) {
-                                    DragResizing(id) => {
-                                        if *id != entity_id {
-                                            return;
-                                        }
-
-                                        let Some(ref drag_data) = this.resizing_drag_data else {
-                                            return;
-                                        };
-
-                                        if drag_data.side != ResizeSide::BottomRight {
-                                            return;
-                                        }
-
-                                        let pos = e.event.position;
-                                        let delta_x = pos.x - drag_data.last_position.x;
-                                        let delta_y = pos.y - drag_data.last_position.y;
-                                        let new_width = (drag_data.last_bounds.size.width
-                                            + delta_x)
-                                            .max(MINIMUM_SIZE.width);
-                                        let new_height = (drag_data.last_bounds.size.height
-                                            + delta_y)
-                                            .max(MINIMUM_SIZE.height);
-                                        this.resize(
-                                            None,
-                                            None,
-                                            Some(new_width),
-                                            Some(new_height),
-                                            window,
-                                            cx,
-                                        );
-                                    }
-                                }
-                            },
-                        )),
-                )
-                .into_any_element(),
-        );
-
-        elements
-    }
-
-    fn on_resize_handle_mouse_down(
-        &mut self,
-        side: ResizeSide,
-        item_id: EntityId,
-        item_bounds: Bounds<Pixels>,
-        event: &MouseDownEvent,
-        _: &mut Window,
-        cx: &mut Context<'_, Self>,
-    ) {
-        let last_position = event.position;
-        self.resizing_id = Some(item_id);
-        self.resizing_drag_data = Some(ResizeDrag {
-            side,
-            last_position,
-            last_bounds: item_bounds,
-        });
-
-        if let Some(new_id) = self.bring_to_front(self.resizing_id, cx) {
-            self.resizing_id = Some(new_id);
-        }
-        cx.stop_propagation();
-    }
-
-    /// Produce the drag-bar element for the given panel item
-    fn render_drag_bar(
-        &mut self,
-        _: &mut Window,
-        cx: &mut Context<Self>,
-        entity_id: EntityId,
-        item: &TileItem,
-    ) -> AnyElement {
-        let item_id = item.id;
-        let item_bounds = item.bounds;
-
-        h_flex()
-            .id("drag-bar")
-            .absolute()
-            .w_full()
-            .h(DRAG_BAR_HEIGHT)
-            .bg(cx.theme().transparent)
-            .on_mouse_down(
-                MouseButton::Left,
-                cx.listener(move |this, event: &MouseDownEvent, _, cx| {
-                    let inner_pos = event.position - this.bounds.origin;
-                    this.dragging_id = Some(item_id);
-                    this.dragging_initial_mouse = inner_pos;
-                    this.dragging_initial_bounds = item_bounds;
-
-                    if let Some(new_id) = this.bring_to_front(Some(item_id), cx) {
-                        this.dragging_id = Some(new_id);
-                    }
-                }),
-            )
-            .on_drag(DragMoving(entity_id), |drag, _, _, cx| {
-                cx.stop_propagation();
-                cx.new(|_| drag.clone())
-            })
-            .on_drag_move(
-                cx.listener(
-                    move |this, e: &DragMoveEvent<DragMoving>, _, cx| match e.drag(cx) {
-                        DragMoving(id) => {
-                            if *id != entity_id {
-                                return;
-                            }
-                            this.update_position(e.event.position, cx);
-                        }
-                    },
-                ),
-            )
-            .into_any_element()
-    }
-
-    fn render_panel(
-        &mut self,
-        item: &TileItem,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Div {
-        let entity_id = cx.entity_id();
-        let item_id = item.id;
-        let panel_view = item.panel.view();
-
-        v_flex()
-            .occlude()
-            .bg(cx.theme().tokens.background)
-            .border_1()
-            .border_color(cx.theme().border)
-            .absolute()
-            .left(item.bounds.origin.x)
-            .top(item.bounds.origin.y)
-            // More 1px to account for the border width when 2 panels are too close
-            .w(item.bounds.size.width + px(1.))
-            .h(item.bounds.size.height + px(1.))
-            .rounded(cx.theme().tile_radius)
-            .child(h_flex().overflow_hidden().size_full().child(panel_view))
-            .children(self.render_resize_handles(window, cx, entity_id, item))
-            .child(self.render_drag_bar(window, cx, entity_id, item))
-            .on_mouse_down(
-                MouseButton::Left,
-                cx.listener(move |this, _, _, _| {
-                    this.dragging_id = Some(item_id);
-                }),
-            )
-            // Here must be mouse up for avoid conflict with Drag event
-            .on_mouse_up(
-                MouseButton::Left,
-                cx.listener(move |this, _, _, cx| {
-                    if this.dragging_id == Some(item_id) {
-                        this.dragging_id = None;
-                        this.bring_to_front(Some(item_id), cx);
-                    }
-                }),
-            )
-    }
-
-    /// Handle the mouse up event to finalize drag or resize operations
-    fn on_mouse_up(&mut self, _: &mut Window, cx: &mut Context<'_, Tiles>) {
-        // Check if a drag or resize was active
-        if self.dragging_id.is_some()
-            || self.resizing_id.is_some()
-            || self.resizing_drag_data.is_some()
-        {
-            let mut changes_to_push = vec![];
-
-            // Handle dragging
-            if let Some(dragging_id) = self.dragging_id
-                && let Some(idx) = self.panels.iter().position(|p| p.id == dragging_id)
-            {
-                let initial_bounds = self.dragging_initial_bounds;
-                let current_bounds = self.panels[idx].bounds;
-
-                // Apply grid alignment to final position
-                let aligned_origin = round_point_to_nearest_ten(current_bounds.origin, cx);
-
-                if initial_bounds.origin != aligned_origin
-                    || initial_bounds.size != current_bounds.size
-                {
-                    self.panels[idx].bounds.origin = aligned_origin;
-
-                    changes_to_push.push(TileChange {
-                        tile_id: self.panels[idx].panel.view().entity_id(),
-                        old_bounds: Some(initial_bounds),
-                        new_bounds: Some(self.panels[idx].bounds),
-                        old_order: None,
-                        new_order: None,
-                        version: 0,
-                    });
-                }
-            }
-
-            // Handle resizing
-            if let Some(resizing_id) = self.resizing_id
-                && let Some(drag_data) = &self.resizing_drag_data
-                && let Some(item) = self.panel(&resizing_id)
-            {
-                let initial_bounds = drag_data.last_bounds;
-                let current_bounds = item.bounds;
-                if initial_bounds.size != current_bounds.size {
-                    changes_to_push.push(TileChange {
-                        tile_id: item.panel.view().entity_id(),
-                        old_bounds: Some(initial_bounds),
-                        new_bounds: Some(current_bounds),
-                        old_order: None,
-                        new_order: None,
-                        version: 0,
-                    });
-                }
-            }
-
-            // Push changes to history if any
-            if !changes_to_push.is_empty() {
-                for change in changes_to_push {
-                    self.history.push(change);
-                }
-            }
-
-            // Reset drag and resize state
-            self.reset_current_index();
-            self.resizing_drag_data = None;
-            cx.emit(PanelEvent::LayoutChanged);
-            cx.notify();
-        }
-    }
-}
-
-/// Snap `edge` to the nearest value in `candidates` whose distance is strictly
-/// below `threshold`. Returns `None` when nothing is close enough.
-fn snap_edge(edge: Pixels, candidates: &[Pixels], threshold: Pixels) -> Option<Pixels> {
-    let mut best: Option<Pixels> = None;
-    let mut best_dist = threshold;
-    for &candidate in candidates {
-        let dist = (edge - candidate).abs();
-        if dist < best_dist {
-            best_dist = dist;
-            best = Some(candidate);
-        }
-    }
-    best
-}
-
-/// Compute the final bounds for a resize, applying magnetic edge snapping to
-/// neighboring panels and falling back to grid rounding when no neighbor edge
-/// is within `grid_size`.
-///
-/// Which edges move is inferred from the provided `Option`s, mirroring
-/// `Tiles::resize`:
-/// - `new_x` set                  => left edge moves (right edge pinned)
-/// - `new_width` set, `new_x` not => right edge moves (left edge pinned)
-/// - `new_y` set                  => top edge moves (bottom edge pinned)
-/// - `new_height` set, `new_y` not => bottom edge moves (top edge pinned)
-fn compute_resized_bounds(
-    previous: Bounds<Pixels>,
-    new_x: Option<Pixels>,
-    new_y: Option<Pixels>,
-    new_width: Option<Pixels>,
-    new_height: Option<Pixels>,
-    other_bounds: &[Bounds<Pixels>],
-    grid_size: Pixels,
-) -> Bounds<Pixels> {
-    // Candidate snap edges from neighbouring panels.
-    let mut x_edges = Vec::with_capacity(other_bounds.len() * 2);
-    let mut y_edges = Vec::with_capacity(other_bounds.len() * 2);
-    for bounds in other_bounds {
-        x_edges.push(bounds.left());
-        x_edges.push(bounds.right());
-        y_edges.push(bounds.top());
-        y_edges.push(bounds.bottom());
-    }
-
-    let prev_right = previous.origin.x + previous.size.width;
-    let prev_bottom = previous.origin.y + previous.size.height;
-
-    // --- X axis ---
-    let (final_x, final_width) = if let Some(x) = new_x {
-        // Left edge moving; right edge pinned. Canvas-left (0) is also a target.
-        let raw_left = x.max(px(0.));
-        let mut candidates = x_edges.clone();
-        candidates.push(px(0.));
-        let snapped_left = snap_edge(raw_left, &candidates, grid_size)
-            .unwrap_or_else(|| round_to_nearest_ten_with(raw_left, grid_size));
-        let width = (prev_right - snapped_left).max(MINIMUM_SIZE.width);
-        (snapped_left, width)
-    } else if let Some(width) = new_width {
-        // Right edge moving; left edge pinned.
-        let raw_right = previous.origin.x + width;
-        let snapped_right = snap_edge(raw_right, &x_edges, grid_size)
-            .unwrap_or_else(|| round_to_nearest_ten_with(raw_right, grid_size));
-        let width = (snapped_right - previous.origin.x).max(MINIMUM_SIZE.width);
-        (previous.origin.x, width)
-    } else {
-        (previous.origin.x, previous.size.width)
-    };
-
-    // --- Y axis ---
-    let (final_y, final_height) = if let Some(y) = new_y {
-        // Top edge moving; bottom edge pinned. Canvas-top (0) is also a target.
-        let raw_top = y.max(px(0.));
-        let mut candidates = y_edges.clone();
-        candidates.push(px(0.));
-        let snapped_top = snap_edge(raw_top, &candidates, grid_size)
-            .unwrap_or_else(|| round_to_nearest_ten_with(raw_top, grid_size));
-        let height = (prev_bottom - snapped_top).max(MINIMUM_SIZE.height);
-        (snapped_top, height)
-    } else if let Some(height) = new_height {
-        // Bottom edge moving; top edge pinned.
-        let raw_bottom = previous.origin.y + height;
-        let snapped_bottom = snap_edge(raw_bottom, &y_edges, grid_size)
-            .unwrap_or_else(|| round_to_nearest_ten_with(raw_bottom, grid_size));
-        let height = (snapped_bottom - previous.origin.y).max(MINIMUM_SIZE.height);
-        (previous.origin.y, height)
-    } else {
-        (previous.origin.y, previous.size.height)
-    };
-
-    Bounds {
-        origin: Point {
-            x: final_x,
-            y: final_y,
-        },
-        size: Size {
-            width: final_width,
-            height: final_height,
-        },
-    }
-}
-
-fn round_to_nearest_ten_with(value: Pixels, grid_size: Pixels) -> Pixels {
-    (value / grid_size).round() * grid_size
-}
-
-#[inline]
-fn round_to_nearest_ten(value: Pixels, cx: &App) -> Pixels {
-    round_to_nearest_ten_with(value, cx.theme().tile_grid_size)
-}
-
-#[inline]
-fn round_point_to_nearest_ten(point: Point<Pixels>, cx: &App) -> Point<Pixels> {
-    Point::new(
-        round_to_nearest_ten(point.x, cx),
-        round_to_nearest_ten(point.y, cx),
-    )
-}
-
-impl Focusable for Tiles {
-    fn focus_handle(&self, _cx: &App) -> FocusHandle {
-        self.focus_handle.clone()
-    }
-}
-impl EventEmitter<PanelEvent> for Tiles {}
-impl EventEmitter<DismissEvent> for Tiles {}
-impl Render for Tiles {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let view = cx.entity().clone();
-        let panels = self.sorted_panels();
-        let scroll_bounds =
-            self.panels
-                .iter()
-                .fold(Bounds::default(), |acc: Bounds<Pixels>, item| Bounds {
-                    origin: Point {
-                        x: acc.origin.x.min(item.bounds.origin.x),
-                        y: acc.origin.y.min(item.bounds.origin.y),
-                    },
-                    size: Size {
-                        width: acc.size.width.max(item.bounds.right()),
-                        height: acc.size.height.max(item.bounds.bottom()),
-                    },
-                });
-        let scroll_size = scroll_bounds.size - size(scroll_bounds.origin.x, scroll_bounds.origin.y);
-
-        div()
-            .relative()
-            .bg(cx.theme().tokens.tiles)
-            .child(
-                div()
-                    .id("tiles")
-                    .track_scroll(&self.scroll_handle)
-                    .size_full()
-                    .top(-px(1.))
-                    .left(-px(1.))
-                    .overflow_scroll()
-                    .children(
-                        panels
-                            .into_iter()
-                            .map(|item| self.render_panel(&item, window, cx)),
-                    )
-                    .on_prepaint(move |bounds, _, cx| view.update(cx, |r, _| r.bounds = bounds))
-                    .on_drop(cx.listener(move |_, item: &AnyDrag, _, cx| {
-                        cx.emit(DragDrop(item.clone()));
-                    })),
-            )
-            .on_mouse_up(
-                MouseButton::Left,
-                cx.listener(move |this, _event: &MouseUpEvent, window, cx| {
-                    this.on_mouse_up(window, cx);
-                }),
-            )
-            .child(
-                Scrollbar::new(&self.scroll_handle)
-                    .scroll_size(scroll_size)
-                    .when_some(self.scrollbar_mode, |this, scrollbar_mode| {
-                        this.mode(scrollbar_mode)
-                    }),
-            )
-            .size_full()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use gpui::{Bounds, Pixels, Point, Size, px};
-
-    use super::*;
-
-    fn b(x: f32, y: f32, w: f32, h: f32) -> Bounds<Pixels> {
-        Bounds {
-            origin: Point { x: px(x), y: px(y) },
-            size: Size {
-                width: px(w),
-                height: px(h),
-            },
-        }
-    }
-
-    #[test]
-    fn test_snap_edge_within_threshold() {
-        // 102 is 2px from 100 (< 8) -> snaps to 100.
-        assert_eq!(
-            snap_edge(px(102.), &[px(100.), px(300.)], px(8.)),
-            Some(px(100.))
-        );
-    }
-
-    #[test]
-    fn test_snap_edge_outside_threshold() {
-        // 120 is 20px from nearest candidate (>= 8) -> no snap.
-        assert_eq!(snap_edge(px(120.), &[px(100.), px(300.)], px(8.)), None);
-    }
-
-    #[test]
-    fn test_snap_edge_picks_nearest() {
-        // 303 is 3px from 300 and 5px from 308 -> picks 300.
-        assert_eq!(
-            snap_edge(px(303.), &[px(308.), px(300.)], px(8.)),
-            Some(px(300.))
-        );
-    }
-
-    #[test]
-    fn test_snap_edge_empty_candidates() {
-        assert_eq!(snap_edge(px(50.), &[], px(8.)), None);
-    }
-
-    #[test]
-    fn test_resize_right_edge_snaps_to_neighbor_left() {
-        // Panel A: x=0 w=196 (right edge 196). Neighbour B starts at x=200.
-        // Dragging right edge to 197 should snap right edge to 200 -> width 200.
-        let prev = b(0., 0., 196., 100.);
-        let neighbor = b(200., 0., 100., 100.);
-        let out =
-            compute_resized_bounds(prev, None, None, Some(px(197.)), None, &[neighbor], px(8.));
-        assert_eq!(out.origin.x, px(0.));
-        assert_eq!(out.size.width, px(200.));
-    }
-
-    #[test]
-    fn test_resize_bottom_edge_snaps_to_neighbor_top() {
-        let prev = b(0., 0., 100., 196.);
-        let neighbor = b(0., 200., 100., 100.);
-        let out =
-            compute_resized_bounds(prev, None, None, None, Some(px(197.)), &[neighbor], px(8.));
-        assert_eq!(out.origin.y, px(0.));
-        assert_eq!(out.size.height, px(200.));
-    }
-
-    #[test]
-    fn test_resize_left_edge_snaps_and_pins_right() {
-        // Panel: x=200 w=100 (right edge 300). Neighbour right edge at 100.
-        // Drag left edge to 103 -> snaps to 100 -> width = 300 - 100 = 200.
-        let prev = b(200., 0., 100., 100.);
-        let neighbor = b(0., 0., 100., 100.);
-        let out = compute_resized_bounds(
-            prev,
-            Some(px(103.)),
-            None,
-            Some(px(197.)),
-            None,
-            &[neighbor],
-            px(8.),
-        );
-        assert_eq!(out.origin.x, px(100.));
-        assert_eq!(out.size.width, px(200.));
-    }
-
-    #[test]
-    fn test_resize_corner_snaps_both_edges() {
-        // Right edge -> neighbour-right at 300; bottom edge -> neighbour-bottom at 250.
-        let prev = b(0., 0., 196., 196.);
-        let right_neighbor = b(100., 0., 200., 100.); // right edge = 300
-        let bottom_neighbor = b(0., 100., 100., 150.); // bottom edge = 250
-        let out = compute_resized_bounds(
-            prev,
-            None,
-            None,
-            Some(px(298.)),
-            Some(px(248.)),
-            &[right_neighbor, bottom_neighbor],
-            px(8.),
-        );
-        assert_eq!(out.size.width, px(300.));
-        assert_eq!(out.size.height, px(250.));
-    }
-
-    #[test]
-    fn test_resize_grid_rounds_when_no_neighbor_close() {
-        // No neighbours; raw right edge 153 -> grid round to 152 (nearest multiple of 8).
-        let prev = b(0., 0., 100., 100.);
-        let out = compute_resized_bounds(prev, None, None, Some(px(153.)), None, &[], px(8.));
-        assert_eq!(out.size.width, px(152.));
-    }
-
-    #[test]
-    fn test_resize_respects_minimum_size() {
-        let prev = b(0., 0., 100., 100.);
-        let out = compute_resized_bounds(prev, None, None, Some(px(10.)), None, &[], px(8.));
-        assert_eq!(out.size.width, MINIMUM_SIZE.width);
-    }
-
-    #[test]
-    fn test_resize_no_change_returns_previous_geometry() {
-        let prev = b(0., 0., 100., 100.);
-        let out = compute_resized_bounds(prev, None, None, None, None, &[], px(8.));
-        assert_eq!(out.origin.x, px(0.));
-        assert_eq!(out.origin.y, px(0.));
-        assert_eq!(out.size.width, px(100.));
-        assert_eq!(out.size.height, px(100.));
-    }
-}
diff --git a/crates/dock/src/window_controls.rs b/crates/dock/src/window_controls.rs
index 18fba96..ee4617d 100644
--- a/crates/dock/src/window_controls.rs
+++ b/crates/dock/src/window_controls.rs
@@ -133,8 +133,6 @@ impl RenderOnce for ControlIcon {
     }
 }
 
-/// Render the window control buttons, or an empty placeholder on macOS (the
-/// traffic lights are drawn natively).
 pub(crate) fn window_controls(window: &mut Window, cx: &mut App) -> impl IntoElement {
     if cfg!(target_os = "macos") || cfg!(target_family = "wasm") {
         return div().id("window-controls");
diff --git a/crates/workspace/src/views/repo_detail/mod.rs b/crates/workspace/src/views/repo_detail/mod.rs
index 61340bf..b79c2d6 100644
--- a/crates/workspace/src/views/repo_detail/mod.rs
+++ b/crates/workspace/src/views/repo_detail/mod.rs
@@ -651,7 +651,7 @@ impl RepoDetailView {
             cx.new(|cx| CommitDiffView::new(worktree, repo_name, commit_id.into(), window, cx));
 
         dock_area.update(cx, |dock_area, cx| {
-            dock_area.add_panel(Arc::new(panel), DockPlacement::Center, None, window, cx);
+            dock_area.add_panel(Arc::new(panel), DockPlacement::Center, window, cx);
         });
     }
 
@@ -665,7 +665,7 @@ impl RepoDetailView {
             cx.new(|cx| IssuesView::new(self.store.clone(), self.display_name(cx), window, cx));
 
         dock_area.update(cx, |dock_area, cx| {
-            dock_area.add_panel(Arc::new(panel), DockPlacement::Center, None, window, cx);
+            dock_area.add_panel(Arc::new(panel), DockPlacement::Center, window, cx);
         });
     }
 
@@ -679,7 +679,7 @@ impl RepoDetailView {
             .new(|cx| PullRequestsView::new(self.store.clone(), self.display_name(cx), window, cx));
 
         dock_area.update(cx, |dock_area, cx| {
-            dock_area.add_panel(Arc::new(panel), DockPlacement::Center, None, window, cx);
+            dock_area.add_panel(Arc::new(panel), DockPlacement::Center, window, cx);
         });
     }
 
diff --git a/crates/workspace/src/views/repo_list.rs b/crates/workspace/src/views/repo_list.rs
index 2ec89ab..a10c8dc 100644
--- a/crates/workspace/src/views/repo_list.rs
+++ b/crates/workspace/src/views/repo_list.rs
@@ -68,7 +68,7 @@ impl RepoListView {
 
         if let Some(dock_area) = dock_area.upgrade() {
             dock_area.update(cx, |dock_area, cx| {
-                dock_area.add_panel(Arc::new(detail), DockPlacement::Center, None, window, cx);
+                dock_area.add_panel(Arc::new(detail), DockPlacement::Center, window, cx);
             });
         }
     }
diff --git a/crates/workspace/src/views/sidebar/mod.rs b/crates/workspace/src/views/sidebar/mod.rs
index 35b7523..43bf050 100644
--- a/crates/workspace/src/views/sidebar/mod.rs
+++ b/crates/workspace/src/views/sidebar/mod.rs
@@ -74,7 +74,7 @@ impl SidebarPanel {
         self.explore = Some(panel.downgrade());
 
         let _ = self.dock_area.update(cx, |dock_area, cx| {
-            dock_area.add_panel(Arc::new(panel), DockPlacement::Center, None, window, cx);
+            dock_area.add_panel(Arc::new(panel), DockPlacement::Center, window, cx);
         });
     }