fix(dock): size drag preview by visible panels, not stack size

The drag preview divided the edge height by the raw panel count on the target
side. Closed panels keep their stack slot, so a hidden panel (e.g. the block
palette tucked away while Properties stays open) split the ghost and the drop
index as if it were rendering — leaving a half-height preview on that edge.
Size slots from the panels actually rendered on the edge instead, via a shared
visibility helper used by both the drop-index math and the ghost/edge-tint
geometry.

src/app/update/dialog.rs

@@ -644,7 +644,7 @@ pub(super) fn on_ribbon_tool_click(&mut self, tool_id: String, event: ModuleEven
                     };
                     let index = crate::ui::dock::drop_index(
                         point.y,
-                        std::cmp::max(self.dock.len(side), 1),
+                        std::cmp::max(self.dock_visible_len(side), 1),
                         avail,
                     );
                     self.dock_drag_target = Some((side, index));
@@ -681,6 +681,33 @@ pub(super) fn on_ribbon_tool_click(&mut self, tool_id: String, event: ModuleEven
         }
     }
 
+    /// Whether `id` is currently rendered (not closed, not on the start screen /
+    /// clean-screen viewport). Mirrors the visibility filter the edge column
+    /// renderer applies before building each side's stack.
+    pub(crate) fn dock_panel_visible(&self, id: crate::ui::dock::PanelId) -> bool {
+        use crate::ui::dock::PanelId;
+        if self.tabs[self.active_tab].is_start || self.clean_screen {
+            return false;
+        }
+        match id {
+            PanelId::Properties => self.show_properties,
+            PanelId::BlockPalette => self.show_block_palette,
+        }
+    }
+
+    /// Number of panels currently rendered on `side`. Closed panels keep their
+    /// stack slot but take no vertical space, so drag preview geometry must
+    /// size slots against only the panels that are actually visible.
+    pub(crate) fn dock_visible_len(&self, side: crate::app::config::DockSide) -> usize {
+        let ids: &[crate::ui::dock::PanelId] = match side {
+            crate::app::config::DockSide::Left => &self.dock.left,
+            crate::app::config::DockSide::Right => &self.dock.right,
+        };
+        ids.iter()
+            .filter(|id| self.dock_panel_visible(**id))
+            .count()
+    }
+
     /// Start placing `name` through the INSERT command, skipping the name prompt.
     fn start_block_placement(&mut self, name: &str) {
         let i = self.active_tab;
@@ -1121,6 +1148,89 @@ mod tests {
         );
     }
 
+    #[test]
+    fn dock_visible_len_counts_only_rendered_panels() {
+        let mut app = fresh();
+        app.dock = Default::default();
+        app.dock.left = vec![
+            crate::ui::dock::PanelId::BlockPalette,
+            crate::ui::dock::PanelId::Properties,
+        ];
+        // Left: block palette hidden, properties shown -> 1 visible panel.
+        app.show_block_palette = false;
+        app.show_properties = true;
+        assert_eq!(
+            app.dock_visible_len(crate::app::config::DockSide::Left),
+            1
+        );
+        // Reveal the block palette -> both count.
+        app.show_block_palette = true;
+        assert_eq!(
+            app.dock_visible_len(crate::app::config::DockSide::Left),
+            2
+        );
+        // A hidden (closed) panel counts for nothing even when stacked.
+        app.show_block_palette = false;
+        assert_eq!(
+            app.dock_visible_len(crate::app::config::DockSide::Left),
+            1
+        );
+    }
+
+    #[test]
+    fn dock_drag_target_ignores_hidden_panels_on_the_side() {
+        // Reproduce the persisted layout that exposed a half-height ghost: two
+        // panels live in the left stack but the block palette is hidden
+        // (show_block_palette=false), so only Properties renders. Drag geometry
+        // must count only panels that are actually visible.
+        let mut app = fresh();
+        app.dock = Default::default();
+        app.dock.left = vec![
+            crate::ui::dock::PanelId::BlockPalette,
+            crate::ui::dock::PanelId::Properties,
+        ];
+        app.show_block_palette = false;
+        app.show_properties = true;
+        let i = app.active_tab;
+        app.tabs[i].scene.selection.borrow_mut().vp_size = (1600.0, 900.0);
+        app.win_size = (1600.0, 900.0).into();
+        let id = crate::ui::dock::PanelId::Properties;
+        let _ = app.on_dock(crate::ui::dock::DockMsg::DockGrab(id));
+        // Pointer near the bottom of the left edge: one visible panel means a
+        // single slot, so every y maps to index 0 (no top/bottom split).
+        let _ =
+            app.on_dock(crate::ui::dock::DockMsg::DragMove(iced::Point::new(100.0, 850.0)));
+        assert_eq!(
+            app.dock_drag_target,
+            Some((crate::app::config::DockSide::Left, 0))
+        );
+    }
+
+    #[test]
+    fn dock_drag_target_counts_all_visible_panels() {
+        let mut app = fresh();
+        app.dock = Default::default();
+        app.dock.left = vec![
+            crate::ui::dock::PanelId::BlockPalette,
+            crate::ui::dock::PanelId::Properties,
+        ];
+        // Both panels shown: two real slots on the left edge. A pointer near
+        // the bottom maps to the append slot (index == 2).
+        app.show_block_palette = true;
+        app.show_properties = true;
+        let i = app.active_tab;
+        app.tabs[i].scene.selection.borrow_mut().vp_size = (1600.0, 900.0);
+        app.win_size = (1600.0, 900.0).into();
+        let id = crate::ui::dock::PanelId::Properties;
+        let _ = app.on_dock(crate::ui::dock::DockMsg::DockGrab(id));
+        let _ =
+            app.on_dock(crate::ui::dock::DockMsg::DragMove(iced::Point::new(100.0, 850.0)));
+        assert_eq!(
+            app.dock_drag_target,
+            Some((crate::app::config::DockSide::Left, 2))
+        );
+    }
+
     #[test]
     fn blockpalette_width_reset() {
         let mut app = fresh();

src/app/view/mod.rs

@@ -1528,13 +1528,17 @@ impl OpenCADStudio {
                     .unwrap_or(crate::app::config::DockSide::Right),
             );
             // Dropping onto an edge joins that edge's stack, whose column is as
-            // wide as its widest panel (the dragged panel included).
+            // wide as its widest currently-shown panel (the dragged panel
+            // included). Hidden (closed) panels don't render, so they can't
+            // widen the column being previewed.
             let preview_width = {
                 let mut widths: Vec<f32> = match side {
-                    crate::app::config::DockSide::Left => self.dock.left.clone(),
-                    crate::app::config::DockSide::Right => self.dock.right.clone(),
+                    crate::app::config::DockSide::Left => &self.dock.left,
+                    crate::app::config::DockSide::Right => &self.dock.right,
                 }
-                .into_iter()
+                .iter()
+                .copied()
+                .filter(|&pid| self.dock_panel_visible(pid))
                 .map(|pid| self.dock.width(pid, self.win_size.0))
                 .collect();
                 widths.push(self.dock.width(id, self.win_size.0));
@@ -1555,13 +1559,17 @@ impl OpenCADStudio {
                     }
                 });
             // The ghost is the dragged panel at its real size: its own saved
-            // width and its 1/N share of the edge (N = stack size after the
-            // drop), with a header naming which panel is being moved.
+            // width and its 1/N share of the edge (N = number of panels shown
+            // on the edge after the drop), with a header naming which panel is
+            // being moved. Only visibly-docked panels share the column height:
+            // a hidden (closed) panel keeps its stack slot but no screen space,
+            // so it must not split the preview.
             let was_here = self.dock.location(id).map(|(s, _)| s) == Some(side);
+            let visible = self.dock_visible_len(side);
             let final_count = if was_here {
-                std::cmp::max(self.dock.len(side), 1)
+                std::cmp::max(visible, 1)
             } else {
-                self.dock.len(side) + 1
+                visible + 1
             };
             let edge_h = tab.scene.selection.borrow().vp_size.1;
             let slot_h = edge_h / final_count as f32;

src/ui/dock.rs

@@ -195,11 +195,6 @@ impl DockState {
         stack.insert(index, id);
         true
     }
-
-    /// Number of panels currently docked on `side`.
-    pub fn len(&self, side: DockSide) -> usize {
-        self.stack(side).len()
-    }
 }
 
 /// Insertion index (0..=total) for dropping a panel whose pointer is at
@@ -319,11 +314,4 @@ mod tests {
         assert_eq!(drop_index(10.0, 2, 900.0), 0);
         assert_eq!(drop_index(890.0, 2, 900.0), 2);
     }
-
-    #[test]
-    fn len_reports_stack_size() {
-        let state = DockState::default();
-        assert_eq!(state.len(DockSide::Left), 1);
-        assert_eq!(state.len(DockSide::Right), 1);
-    }
 }