Refine XCEditor docking and DPI rendering

2026-04-11 17:07:37 +08:00
parent 35d3d6328b
commit 2958dcc491
46 changed files with 4839 additions and 471 deletions
--- a/tests/UI/Editor/unit/test_ui_editor_dock_host.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_dock_host.cpp
@@ -98,8 +98,8 @@ TEST(UIEditorDockHostTest, LayoutComposesOnlyUnifiedTabStacksFromWorkspaceTree)

    const auto* rootSplitter = FindUIEditorDockHostSplitterLayout(layout, "root-split");
    ASSERT_NE(rootSplitter, nullptr);
-    EXPECT_FLOAT_EQ(rootSplitter->splitterLayout.handleRect.x, 395.0f);
-    EXPECT_FLOAT_EQ(rootSplitter->splitterLayout.handleRect.width, 10.0f);
+    EXPECT_FLOAT_EQ(rootSplitter->splitterLayout.handleRect.x, 399.5f);
+    EXPECT_FLOAT_EQ(rootSplitter->splitterLayout.handleRect.width, 1.0f);

    const auto& tabStack = layout.tabStacks.front();
    EXPECT_EQ(tabStack.nodeId, "document-tabs");
@@ -138,7 +138,7 @@ TEST(UIEditorDockHostTest, HiddenBranchCollapsesAndVisibleBranchUsesFullBounds)
    EXPECT_FLOAT_EQ(layout.tabStacks.front().bounds.height, 480.0f);
 }

-TEST(UIEditorDockHostTest, HitTestPrioritizesSplitterThenTabCloseThenPanelBody) {
+TEST(UIEditorDockHostTest, HitTestPrioritizesSplitterThenTabThenPanelBody) {
    const UIEditorPanelRegistry registry = BuildPanelRegistry();
    const UIEditorWorkspaceModel workspace = BuildWorkspace();
    const UIEditorWorkspaceSession session =
@@ -160,14 +160,14 @@ TEST(UIEditorDockHostTest, HitTestPrioritizesSplitterThenTabCloseThenPanelBody)
    EXPECT_EQ(splitterHit.nodeId, "root-split");

    ASSERT_EQ(layout.tabStacks.size(), 3u);
-    const auto& closeRect = layout.tabStacks.front().tabStripLayout.closeButtonRects[1];
-    const auto tabCloseHit = HitTestUIEditorDockHost(
+    const auto& tabRect = layout.tabStacks.front().tabStripLayout.tabHeaderRects[1];
+    const auto tabHit = HitTestUIEditorDockHost(
        layout,
-        UIPoint(closeRect.x + closeRect.width * 0.5f, closeRect.y + closeRect.height * 0.5f));
-    EXPECT_EQ(tabCloseHit.kind, UIEditorDockHostHitTargetKind::TabCloseButton);
-    EXPECT_EQ(tabCloseHit.nodeId, "document-tabs");
-    EXPECT_EQ(tabCloseHit.panelId, "doc-b");
-    EXPECT_EQ(tabCloseHit.index, 1u);
+        UIPoint(tabRect.x + tabRect.width - 6.0f, tabRect.y + tabRect.height * 0.5f));
+    EXPECT_EQ(tabHit.kind, UIEditorDockHostHitTargetKind::Tab);
+    EXPECT_EQ(tabHit.nodeId, "document-tabs");
+    EXPECT_EQ(tabHit.panelId, "doc-b");
+    EXPECT_EQ(tabHit.index, 1u);

    const auto panelBodyHit = HitTestUIEditorDockHost(
        layout,
@@ -186,7 +186,7 @@ TEST(UIEditorDockHostTest, BackgroundAndForegroundEmitStableCompositeCommands) {
    UIEditorDockHostState state = {};
    state.focused = true;
    state.hoveredTarget = UIEditorDockHostHitTarget{
-        UIEditorDockHostHitTargetKind::TabCloseButton,
+        UIEditorDockHostHitTargetKind::Tab,
        "document-tabs",
        "doc-b",
        1u
--- a/tests/UI/Editor/unit/test_ui_editor_dock_host_interaction.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_dock_host_interaction.cpp
@@ -5,6 +5,9 @@
 #include <XCEditor/Shell/UIEditorWorkspaceController.h>
 #include <XCEditor/Shell/UIEditorWorkspaceModel.h>

+#include <algorithm>
+#include <string>
+
 namespace {

 using XCEngine::UI::UIInputEvent;
@@ -19,6 +22,7 @@ using XCEngine::UI::Editor::BuildUIEditorWorkspaceSingleTabStack;
 using XCEngine::UI::Editor::BuildUIEditorWorkspaceSplit;
 using XCEngine::UI::Editor::BuildUIEditorWorkspaceTabStack;
 using XCEngine::UI::Editor::FindUIEditorPanelSessionState;
+using XCEngine::UI::Editor::FindUIEditorWorkspaceNode;
 using XCEngine::UI::Editor::UIEditorDockHostInteractionState;
 using XCEngine::UI::Editor::UIEditorPanelRegistry;
 using XCEngine::UI::Editor::UIEditorWorkspaceModel;
@@ -33,6 +37,7 @@ UIEditorPanelRegistry BuildPanelRegistry() {
    registry.panels = {
        { "doc-a", "Document A", {}, true, true, true },
        { "doc-b", "Document B", {}, true, true, true },
+        { "doc-c", "Document C", {}, true, true, true },
        { "details", "Details", {}, true, true, true },
        { "console", "Console", {}, true, true, true }
    };
@@ -62,6 +67,30 @@ UIEditorWorkspaceModel BuildWorkspace() {
    return workspace;
 }

+UIEditorWorkspaceModel BuildThreeDocumentWorkspace() {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceSplit(
+        "root-split",
+        UIEditorWorkspaceSplitAxis::Horizontal,
+        0.5f,
+        BuildUIEditorWorkspaceTabStack(
+            "document-tabs",
+            {
+                BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+                BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true),
+                BuildUIEditorWorkspacePanel("doc-c-node", "doc-c", "Document C", true)
+            },
+            2u),
+        BuildUIEditorWorkspaceSplit(
+            "right-split",
+            UIEditorWorkspaceSplitAxis::Vertical,
+            0.6f,
+            BuildUIEditorWorkspaceSingleTabStack("details-node", "details", "Details", true),
+            BuildUIEditorWorkspaceSingleTabStack("console-node", "console", "Console", true)));
+    workspace.activePanelId = "doc-c";
+    return workspace;
+}
+
 UIInputEvent MakePointerMove(float x, float y) {
    UIInputEvent event = {};
    event.type = UIInputEventType::PointerMove;
@@ -230,60 +259,6 @@ TEST(UIEditorDockHostInteractionTest, ClickingTabActivatesTargetPanel) {
    EXPECT_EQ(documentStack->selectedPanelId, "doc-a");
 }

-TEST(UIEditorDockHostInteractionTest, ClickingTabCloseClosesPanelThroughController) {
-    auto controller =
-        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
-    UIEditorDockHostInteractionState state = {};
-
-    auto frame = UpdateUIEditorDockHostInteraction(
-        state,
-        controller,
-        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
-        {});
-    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
-    ASSERT_NE(documentStack, nullptr);
-    const UIRect closeRect = documentStack->tabStripLayout.closeButtonRects[1];
-    const UIPoint closeCenter = RectCenter(closeRect);
-
-    frame = UpdateUIEditorDockHostInteraction(
-        state,
-        controller,
-        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
-        { MakePointerMove(closeCenter.x, closeCenter.y) });
-    EXPECT_EQ(frame.result.hitTarget.kind, UIEditorDockHostHitTargetKind::TabCloseButton);
-    EXPECT_EQ(frame.result.hitTarget.panelId, "doc-b");
-
-    frame = UpdateUIEditorDockHostInteraction(
-        state,
-        controller,
-        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
-        { MakePointerDown(closeCenter.x, closeCenter.y) });
-    EXPECT_TRUE(frame.result.consumed);
-    EXPECT_FALSE(frame.result.commandExecuted);
-
-    frame = UpdateUIEditorDockHostInteraction(
-        state,
-        controller,
-        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
-        { MakePointerDown(closeCenter.x, closeCenter.y) });
-    EXPECT_TRUE(frame.result.consumed);
-    EXPECT_FALSE(frame.result.commandExecuted);
-
-    frame = UpdateUIEditorDockHostInteraction(
-        state,
-        controller,
-        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
-        { MakePointerUp(closeCenter.x, closeCenter.y) });
-    EXPECT_TRUE(frame.result.consumed);
-    EXPECT_TRUE(frame.result.commandExecuted);
-
-    const auto* panelState = FindUIEditorPanelSessionState(controller.GetSession(), "doc-b");
-    ASSERT_NE(panelState, nullptr);
-    EXPECT_FALSE(panelState->open);
-    EXPECT_FALSE(panelState->visible);
-    EXPECT_EQ(controller.GetWorkspace().activePanelId, "doc-a");
-}
-
 TEST(UIEditorDockHostInteractionTest, FocusedTabStripHandlesKeyboardNavigationThroughTabStripInteraction) {
    auto controller =
        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
@@ -399,7 +374,7 @@ TEST(UIEditorDockHostInteractionTest, ClickingSingleTabStackBodyActivatesTargetP
    EXPECT_EQ(controller.GetWorkspace().activePanelId, "details");
 }

-TEST(UIEditorDockHostInteractionTest, ClickingSingleTabStackTabCloseClosesPanelThroughController) {
+TEST(UIEditorDockHostInteractionTest, DraggingTabWithinSameStackRequestsCaptureAndCommitsReorder) {
    auto controller =
        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
    UIEditorDockHostInteractionState state = {};
@@ -409,29 +384,411 @@ TEST(UIEditorDockHostInteractionTest, ClickingSingleTabStackTabCloseClosesPanelT
        controller,
        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
        {});
-    const auto* consoleStack = FindTabStackByNodeId(frame.layout, "console-node");
-    ASSERT_NE(consoleStack, nullptr);
-    const UIRect closeRect = consoleStack->tabStripLayout.closeButtonRects[0];
-    const UIPoint closeCenter = RectCenter(closeRect);
+    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
+    ASSERT_NE(documentStack, nullptr);
+    const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
+    const UIPoint dropPoint(
+        documentStack->tabStripLayout.headerRect.x +
+            documentStack->tabStripLayout.headerRect.width - 2.0f,
+        sourceCenter.y);

    frame = UpdateUIEditorDockHostInteraction(
        state,
        controller,
        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
-        { MakePointerMove(closeCenter.x, closeCenter.y) });
-    EXPECT_EQ(frame.result.hitTarget.kind, UIEditorDockHostHitTargetKind::TabCloseButton);
-    EXPECT_EQ(frame.result.hitTarget.panelId, "console");
-
-    frame = UpdateUIEditorDockHostInteraction(
-        state,
-        controller,
-        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
-        { MakePointerUp(closeCenter.x, closeCenter.y) });
+        { MakePointerDown(sourceCenter.x, sourceCenter.y) });
    EXPECT_TRUE(frame.result.consumed);
-    EXPECT_TRUE(frame.result.commandExecuted);

-    const auto* panelState = FindUIEditorPanelSessionState(controller.GetSession(), "console");
-    ASSERT_NE(panelState, nullptr);
-    EXPECT_FALSE(panelState->open);
-    EXPECT_FALSE(panelState->visible);
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerMove(dropPoint.x, dropPoint.y) });
+    EXPECT_TRUE(frame.result.requestPointerCapture);
+    EXPECT_TRUE(frame.result.consumed);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerUp(dropPoint.x, dropPoint.y) });
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.layoutChanged)
+        << " status=" << static_cast<int>(frame.result.layoutResult.status)
+        << " message=" << frame.result.layoutResult.message
+        << " commandExecuted=" << frame.result.commandExecuted;
+
+    const auto* documentTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
+    ASSERT_NE(documentTabs, nullptr);
+    ASSERT_EQ(documentTabs->children.size(), 2u);
+    EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-b");
+    EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-a");
+}
+
+TEST(UIEditorDockHostInteractionTest, DraggingRightmostTabIntoMiddleCommitsSameStackReorder) {
+    auto controller =
+        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildThreeDocumentWorkspace());
+    UIEditorDockHostInteractionState state = {};
+
+    auto frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {});
+    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
+    ASSERT_NE(documentStack, nullptr);
+    const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[2]);
+    const UIPoint dropPoint(
+        documentStack->tabStripLayout.tabHeaderRects[1].x + 4.0f,
+        sourceCenter.y);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerDown(sourceCenter.x, sourceCenter.y) });
+    EXPECT_TRUE(frame.result.consumed);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerMove(dropPoint.x, dropPoint.y) });
+    EXPECT_TRUE(frame.result.requestPointerCapture);
+    EXPECT_TRUE(frame.result.consumed);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerUp(dropPoint.x, dropPoint.y) });
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.layoutChanged)
+        << " status=" << static_cast<int>(frame.result.layoutResult.status)
+        << " message=" << frame.result.layoutResult.message
+        << " commandExecuted=" << frame.result.commandExecuted;
+
+    const auto* documentTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
+    ASSERT_NE(documentTabs, nullptr);
+    ASSERT_EQ(documentTabs->children.size(), 3u);
+    EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-a");
+    EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-c");
+    EXPECT_EQ(documentTabs->children[2].panel.panelId, "doc-b");
+}
+
+TEST(UIEditorDockHostInteractionTest, DraggingRightmostTabToFrontCommitsSameStackReorder) {
+    auto controller =
+        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildThreeDocumentWorkspace());
+    UIEditorDockHostInteractionState state = {};
+
+    auto frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {});
+    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
+    ASSERT_NE(documentStack, nullptr);
+    const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[2]);
+    const UIPoint dropPoint(
+        documentStack->tabStripLayout.tabHeaderRects[0].x + 4.0f,
+        sourceCenter.y);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerDown(sourceCenter.x, sourceCenter.y) });
+    EXPECT_TRUE(frame.result.consumed);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerMove(dropPoint.x, dropPoint.y) });
+    EXPECT_TRUE(frame.result.requestPointerCapture);
+    EXPECT_TRUE(frame.result.consumed);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerUp(dropPoint.x, dropPoint.y) });
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.layoutChanged);
+
+    const auto* documentTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
+    ASSERT_NE(documentTabs, nullptr);
+    ASSERT_EQ(documentTabs->children.size(), 3u);
+    EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-c");
+    EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-a");
+    EXPECT_EQ(documentTabs->children[2].panel.panelId, "doc-b");
+}
+
+TEST(UIEditorDockHostInteractionTest, SameStackReorderCommitsFromLastVisiblePreviewEvenIfReleaseDropsBelowHeader) {
+    auto controller =
+        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
+    UIEditorDockHostInteractionState state = {};
+
+    auto frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {});
+    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
+    ASSERT_NE(documentStack, nullptr);
+    const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
+    const UIPoint previewPoint(
+        documentStack->tabStripLayout.headerRect.x +
+            documentStack->tabStripLayout.headerRect.width - 2.0f,
+        sourceCenter.y);
+    const UIPoint releasePoint(
+        previewPoint.x,
+        documentStack->tabStripLayout.headerRect.y +
+            documentStack->tabStripLayout.headerRect.height + 8.0f);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerDown(sourceCenter.x, sourceCenter.y) });
+    EXPECT_TRUE(frame.result.consumed);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerMove(previewPoint.x, previewPoint.y) });
+    EXPECT_TRUE(frame.result.requestPointerCapture);
+    EXPECT_TRUE(frame.result.consumed);
+    const auto tabStripStateIt = std::find_if(
+        state.dockHostState.tabStripStates.begin(),
+        state.dockHostState.tabStripStates.end(),
+        [](const auto& tabStripState) {
+            return tabStripState.nodeId == "document-tabs";
+        });
+    ASSERT_NE(tabStripStateIt, state.dockHostState.tabStripStates.end());
+    ASSERT_NE(
+        tabStripStateIt->state.reorder.previewInsertionIndex,
+        XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerUp(releasePoint.x, releasePoint.y) });
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.layoutChanged);
+
+    const auto* documentTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
+    ASSERT_NE(documentTabs, nullptr);
+    ASSERT_EQ(documentTabs->children.size(), 2u);
+    EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-b");
+    EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-a");
+}
+
+TEST(UIEditorDockHostInteractionTest, ReleasingDraggedTabOutsideHeaderCancelsWithoutChangingOrder) {
+    auto controller =
+        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
+    UIEditorDockHostInteractionState state = {};
+
+    auto frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {});
+    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
+    ASSERT_NE(documentStack, nullptr);
+    const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
+    const UIPoint activatePoint(
+        documentStack->tabStripLayout.headerRect.x +
+            documentStack->tabStripLayout.headerRect.width - 2.0f,
+        sourceCenter.y);
+    const UIPoint cancelPoint = RectCenter(documentStack->contentFrameLayout.bodyRect);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(activatePoint.x, activatePoint.y),
+            MakePointerMove(cancelPoint.x, cancelPoint.y),
+            MakePointerUp(cancelPoint.x, cancelPoint.y)
+        });
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_FALSE(frame.result.layoutChanged);
+
+    const auto* documentTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
+    ASSERT_NE(documentTabs, nullptr);
+    ASSERT_EQ(documentTabs->children.size(), 2u);
+    EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-a");
+    EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-b");
+}
+
+TEST(UIEditorDockHostInteractionTest, DraggingTabOntoAnotherStackHeaderMergesIntoTargetStack) {
+    auto controller =
+        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
+    UIEditorDockHostInteractionState state = {};
+
+    auto frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {});
+    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
+    const auto* detailsStack = FindTabStackByNodeId(frame.layout, "details-node");
+    ASSERT_NE(documentStack, nullptr);
+    ASSERT_NE(detailsStack, nullptr);
+    const UIPoint sourceCenter =
+        RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
+    const UIPoint targetHeaderCenter =
+        RectCenter(detailsStack->tabStripLayout.headerRect);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerDown(sourceCenter.x, sourceCenter.y) });
+    EXPECT_TRUE(frame.result.consumed);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerMove(targetHeaderCenter.x, targetHeaderCenter.y) });
+    EXPECT_TRUE(frame.result.requestPointerCapture);
+    EXPECT_TRUE(state.dockHostState.dropPreview.visible);
+    EXPECT_EQ(state.dockHostState.dropPreview.targetNodeId, "details-node");
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerUp(targetHeaderCenter.x, targetHeaderCenter.y) });
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.layoutChanged);
+
+    const auto* documentTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
+    const auto* detailsTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "details-node");
+    ASSERT_NE(documentTabs, nullptr);
+    ASSERT_NE(detailsTabs, nullptr);
+    ASSERT_EQ(documentTabs->children.size(), 1u);
+    ASSERT_EQ(detailsTabs->children.size(), 2u);
+    EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-b");
+    EXPECT_EQ(detailsTabs->children[1].panel.panelId, "doc-a");
+    EXPECT_EQ(controller.GetWorkspace().activePanelId, "doc-a");
+}
+
+TEST(UIEditorDockHostInteractionTest, DraggingTabOntoPanelBodyEdgeCreatesDockSplit) {
+    auto controller =
+        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
+    UIEditorDockHostInteractionState state = {};
+
+    auto frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {});
+    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
+    const auto* detailsStack = FindTabStackByNodeId(frame.layout, "details-node");
+    ASSERT_NE(documentStack, nullptr);
+    ASSERT_NE(detailsStack, nullptr);
+    const UIPoint sourceCenter =
+        RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
+    const UIPoint targetBottomCenter(
+        detailsStack->contentFrameLayout.bodyRect.x +
+            detailsStack->contentFrameLayout.bodyRect.width * 0.5f,
+        detailsStack->contentFrameLayout.bodyRect.y +
+            detailsStack->contentFrameLayout.bodyRect.height - 4.0f);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerDown(sourceCenter.x, sourceCenter.y) });
+    EXPECT_TRUE(frame.result.consumed);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerMove(targetBottomCenter.x, targetBottomCenter.y) });
+    EXPECT_TRUE(frame.result.requestPointerCapture);
+    EXPECT_TRUE(state.dockHostState.dropPreview.visible);
+    EXPECT_EQ(
+        state.dockHostState.dropPreview.placement,
+        XCEngine::UI::Editor::UIEditorWorkspaceDockPlacement::Bottom);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakePointerUp(targetBottomCenter.x, targetBottomCenter.y) });
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.layoutChanged);
+    EXPECT_EQ(controller.GetWorkspace().activePanelId, "doc-a");
+
+    bool foundDockedTab = false;
+    for (const std::string candidate : { "details-node__dock_doc-a_stack", "details-node__dock_doc-a_stack-1" }) {
+        const auto* docked =
+            FindUIEditorWorkspaceNode(controller.GetWorkspace(), candidate);
+        if (docked != nullptr &&
+            docked->children.size() == 1u &&
+            docked->children[0].panel.panelId == "doc-a") {
+            foundDockedTab = true;
+            break;
+        }
+    }
+    EXPECT_TRUE(foundDockedTab);
+}
+
+TEST(UIEditorDockHostInteractionTest, FocusLostWhileDraggingTabCancelsAndReleasesCapture) {
+    auto controller =
+        BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
+    UIEditorDockHostInteractionState state = {};
+
+    auto frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {});
+    const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
+    ASSERT_NE(documentStack, nullptr);
+    const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
+    const UIPoint activatePoint(
+        documentStack->tabStripLayout.headerRect.x +
+            documentStack->tabStripLayout.headerRect.width - 2.0f,
+        sourceCenter.y);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(activatePoint.x, activatePoint.y)
+        });
+    ASSERT_TRUE(frame.result.requestPointerCapture);
+
+    frame = UpdateUIEditorDockHostInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 800.0f, 600.0f),
+        { MakeFocusLost() });
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_FALSE(frame.result.layoutChanged);
+
+    const auto* documentTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
+    ASSERT_NE(documentTabs, nullptr);
+    ASSERT_EQ(documentTabs->children.size(), 2u);
+    EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-a");
+    EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-b");
 }
--- a/tests/UI/Editor/unit/test_ui_editor_menu_bar.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_menu_bar.cpp
@@ -96,12 +96,11 @@ TEST(UIEditorMenuBarTest, BackgroundAndForegroundEmitStableCommands) {

    UIDrawList background("MenuBarBackground");
    AppendUIEditorMenuBarBackground(background, layout, items, state);
-    ASSERT_EQ(background.GetCommandCount(), 6u);
+    ASSERT_EQ(background.GetCommandCount(), 3u);
    const auto& backgroundCommands = background.GetCommands();
    EXPECT_EQ(backgroundCommands[0].type, UIDrawCommandType::FilledRect);
-    EXPECT_EQ(backgroundCommands[1].type, UIDrawCommandType::RectOutline);
+    EXPECT_EQ(backgroundCommands[1].type, UIDrawCommandType::FilledRect);
    EXPECT_EQ(backgroundCommands[2].type, UIDrawCommandType::FilledRect);
-    EXPECT_EQ(backgroundCommands[5].type, UIDrawCommandType::RectOutline);

    UIDrawList foreground("MenuBarForeground");
    AppendUIEditorMenuBarForeground(foreground, layout, items, state);
--- a/tests/UI/Editor/unit/test_ui_editor_shell_interaction.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_shell_interaction.cpp
@@ -41,6 +41,8 @@ using XCEngine::UI::Editor::UIEditorShellInteractionModel;
 using XCEngine::UI::Editor::UIEditorShellInteractionPopupItemRequest;
 using XCEngine::UI::Editor::UIEditorShellInteractionServices;
 using XCEngine::UI::Editor::UIEditorShellInteractionState;
+using XCEngine::UI::Editor::UIEditorTextMeasureRequest;
+using XCEngine::UI::Editor::UIEditorTextMeasurer;
 using XCEngine::UI::Editor::UIEditorWorkspaceController;
 using XCEngine::UI::Editor::UIEditorWorkspaceCommandKind;
 using XCEngine::UI::Editor::UIEditorWorkspaceCommandStatus;
@@ -52,6 +54,13 @@ using XCEngine::UI::Editor::Widgets::UIEditorMenuPopupInvalidIndex;
 using XCEngine::UI::Editor::Widgets::UIEditorStatusBarSlot;
 using XCEngine::UI::Widgets::UIPopupDismissReason;

+class StubTextMeasurer final : public UIEditorTextMeasurer {
+public:
+    float MeasureTextWidth(const UIEditorTextMeasureRequest& request) const override {
+        return static_cast<float>(request.text.size()) * (request.fontSize * 0.6f);
+    }
+};
+
 UIEditorPanelRegistry BuildPanelRegistry() {
    UIEditorPanelRegistry registry = {};
    registry.panels = {
@@ -219,6 +228,76 @@ UIEditorWorkspaceController BuildController() {
    return BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
 }

+UIPoint RectCenter(const UIRect& rect);
+UIInputEvent MakeLeftPointerDown(const UIPoint& position);
+
+TEST(UIEditorShellInteractionTest, RequestUsesTextMeasurerForMenuBarWidths) {
+    UIEditorWorkspaceController controller = BuildController();
+    const UIEditorShellInteractionModel model = BuildInteractionModel();
+    StubTextMeasurer textMeasurer = {};
+    UIEditorShellInteractionServices services = {};
+    services.textMeasurer = &textMeasurer;
+
+    const auto request = ResolveUIEditorShellInteractionRequest(
+        UIRect(0.0f, 0.0f, 480.0f, 320.0f),
+        controller,
+        model,
+        {},
+        {},
+        services);
+
+    ASSERT_EQ(request.menuBarItems.size(), 2u);
+    EXPECT_FLOAT_EQ(
+        request.menuBarItems[0].desiredLabelWidth,
+        textMeasurer.MeasureTextWidth(UIEditorTextMeasureRequest { "File", 13.0f }));
+    EXPECT_FLOAT_EQ(
+        request.menuBarItems[1].desiredLabelWidth,
+        textMeasurer.MeasureTextWidth(UIEditorTextMeasureRequest { "Window", 13.0f }));
+    EXPECT_GT(request.menuButtons[1].rect.width, request.menuButtons[0].rect.width);
+}
+
+TEST(UIEditorShellInteractionTest, PopupWidgetWidthsUseTextMeasurerForLabelAndShortcut) {
+    UIEditorWorkspaceController controller = BuildController();
+    const UIEditorShellInteractionModel model = BuildInteractionModel();
+    StubTextMeasurer textMeasurer = {};
+    UIEditorShellInteractionServices services = {};
+    services.textMeasurer = &textMeasurer;
+
+    UIEditorShellInteractionState state = {};
+    const auto request = ResolveUIEditorShellInteractionRequest(
+        UIRect(0.0f, 0.0f, 480.0f, 320.0f),
+        controller,
+        model,
+        state,
+        {},
+        services);
+    ASSERT_FALSE(request.menuButtons.empty());
+
+    UIInputEvent openMenuEvent = {};
+    openMenuEvent.type = UIInputEventType::PointerButtonDown;
+    openMenuEvent.pointerButton = UIPointerButton::Left;
+    openMenuEvent.position = UIPoint(
+        request.menuButtons.front().rect.x + request.menuButtons.front().rect.width * 0.5f,
+        request.menuButtons.front().rect.y + request.menuButtons.front().rect.height * 0.5f);
+
+    const auto frame = UpdateUIEditorShellInteraction(
+        state,
+        controller,
+        UIRect(0.0f, 0.0f, 480.0f, 320.0f),
+        model,
+        std::vector<UIInputEvent> { openMenuEvent },
+        services);
+
+    ASSERT_EQ(frame.request.popupRequests.size(), 1u);
+    ASSERT_GE(frame.request.popupRequests.front().widgetItems.size(), 2u);
+    EXPECT_FLOAT_EQ(
+        frame.request.popupRequests.front().widgetItems[0].desiredLabelWidth,
+        textMeasurer.MeasureTextWidth(UIEditorTextMeasureRequest { "Workspace Tools", 13.0f }));
+    EXPECT_FLOAT_EQ(
+        frame.request.popupRequests.front().widgetItems[1].desiredShortcutWidth,
+        textMeasurer.MeasureTextWidth(UIEditorTextMeasureRequest { "Ctrl+W", 13.0f }));
+}
+
 const UIEditorShellInteractionMenuButtonRequest* FindMenuButton(
    const UIEditorShellInteractionFrame& frame,
    std::string_view menuId) {
--- a/tests/UI/Editor/unit/test_ui_editor_tab_strip.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_tab_strip.cpp
@@ -15,7 +15,6 @@ using XCEngine::UI::Editor::Widgets::BuildUIEditorTabStripLayout;
 using XCEngine::UI::Editor::Widgets::HitTestUIEditorTabStrip;
 using XCEngine::UI::Editor::Widgets::ResolveUIEditorTabStripDesiredHeaderLabelWidth;
 using XCEngine::UI::Editor::Widgets::ResolveUIEditorTabStripSelectedIndex;
-using XCEngine::UI::Editor::Widgets::ResolveUIEditorTabStripSelectedIndexAfterClose;
 using XCEngine::UI::Editor::Widgets::UIEditorTabStripHitTargetKind;
 using XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex;
 using XCEngine::UI::Editor::Widgets::UIEditorTabStripItem;
@@ -23,7 +22,7 @@ using XCEngine::UI::Editor::Widgets::UIEditorTabStripLayout;
 using XCEngine::UI::Editor::Widgets::UIEditorTabStripMetrics;
 using XCEngine::UI::Editor::Widgets::UIEditorTabStripState;

-TEST(UIEditorTabStripTest, DesiredHeaderWidthReservesCloseButtonBudget) {
+TEST(UIEditorTabStripTest, DesiredHeaderWidthUsesLabelWidthAndLeftInsetOnly) {
    UIEditorTabStripMetrics metrics = {};
    metrics.layoutMetrics.tabHorizontalPadding = 10.0f;
    metrics.estimatedGlyphWidth = 8.0f;
@@ -32,14 +31,14 @@ TEST(UIEditorTabStripTest, DesiredHeaderWidthReservesCloseButtonBudget) {
    metrics.closeInsetRight = 14.0f;
    metrics.labelInsetX = 12.0f;

-    const float closableWidth = ResolveUIEditorTabStripDesiredHeaderLabelWidth(
+    const float measuredWidth = ResolveUIEditorTabStripDesiredHeaderLabelWidth(
        UIEditorTabStripItem{ "doc-a", "ABCD", true, 0.0f },
        metrics);
    const float fixedWidth = ResolveUIEditorTabStripDesiredHeaderLabelWidth(
        UIEditorTabStripItem{ "doc-b", "Ignored", false, 42.0f },
        metrics);

-    EXPECT_FLOAT_EQ(closableWidth, 58.0f);
+    EXPECT_FLOAT_EQ(measuredWidth, 34.0f);
    EXPECT_FLOAT_EQ(fixedWidth, 44.0f);
 }

@@ -58,16 +57,7 @@ TEST(UIEditorTabStripTest, SelectedIndexResolvesByTabIdAndFallsBackToValidRange)
        UIEditorTabStripInvalidIndex);
 }

-TEST(UIEditorTabStripTest, ClosingTabsResolvesSelectionFallbackFromClosedIndex) {
-    EXPECT_EQ(ResolveUIEditorTabStripSelectedIndexAfterClose(1u, 1u, 3u), 1u);
-    EXPECT_EQ(ResolveUIEditorTabStripSelectedIndexAfterClose(2u, 2u, 3u), 1u);
-    EXPECT_EQ(ResolveUIEditorTabStripSelectedIndexAfterClose(2u, 0u, 3u), 1u);
-    EXPECT_EQ(
-        ResolveUIEditorTabStripSelectedIndexAfterClose(0u, 0u, 1u),
-        UIEditorTabStripInvalidIndex);
-}
-
-TEST(UIEditorTabStripTest, LayoutUsesCoreTabArrangementAndBuildsCloseRects) {
+TEST(UIEditorTabStripTest, LayoutUsesCoreTabArrangementWithoutCloseButtons) {
    UIEditorTabStripMetrics metrics = {};
    metrics.layoutMetrics.headerHeight = 30.0f;
    metrics.layoutMetrics.tabMinWidth = 80.0f;
@@ -101,20 +91,16 @@ TEST(UIEditorTabStripTest, LayoutUsesCoreTabArrangementAndBuildsCloseRects) {

    ASSERT_EQ(layout.tabHeaderRects.size(), 2u);
    EXPECT_FLOAT_EQ(layout.tabHeaderRects[0].x, 10.0f);
-    EXPECT_FLOAT_EQ(layout.tabHeaderRects[0].width, 90.0f);
-    EXPECT_FLOAT_EQ(layout.tabHeaderRects[1].x, 104.0f);
+    EXPECT_FLOAT_EQ(layout.tabHeaderRects[0].width, 80.0f);
+    EXPECT_FLOAT_EQ(layout.tabHeaderRects[1].x, 94.0f);
    EXPECT_FLOAT_EQ(layout.tabHeaderRects[1].width, 80.0f);

    ASSERT_EQ(layout.closeButtonRects.size(), 2u);
-    EXPECT_TRUE(layout.showCloseButtons[0]);
+    EXPECT_FALSE(layout.showCloseButtons[0]);
    EXPECT_FALSE(layout.showCloseButtons[1]);
-    EXPECT_FLOAT_EQ(layout.closeButtonRects[0].x, 76.0f);
-    EXPECT_FLOAT_EQ(layout.closeButtonRects[0].y, 29.0f);
-    EXPECT_FLOAT_EQ(layout.closeButtonRects[0].width, 12.0f);
-    EXPECT_FLOAT_EQ(layout.closeButtonRects[0].height, 12.0f);
 }

-TEST(UIEditorTabStripTest, HitTestPrioritizesCloseButtonThenTabThenContent) {
+TEST(UIEditorTabStripTest, HitTestPrioritizesTabThenHeaderThenContent) {
    const std::vector<UIEditorTabStripItem> items = {
        { "doc-a", "Document A", true, 48.0f },
        { "doc-b", "Document B", false, 40.0f }
@@ -125,14 +111,23 @@ TEST(UIEditorTabStripTest, HitTestPrioritizesCloseButtonThenTabThenContent) {
    const UIEditorTabStripLayout layout =
        BuildUIEditorTabStripLayout(UIRect(10.0f, 20.0f, 260.0f, 180.0f), items, state);

-    const auto closeHit = HitTestUIEditorTabStrip(layout, state, UIPoint(85.0f, 34.0f));
-    EXPECT_EQ(closeHit.kind, UIEditorTabStripHitTargetKind::CloseButton);
-    EXPECT_EQ(closeHit.index, 0u);
+    const auto rightSideTabHit = HitTestUIEditorTabStrip(
+        layout,
+        state,
+        UIPoint(
+            layout.tabHeaderRects[0].x + layout.tabHeaderRects[0].width - 2.0f,
+            layout.tabHeaderRects[0].y + layout.tabHeaderRects[0].height * 0.5f));
+    EXPECT_EQ(rightSideTabHit.kind, UIEditorTabStripHitTargetKind::Tab);
+    EXPECT_EQ(rightSideTabHit.index, 0u);

    const auto tabHit = HitTestUIEditorTabStrip(layout, state, UIPoint(40.0f, 34.0f));
    EXPECT_EQ(tabHit.kind, UIEditorTabStripHitTargetKind::Tab);
    EXPECT_EQ(tabHit.index, 0u);

+    const auto headerHit = HitTestUIEditorTabStrip(layout, state, UIPoint(200.0f, 34.0f));
+    EXPECT_EQ(headerHit.kind, UIEditorTabStripHitTargetKind::HeaderBackground);
+    EXPECT_EQ(headerHit.index, UIEditorTabStripInvalidIndex);
+
    const auto contentHit = HitTestUIEditorTabStrip(layout, state, UIPoint(40.0f, 70.0f));
    EXPECT_EQ(contentHit.kind, UIEditorTabStripHitTargetKind::Content);
    EXPECT_EQ(contentHit.index, UIEditorTabStripInvalidIndex);
@@ -147,7 +142,6 @@ TEST(UIEditorTabStripTest, BackgroundAndForegroundEmitStableChromeCommands) {
    UIEditorTabStripState state = {};
    state.selectedIndex = 0u;
    state.hoveredIndex = 1u;
-    state.closeHoveredIndex = 0u;
    state.focused = true;

    const UIEditorTabStripLayout layout =
@@ -155,24 +149,28 @@ TEST(UIEditorTabStripTest, BackgroundAndForegroundEmitStableChromeCommands) {

    UIDrawList background("TabStripBackground");
    AppendUIEditorTabStripBackground(background, layout, state);
-    ASSERT_EQ(background.GetCommandCount(), 8u);
+    ASSERT_EQ(background.GetCommandCount(), 9u);
    const auto& backgroundCommands = background.GetCommands();
    EXPECT_EQ(backgroundCommands[0].type, UIDrawCommandType::FilledRect);
    EXPECT_EQ(backgroundCommands[3].type, UIDrawCommandType::RectOutline);
    EXPECT_EQ(backgroundCommands[4].type, UIDrawCommandType::FilledRect);
-    EXPECT_EQ(backgroundCommands[7].type, UIDrawCommandType::RectOutline);
+    EXPECT_EQ(backgroundCommands[5].type, UIDrawCommandType::RectOutline);
+    EXPECT_EQ(backgroundCommands[6].type, UIDrawCommandType::FilledRect);
+    EXPECT_EQ(backgroundCommands[7].type, UIDrawCommandType::FilledRect);
+    EXPECT_EQ(backgroundCommands[8].type, UIDrawCommandType::RectOutline);

    UIDrawList foreground("TabStripForeground");
    AppendUIEditorTabStripForeground(foreground, layout, items, state);
-    ASSERT_EQ(foreground.GetCommandCount(), 9u);
+    ASSERT_EQ(foreground.GetCommandCount(), 8u);
    const auto& foregroundCommands = foreground.GetCommands();
-    EXPECT_EQ(foregroundCommands[0].type, UIDrawCommandType::PushClipRect);
-    EXPECT_EQ(foregroundCommands[1].type, UIDrawCommandType::Text);
-    EXPECT_EQ(foregroundCommands[1].text, "Document A");
-    EXPECT_EQ(foregroundCommands[5].type, UIDrawCommandType::Text);
-    EXPECT_EQ(foregroundCommands[5].text, "X");
-    EXPECT_EQ(foregroundCommands[7].type, UIDrawCommandType::Text);
-    EXPECT_EQ(foregroundCommands[7].text, "Document B");
+    EXPECT_EQ(foregroundCommands[0].type, UIDrawCommandType::FilledRect);
+    EXPECT_EQ(foregroundCommands[1].type, UIDrawCommandType::FilledRect);
+    EXPECT_EQ(foregroundCommands[2].type, UIDrawCommandType::PushClipRect);
+    EXPECT_EQ(foregroundCommands[3].type, UIDrawCommandType::Text);
+    EXPECT_EQ(foregroundCommands[3].text, "Document A");
+    EXPECT_EQ(foregroundCommands[5].type, UIDrawCommandType::PushClipRect);
+    EXPECT_EQ(foregroundCommands[6].type, UIDrawCommandType::Text);
+    EXPECT_EQ(foregroundCommands[6].text, "Document B");
 }

 } // namespace
--- a/tests/UI/Editor/unit/test_ui_editor_tab_strip_interaction.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_tab_strip_interaction.cpp
@@ -15,6 +15,7 @@ using XCEngine::UI::UIRect;
 using XCEngine::UI::Editor::UIEditorTabStripInteractionState;
 using XCEngine::UI::Editor::UpdateUIEditorTabStripInteraction;
 using XCEngine::UI::Editor::Widgets::UIEditorTabStripHitTargetKind;
+using XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex;
 using XCEngine::UI::Editor::Widgets::UIEditorTabStripItem;

 std::vector<UIEditorTabStripItem> BuildTabItems() {
@@ -73,7 +74,7 @@ UIPoint RectCenter(const XCEngine::UI::UIRect& rect) {

 } // namespace

-TEST(UIEditorTabStripInteractionTest, PointerMoveUpdatesHoveredTabAndCloseState) {
+TEST(UIEditorTabStripInteractionTest, PointerMoveUpdatesHoveredTabOnly) {
    const auto items = BuildTabItems();
    std::string selectedTabId = "doc-a";
    UIEditorTabStripInteractionState state = {};
@@ -85,7 +86,7 @@ TEST(UIEditorTabStripInteractionTest, PointerMoveUpdatesHoveredTabAndCloseState)
        items,
        {});

-    auto frame = UpdateUIEditorTabStripInteraction(
+    const auto frame = UpdateUIEditorTabStripInteraction(
        state,
        selectedTabId,
        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
@@ -93,21 +94,11 @@ TEST(UIEditorTabStripInteractionTest, PointerMoveUpdatesHoveredTabAndCloseState)
        { MakePointerMove(
            initialFrame.layout.tabHeaderRects[1].x + 12.0f,
            initialFrame.layout.tabHeaderRects[1].y + 12.0f) });
+
    EXPECT_EQ(frame.result.hitTarget.kind, UIEditorTabStripHitTargetKind::Tab);
    EXPECT_EQ(state.tabStripState.hoveredIndex, 1u);
-    EXPECT_EQ(state.tabStripState.closeHoveredIndex, XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex);
-
-    frame = UpdateUIEditorTabStripInteraction(
-        state,
-        selectedTabId,
-        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
-        items,
-        { MakePointerMove(
-            initialFrame.layout.closeButtonRects[0].x + 4.0f,
-            initialFrame.layout.closeButtonRects[0].y + 4.0f) });
-    EXPECT_EQ(frame.result.hitTarget.kind, UIEditorTabStripHitTargetKind::CloseButton);
-    EXPECT_EQ(state.tabStripState.hoveredIndex, 0u);
-    EXPECT_EQ(state.tabStripState.closeHoveredIndex, 0u);
+    EXPECT_EQ(state.tabStripState.closeHoveredIndex, UIEditorTabStripInvalidIndex);
+    EXPECT_FALSE(frame.result.closeRequested);
 }

 TEST(UIEditorTabStripInteractionTest, LeftClickTabSelectsAndFocusesStrip) {
@@ -141,38 +132,6 @@ TEST(UIEditorTabStripInteractionTest, LeftClickTabSelectsAndFocusesStrip) {
    EXPECT_TRUE(state.tabStripState.focused);
 }

-TEST(UIEditorTabStripInteractionTest, LeftClickCloseButtonRequestsCloseWithoutChangingSelection) {
-    const auto items = BuildTabItems();
-    std::string selectedTabId = "doc-a";
-    UIEditorTabStripInteractionState state = {};
-
-    const auto initialFrame = UpdateUIEditorTabStripInteraction(
-        state,
-        selectedTabId,
-        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
-        items,
-        {});
-    const UIPoint closeCenter = RectCenter(initialFrame.layout.closeButtonRects[1]);
-
-    const auto frame = UpdateUIEditorTabStripInteraction(
-        state,
-        selectedTabId,
-        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
-        items,
-        {
-            MakePointerDown(closeCenter.x, closeCenter.y),
-            MakePointerUp(closeCenter.x, closeCenter.y)
-        });
-
-    EXPECT_TRUE(frame.result.consumed);
-    EXPECT_TRUE(frame.result.closeRequested);
-    EXPECT_FALSE(frame.result.selectionChanged);
-    EXPECT_EQ(frame.result.closedTabId, "doc-b");
-    EXPECT_EQ(frame.result.closedIndex, 1u);
-    EXPECT_EQ(selectedTabId, "doc-a");
-    EXPECT_TRUE(state.tabStripState.focused);
-}
-
 TEST(UIEditorTabStripInteractionTest, KeyboardNavigationMovesSelectionWhenFocused) {
    const auto items = BuildTabItems();
    std::string selectedTabId = "doc-b";
@@ -238,7 +197,377 @@ TEST(UIEditorTabStripInteractionTest, OutsideClickAndFocusLostClearFocusAndHover
        items,
        { MakePointerLeave(), MakeFocusLost() });
    EXPECT_FALSE(state.tabStripState.focused);
-    EXPECT_EQ(state.tabStripState.hoveredIndex, XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex);
-    EXPECT_EQ(state.tabStripState.closeHoveredIndex, XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex);
+    EXPECT_EQ(state.tabStripState.hoveredIndex, UIEditorTabStripInvalidIndex);
+    EXPECT_EQ(state.tabStripState.closeHoveredIndex, UIEditorTabStripInvalidIndex);
    EXPECT_FALSE(state.hasPointerPosition);
 }
+
+TEST(UIEditorTabStripInteractionTest, DraggingTabRequestsPointerCaptureAndShowsInsertionPreview) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-a";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[0]);
+    const auto& lastRect = initialFrame.layout.tabHeaderRects.back();
+    const UIPoint dragPoint(lastRect.x + lastRect.width - 2.0f, sourceCenter.y);
+
+    const auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(dragPoint.x, dragPoint.y)
+        });
+
+    EXPECT_TRUE(frame.result.requestPointerCapture);
+    EXPECT_TRUE(frame.result.dragStarted);
+    EXPECT_TRUE(frame.result.consumed);
+    EXPECT_EQ(frame.result.draggedTabId, "doc-a");
+    EXPECT_EQ(frame.result.dragSourceIndex, 0u);
+    EXPECT_EQ(frame.result.dropInsertionIndex, items.size());
+    EXPECT_EQ(frame.result.reorderToIndex, 2u);
+    EXPECT_TRUE(frame.result.reorderPreviewActive);
+    EXPECT_EQ(frame.result.reorderPreviewIndex, 2u);
+    EXPECT_TRUE(state.reorderCaptureActive);
+    EXPECT_EQ(state.reorderSourceIndex, 0u);
+    EXPECT_EQ(state.reorderPreviewIndex, 2u);
+    EXPECT_TRUE(frame.layout.insertionPreview.visible);
+    EXPECT_EQ(frame.layout.insertionPreview.insertionIndex, items.size());
+}
+
+TEST(UIEditorTabStripInteractionTest, DroppingDraggedTabEmitsSameStackReorderRequest) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-a";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[0]);
+    const auto& lastRect = initialFrame.layout.tabHeaderRects.back();
+    const UIPoint dragPoint(lastRect.x + lastRect.width - 2.0f, sourceCenter.y);
+
+    const auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(dragPoint.x, dragPoint.y),
+            MakePointerUp(dragPoint.x, dragPoint.y)
+        });
+
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.dragEnded);
+    EXPECT_TRUE(frame.result.reorderRequested);
+    EXPECT_FALSE(frame.result.dragCanceled);
+    EXPECT_EQ(frame.result.draggedTabId, "doc-a");
+    EXPECT_EQ(frame.result.dragSourceIndex, 0u);
+    EXPECT_EQ(frame.result.dropInsertionIndex, items.size());
+    EXPECT_EQ(frame.result.reorderToIndex, 2u);
+    EXPECT_FALSE(state.reorderCaptureActive);
+    EXPECT_EQ(state.reorderSourceIndex, UIEditorTabStripInvalidIndex);
+    EXPECT_EQ(state.reorderPreviewIndex, UIEditorTabStripInvalidIndex);
+    EXPECT_FALSE(frame.layout.insertionPreview.visible);
+}
+
+TEST(UIEditorTabStripInteractionTest, DroppingRightmostTabToFrontCommitsReorderRequest) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-c";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[2]);
+    const UIPoint dropPoint(
+        initialFrame.layout.tabHeaderRects[0].x + 4.0f,
+        sourceCenter.y);
+
+    const auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(dropPoint.x, dropPoint.y),
+            MakePointerUp(dropPoint.x, dropPoint.y)
+        });
+
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.dragEnded);
+    EXPECT_TRUE(frame.result.reorderRequested);
+    EXPECT_FALSE(frame.result.dragCanceled);
+    EXPECT_EQ(frame.result.draggedTabId, "doc-c");
+    EXPECT_EQ(frame.result.dragSourceIndex, 2u);
+    EXPECT_EQ(frame.result.dropInsertionIndex, 0u);
+    EXPECT_EQ(frame.result.reorderToIndex, 0u);
+}
+
+TEST(UIEditorTabStripInteractionTest, DroppingRightmostTabIntoMiddleCommitsReorderRequest) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-c";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[2]);
+    const UIPoint dropPoint(
+        initialFrame.layout.tabHeaderRects[1].x + 4.0f,
+        sourceCenter.y);
+
+    const auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(dropPoint.x, dropPoint.y),
+            MakePointerUp(dropPoint.x, dropPoint.y)
+        });
+
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.dragEnded);
+    EXPECT_TRUE(frame.result.reorderRequested);
+    EXPECT_FALSE(frame.result.dragCanceled);
+    EXPECT_EQ(frame.result.draggedTabId, "doc-c");
+    EXPECT_EQ(frame.result.dragSourceIndex, 2u);
+    EXPECT_EQ(frame.result.dropInsertionIndex, 1u);
+    EXPECT_EQ(frame.result.reorderToIndex, 1u);
+}
+
+TEST(UIEditorTabStripInteractionTest, SeparateFrameDropOfRightmostTabIntoMiddleStillCommitsReorderRequest) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-c";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[2]);
+    const UIPoint dropPoint(
+        initialFrame.layout.tabHeaderRects[1].x + 4.0f,
+        sourceCenter.y);
+
+    auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(dropPoint.x, dropPoint.y)
+        });
+    ASSERT_TRUE(frame.result.requestPointerCapture);
+    ASSERT_TRUE(frame.result.reorderPreviewActive);
+    ASSERT_TRUE(state.reorderDragState.active);
+    ASSERT_FALSE(state.reorderDragState.targetId.empty());
+
+    frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        { MakePointerUp(dropPoint.x, dropPoint.y) });
+
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.dragEnded);
+    EXPECT_TRUE(frame.result.reorderRequested);
+    EXPECT_FALSE(frame.result.dragCanceled);
+    EXPECT_EQ(frame.result.draggedTabId, "doc-c");
+    EXPECT_EQ(frame.result.dragSourceIndex, 2u);
+    EXPECT_EQ(frame.result.dropInsertionIndex, 1u);
+    EXPECT_EQ(frame.result.reorderToIndex, 1u);
+}
+
+TEST(UIEditorTabStripInteractionTest, ReleasingOutsideHeaderStillCommitsLastVisibleReorderPreview) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-a";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[0]);
+    const auto& lastRect = initialFrame.layout.tabHeaderRects.back();
+    const UIPoint dragPoint(lastRect.x + lastRect.width - 2.0f, sourceCenter.y);
+    const UIPoint releasePoint(
+        dragPoint.x,
+        initialFrame.layout.headerRect.y + initialFrame.layout.headerRect.height + 8.0f);
+
+    auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(dragPoint.x, dragPoint.y)
+        });
+    ASSERT_TRUE(frame.result.reorderPreviewActive);
+    ASSERT_EQ(state.tabStripState.reorder.previewInsertionIndex, items.size());
+
+    frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        { MakePointerUp(releasePoint.x, releasePoint.y) });
+
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_TRUE(frame.result.dragEnded);
+    EXPECT_TRUE(frame.result.reorderRequested);
+    EXPECT_FALSE(frame.result.dragCanceled);
+    EXPECT_EQ(frame.result.draggedTabId, "doc-a");
+    EXPECT_EQ(frame.result.dragSourceIndex, 0u);
+    EXPECT_EQ(frame.result.dropInsertionIndex, items.size());
+    EXPECT_EQ(frame.result.reorderToIndex, 2u);
+}
+
+TEST(UIEditorTabStripInteractionTest, EscapeCancelsActiveTabDragAndReleasesCapture) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-a";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[1]);
+    const UIPoint dragPoint(
+        initialFrame.layout.tabHeaderRects[2].x + 8.0f,
+        sourceCenter.y);
+
+    auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(dragPoint.x, dragPoint.y)
+        });
+    ASSERT_TRUE(frame.result.dragStarted);
+    ASSERT_TRUE(state.reorderCaptureActive);
+
+    frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        { MakeKeyDown(KeyCode::Escape) });
+
+    EXPECT_TRUE(frame.result.dragCanceled);
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_FALSE(frame.result.reorderRequested);
+    EXPECT_EQ(frame.result.draggedTabId, "doc-b");
+    EXPECT_FALSE(state.reorderCaptureActive);
+    EXPECT_EQ(state.reorderSourceIndex, UIEditorTabStripInvalidIndex);
+}
+
+TEST(UIEditorTabStripInteractionTest, FocusLostCancelsActiveTabDragAndClearsPreview) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-a";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[0]);
+    const UIPoint dragPoint(
+        initialFrame.layout.tabHeaderRects[2].x + 8.0f,
+        sourceCenter.y);
+
+    auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(dragPoint.x, dragPoint.y)
+        });
+    ASSERT_TRUE(frame.result.dragStarted);
+    ASSERT_TRUE(frame.result.reorderPreviewActive);
+
+    frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        { MakeFocusLost() });
+
+    EXPECT_TRUE(frame.result.dragCanceled);
+    EXPECT_TRUE(frame.result.releasePointerCapture);
+    EXPECT_FALSE(frame.result.reorderRequested);
+    EXPECT_FALSE(state.tabStripState.focused);
+    EXPECT_FALSE(state.reorderCaptureActive);
+    EXPECT_EQ(state.reorderPreviewIndex, UIEditorTabStripInvalidIndex);
+    EXPECT_FALSE(frame.layout.insertionPreview.visible);
+}
+
+TEST(UIEditorTabStripInteractionTest, VisibleInsertionIndexTracksHeaderGapsInsteadOfFinalTabIndices) {
+    const auto items = BuildTabItems();
+    std::string selectedTabId = "doc-b";
+    UIEditorTabStripInteractionState state = {};
+
+    const auto initialFrame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {});
+    const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[1]);
+    const float betweenFirstAndSecond =
+        (initialFrame.layout.tabHeaderRects[0].x + initialFrame.layout.tabHeaderRects[0].width +
+            initialFrame.layout.tabHeaderRects[1].x) * 0.5f;
+
+    const auto frame = UpdateUIEditorTabStripInteraction(
+        state,
+        selectedTabId,
+        UIRect(0.0f, 0.0f, 320.0f, 180.0f),
+        items,
+        {
+            MakePointerDown(sourceCenter.x, sourceCenter.y),
+            MakePointerMove(betweenFirstAndSecond, sourceCenter.y)
+        });
+
+    EXPECT_TRUE(frame.result.requestPointerCapture);
+    EXPECT_TRUE(frame.result.reorderPreviewActive);
+    EXPECT_EQ(frame.result.dragSourceIndex, 1u);
+    EXPECT_EQ(frame.result.dropInsertionIndex, 1u);
+    EXPECT_EQ(frame.result.reorderToIndex, 1u);
+    EXPECT_EQ(frame.result.reorderPreviewIndex, 1u);
+}
--- a/tests/UI/Editor/unit/test_ui_editor_viewport_shell.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_viewport_shell.cpp
@@ -37,9 +37,9 @@ TEST(UIEditorViewportShellTest, ResolveRequestUsesViewportInputRectSize) {
        spec);

    EXPECT_FLOAT_EQ(request.slotLayout.inputRect.width, 800.0f);
-    EXPECT_FLOAT_EQ(request.slotLayout.inputRect.height, 532.0f);
+    EXPECT_FLOAT_EQ(request.slotLayout.inputRect.height, 554.0f);
    EXPECT_FLOAT_EQ(request.requestedViewportSize.width, 800.0f);
-    EXPECT_FLOAT_EQ(request.requestedViewportSize.height, 532.0f);
+    EXPECT_FLOAT_EQ(request.requestedViewportSize.height, 554.0f);
 }

 TEST(UIEditorViewportShellTest, ResolveRequestTracksChromeBarVisibility) {
--- a/tests/UI/Editor/unit/test_ui_editor_viewport_slot.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_viewport_slot.cpp
@@ -92,7 +92,7 @@ TEST(UIEditorViewportSlotTest, DesiredToolWidthUsesExplicitValueBeforeEstimatedL
    inferredWidth.label = "Scene";

    EXPECT_FLOAT_EQ(ResolveUIEditorViewportSlotDesiredToolWidth(explicitWidth), 88.0f);
-    EXPECT_FLOAT_EQ(ResolveUIEditorViewportSlotDesiredToolWidth(inferredWidth), 55.0f);
+    EXPECT_FLOAT_EQ(ResolveUIEditorViewportSlotDesiredToolWidth(inferredWidth), 48.5f);
 }

 TEST(UIEditorViewportSlotTest, LayoutBuildsTopBarSurfaceBottomBarAndAspectFittedTexture) {
@@ -142,12 +142,12 @@ TEST(UIEditorViewportSlotTest, ToolItemsAlignToEdgesAndTitleRectClampsBetweenToo
            BuildToolItems(),
            {});

-    EXPECT_FLOAT_EQ(layout.toolItemRects[0].x, 12.0f);
+    EXPECT_FLOAT_EQ(layout.toolItemRects[0].x, 8.0f);
    EXPECT_FLOAT_EQ(layout.toolItemRects[0].width, 96.0f);
-    EXPECT_FLOAT_EQ(layout.toolItemRects[1].x, 762.0f);
-    EXPECT_FLOAT_EQ(layout.toolItemRects[2].x, 816.0f);
-    EXPECT_FLOAT_EQ(layout.titleRect.x, 118.0f);
-    EXPECT_FLOAT_EQ(layout.titleRect.width, 634.0f);
+    EXPECT_FLOAT_EQ(layout.toolItemRects[1].x, 768.0f);
+    EXPECT_FLOAT_EQ(layout.toolItemRects[2].x, 820.0f);
+    EXPECT_FLOAT_EQ(layout.titleRect.x, 110.0f);
+    EXPECT_FLOAT_EQ(layout.titleRect.width, 652.0f);
 }

 TEST(UIEditorViewportSlotTest, HitTestPrioritizesToolThenStatusThenSurface) {
--- a/tests/UI/Editor/unit/test_ui_editor_workspace_controller.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_workspace_controller.cpp
@@ -2,6 +2,8 @@

 #include <XCEditor/Shell/UIEditorWorkspaceController.h>

+#include <string>
+
 namespace {

 using XCEngine::UI::Editor::BuildDefaultUIEditorWorkspaceController;
@@ -9,6 +11,9 @@ using XCEngine::UI::Editor::BuildDefaultUIEditorWorkspaceSession;
 using XCEngine::UI::Editor::BuildUIEditorWorkspacePanel;
 using XCEngine::UI::Editor::BuildUIEditorWorkspaceSplit;
 using XCEngine::UI::Editor::BuildUIEditorWorkspaceTabStack;
+using XCEngine::UI::Editor::AreUIEditorWorkspaceModelsEquivalent;
+using XCEngine::UI::Editor::FindUIEditorPanelSessionState;
+using XCEngine::UI::Editor::FindUIEditorWorkspaceNode;
 using XCEngine::UI::Editor::GetUIEditorWorkspaceCommandKindName;
 using XCEngine::UI::Editor::GetUIEditorWorkspaceCommandStatusName;
 using XCEngine::UI::Editor::UIEditorPanelRegistry;
@@ -17,7 +22,11 @@ using XCEngine::UI::Editor::UIEditorWorkspaceCommandKind;
 using XCEngine::UI::Editor::UIEditorWorkspaceCommandStatus;
 using XCEngine::UI::Editor::UIEditorWorkspaceControllerValidationCode;
 using XCEngine::UI::Editor::UIEditorWorkspaceController;
+using XCEngine::UI::Editor::UIEditorWorkspaceDockPlacement;
+using XCEngine::UI::Editor::UIEditorWorkspaceLayoutOperationStatus;
 using XCEngine::UI::Editor::UIEditorWorkspaceModel;
+using XCEngine::UI::Editor::UIEditorWorkspaceNode;
+using XCEngine::UI::Editor::UIEditorWorkspaceSession;
 using XCEngine::UI::Editor::UIEditorWorkspaceSplitAxis;

 UIEditorPanelRegistry BuildPanelRegistry() {
@@ -25,6 +34,9 @@ UIEditorPanelRegistry BuildPanelRegistry() {
    registry.panels = {
        { "doc-a", "Document A", {}, true, true, true },
        { "doc-b", "Document B", {}, true, true, true },
+        { "doc-c", "Document C", {}, true, true, true },
+        { "hidden-a", "Hidden A", {}, true, true, true },
+        { "hidden-b", "Hidden B", {}, true, true, true },
        { "details", "Details", {}, true, true, true },
        { "root", "Root", {}, true, false, false }
    };
@@ -49,6 +61,34 @@ UIEditorWorkspaceModel BuildWorkspace() {
    return workspace;
 }

+UIEditorWorkspaceModel BuildReorderWorkspace() {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceTabStack(
+        "document-tabs",
+        {
+            BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+            BuildUIEditorWorkspacePanel("hidden-a-node", "hidden-a", "Hidden A", true),
+            BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true),
+            BuildUIEditorWorkspacePanel("hidden-b-node", "hidden-b", "Hidden B", true),
+            BuildUIEditorWorkspacePanel("doc-c-node", "doc-c", "Document C", true)
+        },
+        2u);
+    workspace.activePanelId = "doc-b";
+    return workspace;
+}
+
+UIEditorWorkspaceSession BuildReorderSession() {
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "doc-a", true, true },
+        { "hidden-a", true, false },
+        { "doc-b", true, true },
+        { "hidden-b", true, false },
+        { "doc-c", true, true }
+    };
+    return session;
+}
+
 } // namespace

 TEST(UIEditorWorkspaceControllerTest, CommandNameHelpersExposeStableDebugNames) {
@@ -146,3 +186,201 @@ TEST(UIEditorWorkspaceControllerTest, RejectsUnknownPanelAndNonCloseablePanelCom
    EXPECT_EQ(nonCloseable.status, UIEditorWorkspaceCommandStatus::Rejected);
    EXPECT_EQ(rootController.GetWorkspace().activePanelId, "root");
 }
+
+TEST(UIEditorWorkspaceControllerTest, ReorderTabUsesModelSurgeryAndPreservesSelectionActiveAndSession) {
+    UIEditorWorkspaceController controller(
+        BuildPanelRegistry(),
+        BuildReorderWorkspace(),
+        BuildReorderSession());
+
+    const auto result = controller.ReorderTab("document-tabs", "doc-c", 0u);
+    EXPECT_EQ(result.status, UIEditorWorkspaceLayoutOperationStatus::Changed);
+    EXPECT_EQ(result.activePanelId, "doc-b");
+    ASSERT_EQ(result.visiblePanelIds.size(), 1u);
+    EXPECT_EQ(result.visiblePanelIds[0], "doc-b");
+
+    const UIEditorWorkspaceNode* tabStack =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
+    ASSERT_NE(tabStack, nullptr);
+    ASSERT_EQ(tabStack->children.size(), 5u);
+    EXPECT_EQ(tabStack->children[0].panel.panelId, "doc-c");
+    EXPECT_EQ(tabStack->children[1].panel.panelId, "hidden-a");
+    EXPECT_EQ(tabStack->children[2].panel.panelId, "doc-a");
+    EXPECT_EQ(tabStack->children[3].panel.panelId, "hidden-b");
+    EXPECT_EQ(tabStack->children[4].panel.panelId, "doc-b");
+    EXPECT_EQ(tabStack->selectedTabIndex, 4u);
+
+    const auto* hiddenState =
+        FindUIEditorPanelSessionState(controller.GetSession(), "hidden-a");
+    ASSERT_NE(hiddenState, nullptr);
+    EXPECT_TRUE(hiddenState->open);
+    EXPECT_FALSE(hiddenState->visible);
+}
+
+TEST(UIEditorWorkspaceControllerTest, ReorderTabRejectsHiddenPanelsAndOutOfRangeTargetsAndReportsNoOp) {
+    UIEditorWorkspaceController controller(
+        BuildPanelRegistry(),
+        BuildReorderWorkspace(),
+        BuildReorderSession());
+
+    const auto hidden = controller.ReorderTab("document-tabs", "hidden-a", 0u);
+    EXPECT_EQ(hidden.status, UIEditorWorkspaceLayoutOperationStatus::Rejected);
+
+    const auto outOfRange = controller.ReorderTab("document-tabs", "doc-a", 4u);
+    EXPECT_EQ(outOfRange.status, UIEditorWorkspaceLayoutOperationStatus::Rejected);
+
+    const auto noOp = controller.ReorderTab("document-tabs", "doc-a", 0u);
+    EXPECT_EQ(noOp.status, UIEditorWorkspaceLayoutOperationStatus::NoOp);
+}
+
+TEST(UIEditorWorkspaceControllerTest, MoveTabToStackMovesVisibleTabAcrossStacks) {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceSplit(
+        "root-split",
+        UIEditorWorkspaceSplitAxis::Horizontal,
+        0.55f,
+        BuildUIEditorWorkspaceTabStack(
+            "left-tabs",
+            {
+                BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+                BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
+            },
+            0u),
+        BuildUIEditorWorkspacePanel("details-node", "details", "Details", true));
+    workspace.activePanelId = "doc-a";
+
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "doc-a", true, true },
+        { "doc-b", true, true },
+        { "details", true, true }
+    };
+
+    UIEditorWorkspaceController controller(BuildPanelRegistry(), workspace, session);
+
+    const auto result = controller.MoveTabToStack("left-tabs", "doc-b", "details-node", 1u);
+    EXPECT_EQ(result.status, UIEditorWorkspaceLayoutOperationStatus::Changed);
+    EXPECT_EQ(result.activePanelId, "doc-b");
+
+    const UIEditorWorkspaceNode* leftTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "left-tabs");
+    const UIEditorWorkspaceNode* detailsTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "details-node");
+    ASSERT_NE(leftTabs, nullptr);
+    ASSERT_NE(detailsTabs, nullptr);
+    ASSERT_EQ(leftTabs->children.size(), 1u);
+    ASSERT_EQ(detailsTabs->children.size(), 2u);
+    EXPECT_EQ(detailsTabs->children[1].panel.panelId, "doc-b");
+}
+
+TEST(UIEditorWorkspaceControllerTest, DockTabRelativeCreatesSplitAroundTargetStack) {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceSplit(
+        "root-split",
+        UIEditorWorkspaceSplitAxis::Horizontal,
+        0.55f,
+        BuildUIEditorWorkspaceTabStack(
+            "left-tabs",
+            {
+                BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+                BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
+            },
+            0u),
+        BuildUIEditorWorkspacePanel("details-node", "details", "Details", true));
+    workspace.activePanelId = "doc-a";
+
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "doc-a", true, true },
+        { "doc-b", true, true },
+        { "details", true, true }
+    };
+
+    UIEditorWorkspaceController controller(BuildPanelRegistry(), workspace, session);
+
+    const auto result = controller.DockTabRelative(
+        "left-tabs",
+        "doc-b",
+        "details-node",
+        UIEditorWorkspaceDockPlacement::Bottom,
+        0.4f);
+    EXPECT_EQ(result.status, UIEditorWorkspaceLayoutOperationStatus::Changed);
+    EXPECT_EQ(result.activePanelId, "doc-b");
+
+    const UIEditorWorkspaceNode* detailsTabs =
+        FindUIEditorWorkspaceNode(controller.GetWorkspace(), "details-node");
+    ASSERT_NE(detailsTabs, nullptr);
+    EXPECT_EQ(detailsTabs->kind, XCEngine::UI::Editor::UIEditorWorkspaceNodeKind::TabStack);
+
+    bool foundDockedTab = false;
+    for (const std::string candidate : { "details-node__dock_doc-b_stack", "details-node__dock_doc-b_stack-1" }) {
+        const UIEditorWorkspaceNode* docked =
+            FindUIEditorWorkspaceNode(controller.GetWorkspace(), candidate);
+        if (docked != nullptr) {
+            foundDockedTab = docked->children.size() == 1u &&
+                docked->children[0].panel.panelId == "doc-b";
+            if (foundDockedTab) {
+                break;
+            }
+        }
+    }
+    EXPECT_TRUE(foundDockedTab);
+}
+
+TEST(UIEditorWorkspaceControllerTest, DockTabRelativeReturnsNoOpWhenRedockingAlreadyDockedSingleTabStack) {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceSplit(
+        "root-split",
+        UIEditorWorkspaceSplitAxis::Horizontal,
+        0.55f,
+        BuildUIEditorWorkspaceTabStack(
+            "left-tabs",
+            {
+                BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+                BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
+            },
+            0u),
+        BuildUIEditorWorkspacePanel("details-node", "details", "Details", true));
+    workspace.activePanelId = "doc-a";
+
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "doc-a", true, true },
+        { "doc-b", true, true },
+        { "details", true, true }
+    };
+
+    UIEditorWorkspaceController controller(BuildPanelRegistry(), workspace, session);
+
+    const auto first = controller.DockTabRelative(
+        "left-tabs",
+        "doc-b",
+        "details-node",
+        UIEditorWorkspaceDockPlacement::Bottom,
+        0.4f);
+    ASSERT_EQ(first.status, UIEditorWorkspaceLayoutOperationStatus::Changed);
+
+    std::string movedStackId = {};
+    for (const std::string candidate : { "details-node__dock_doc-b_stack", "details-node__dock_doc-b_stack-1" }) {
+        if (FindUIEditorWorkspaceNode(controller.GetWorkspace(), candidate) != nullptr) {
+            movedStackId = candidate;
+            break;
+        }
+    }
+    ASSERT_FALSE(movedStackId.empty());
+
+    const UIEditorWorkspaceModel afterFirstDock = controller.GetWorkspace();
+
+    const auto second = controller.DockTabRelative(
+        movedStackId,
+        "doc-b",
+        "details-node",
+        UIEditorWorkspaceDockPlacement::Bottom,
+        0.4f);
+    EXPECT_EQ(second.status, UIEditorWorkspaceLayoutOperationStatus::NoOp);
+    EXPECT_EQ(second.activePanelId, "doc-b");
+    EXPECT_TRUE(
+        AreUIEditorWorkspaceModelsEquivalent(
+            controller.GetWorkspace(),
+            afterFirstDock));
+}
--- a/tests/UI/Editor/unit/test_ui_editor_workspace_model.cpp
+++ b/tests/UI/Editor/unit/test_ui_editor_workspace_model.cpp
@@ -1,6 +1,7 @@
 #include <gtest/gtest.h>

 #include <XCEditor/Shell/UIEditorWorkspaceModel.h>
+#include <XCEditor/Shell/UIEditorWorkspaceSession.h>

 #include <algorithm>
 #include <string>
@@ -12,17 +13,25 @@ using XCEngine::UI::Editor::BuildUIEditorWorkspacePanel;
 using XCEngine::UI::Editor::BuildUIEditorWorkspaceSingleTabStack;
 using XCEngine::UI::Editor::BuildUIEditorWorkspaceSplit;
 using XCEngine::UI::Editor::BuildUIEditorWorkspaceTabStack;
+using XCEngine::UI::Editor::AreUIEditorWorkspaceModelsEquivalent;
 using XCEngine::UI::Editor::CanonicalizeUIEditorWorkspaceModel;
 using XCEngine::UI::Editor::CollectUIEditorWorkspaceVisiblePanels;
 using XCEngine::UI::Editor::ContainsUIEditorWorkspacePanel;
 using XCEngine::UI::Editor::FindUIEditorWorkspaceActivePanel;
 using XCEngine::UI::Editor::FindUIEditorWorkspaceNode;
 using XCEngine::UI::Editor::TryActivateUIEditorWorkspacePanel;
+using XCEngine::UI::Editor::TryDockUIEditorWorkspaceTabRelative;
+using XCEngine::UI::Editor::TryMoveUIEditorWorkspaceTabToStack;
+using XCEngine::UI::Editor::TryReorderUIEditorWorkspaceTab;
 using XCEngine::UI::Editor::TrySetUIEditorWorkspaceSplitRatio;
+using XCEngine::UI::Editor::UIEditorWorkspaceDockPlacement;
 using XCEngine::UI::Editor::UIEditorWorkspaceModel;
+using XCEngine::UI::Editor::UIEditorWorkspaceNode;
+using XCEngine::UI::Editor::UIEditorWorkspaceSession;
 using XCEngine::UI::Editor::UIEditorWorkspaceNodeKind;
 using XCEngine::UI::Editor::UIEditorWorkspaceSplitAxis;
 using XCEngine::UI::Editor::UIEditorWorkspaceValidationCode;
+using XCEngine::UI::Editor::UIEditorWorkspaceVisiblePanel;
 using XCEngine::UI::Editor::ValidateUIEditorWorkspace;

 std::vector<std::string> CollectVisiblePanelIds(const UIEditorWorkspaceModel& workspace) {
@@ -170,6 +179,78 @@ TEST(UIEditorWorkspaceModelTest, SplitRatioMutationTargetsSplitNodeAndRejectsInv
    EXPECT_FALSE(TrySetUIEditorWorkspaceSplitRatio(workspace, "root-split", 1.0f));
 }

+TEST(UIEditorWorkspaceModelTest, ReorderTabMovesVisibleTabsAndPreservesHiddenOrderSelectionAndActivePanel) {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceTabStack(
+        "document-tabs",
+        {
+            BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+            BuildUIEditorWorkspacePanel("hidden-a-node", "hidden-a", "Hidden A", true),
+            BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true),
+            BuildUIEditorWorkspacePanel("hidden-b-node", "hidden-b", "Hidden B", true),
+            BuildUIEditorWorkspacePanel("doc-c-node", "doc-c", "Document C", true)
+        },
+        2u);
+    workspace.activePanelId = "doc-b";
+
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "doc-a", true, true },
+        { "hidden-a", true, false },
+        { "doc-b", true, true },
+        { "hidden-b", true, false },
+        { "doc-c", true, true }
+    };
+
+    ASSERT_TRUE(TryReorderUIEditorWorkspaceTab(
+        workspace,
+        session,
+        "document-tabs",
+        "doc-c",
+        0u));
+
+    const UIEditorWorkspaceNode* tabStack =
+        FindUIEditorWorkspaceNode(workspace, "document-tabs");
+    ASSERT_NE(tabStack, nullptr);
+    ASSERT_EQ(tabStack->children.size(), 5u);
+    EXPECT_EQ(tabStack->children[0].panel.panelId, "doc-c");
+    EXPECT_EQ(tabStack->children[1].panel.panelId, "hidden-a");
+    EXPECT_EQ(tabStack->children[2].panel.panelId, "doc-a");
+    EXPECT_EQ(tabStack->children[3].panel.panelId, "hidden-b");
+    EXPECT_EQ(tabStack->children[4].panel.panelId, "doc-b");
+    EXPECT_EQ(tabStack->selectedTabIndex, 4u);
+    EXPECT_EQ(workspace.activePanelId, "doc-b");
+
+    EXPECT_FALSE(TryReorderUIEditorWorkspaceTab(
+        workspace,
+        session,
+        "document-tabs",
+        "hidden-a",
+        0u));
+
+    ASSERT_TRUE(TryReorderUIEditorWorkspaceTab(
+        workspace,
+        session,
+        "document-tabs",
+        "doc-a",
+        3u));
+    tabStack = FindUIEditorWorkspaceNode(workspace, "document-tabs");
+    ASSERT_NE(tabStack, nullptr);
+    EXPECT_EQ(tabStack->children[0].panel.panelId, "doc-c");
+    EXPECT_EQ(tabStack->children[1].panel.panelId, "hidden-a");
+    EXPECT_EQ(tabStack->children[2].panel.panelId, "doc-b");
+    EXPECT_EQ(tabStack->children[3].panel.panelId, "hidden-b");
+    EXPECT_EQ(tabStack->children[4].panel.panelId, "doc-a");
+    EXPECT_EQ(tabStack->selectedTabIndex, 2u);
+
+    EXPECT_FALSE(TryReorderUIEditorWorkspaceTab(
+        workspace,
+        session,
+        "document-tabs",
+        "doc-a",
+        4u));
+}
+
 TEST(UIEditorWorkspaceModelTest, CanonicalizeWrapsStandalonePanelsIntoSingleTabStacks) {
    UIEditorWorkspaceModel workspace = {};
    workspace.root = BuildUIEditorWorkspaceSplit(
@@ -195,3 +276,254 @@ TEST(UIEditorWorkspaceModelTest, CanonicalizeWrapsStandalonePanelsIntoSingleTabS
        "left");
    EXPECT_EQ(canonicalWorkspace.root.children[1].kind, UIEditorWorkspaceNodeKind::TabStack);
 }
+
+TEST(UIEditorWorkspaceModelTest, MoveTabToStackMergesIntoTargetStackAndActivatesMovedPanel) {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceSplit(
+        "root-split",
+        UIEditorWorkspaceSplitAxis::Horizontal,
+        0.58f,
+        BuildUIEditorWorkspaceTabStack(
+            "left-tabs",
+            {
+                BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+                BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
+            },
+            0u),
+        BuildUIEditorWorkspaceSingleTabStack(
+            "right-tabs",
+            "details",
+            "Details",
+            true));
+    workspace.activePanelId = "doc-a";
+
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "doc-a", true, true },
+        { "doc-b", true, true },
+        { "details", true, true }
+    };
+
+    ASSERT_TRUE(TryMoveUIEditorWorkspaceTabToStack(
+        workspace,
+        session,
+        "left-tabs",
+        "doc-b",
+        "right-tabs",
+        1u));
+
+    const UIEditorWorkspaceNode* leftTabs =
+        FindUIEditorWorkspaceNode(workspace, "left-tabs");
+    const UIEditorWorkspaceNode* rightTabs =
+        FindUIEditorWorkspaceNode(workspace, "right-tabs");
+    ASSERT_NE(leftTabs, nullptr);
+    ASSERT_NE(rightTabs, nullptr);
+    ASSERT_EQ(leftTabs->children.size(), 1u);
+    ASSERT_EQ(rightTabs->children.size(), 2u);
+    EXPECT_EQ(leftTabs->children[0].panel.panelId, "doc-a");
+    EXPECT_EQ(rightTabs->children[0].panel.panelId, "details");
+    EXPECT_EQ(rightTabs->children[1].panel.panelId, "doc-b");
+    EXPECT_EQ(rightTabs->selectedTabIndex, 1u);
+    EXPECT_EQ(workspace.activePanelId, "doc-b");
+}
+
+TEST(UIEditorWorkspaceModelTest, DockTabRelativeSplitsTargetStackAndCreatesNewLeaf) {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceSplit(
+        "root-split",
+        UIEditorWorkspaceSplitAxis::Horizontal,
+        0.58f,
+        BuildUIEditorWorkspaceTabStack(
+            "left-tabs",
+            {
+                BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+                BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
+            },
+            0u),
+        BuildUIEditorWorkspaceSingleTabStack(
+            "right-tabs",
+            "details",
+            "Details",
+            true));
+    workspace.activePanelId = "doc-a";
+
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "doc-a", true, true },
+        { "doc-b", true, true },
+        { "details", true, true }
+    };
+
+    ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
+        workspace,
+        session,
+        "left-tabs",
+        "doc-b",
+        "right-tabs",
+        UIEditorWorkspaceDockPlacement::Bottom,
+        0.4f));
+
+    const UIEditorWorkspaceNode* rightTabs =
+        FindUIEditorWorkspaceNode(workspace, "right-tabs");
+    ASSERT_NE(rightTabs, nullptr);
+    ASSERT_EQ(rightTabs->kind, UIEditorWorkspaceNodeKind::TabStack);
+    ASSERT_EQ(rightTabs->children.size(), 1u);
+    EXPECT_EQ(rightTabs->children[0].panel.panelId, "details");
+
+    const UIEditorWorkspaceNode* movedTabStack = nullptr;
+    if (const UIEditorWorkspaceNode* rootSplit =
+            FindUIEditorWorkspaceNode(workspace, "root-split");
+        rootSplit != nullptr) {
+        const auto visibleIds = CollectVisiblePanelIds(workspace);
+        ASSERT_EQ(visibleIds.size(), 3u);
+        EXPECT_EQ(visibleIds[0], "doc-a");
+        EXPECT_EQ(visibleIds[1], "details");
+        EXPECT_EQ(visibleIds[2], "doc-b");
+    }
+
+    const std::vector<UIEditorWorkspaceVisiblePanel> visiblePanels =
+        CollectUIEditorWorkspaceVisiblePanels(workspace);
+    ASSERT_EQ(visiblePanels.size(), 3u);
+    EXPECT_EQ(visiblePanels[2].panelId, "doc-b");
+
+    for (const std::string candidate : { "right-tabs__dock_doc-b_stack", "right-tabs__dock_doc-b_stack-1" }) {
+        movedTabStack = FindUIEditorWorkspaceNode(workspace, candidate);
+        if (movedTabStack != nullptr) {
+            break;
+        }
+    }
+    ASSERT_NE(movedTabStack, nullptr);
+    ASSERT_EQ(movedTabStack->kind, UIEditorWorkspaceNodeKind::TabStack);
+    ASSERT_EQ(movedTabStack->children.size(), 1u);
+    EXPECT_EQ(movedTabStack->children[0].panel.panelId, "doc-b");
+    EXPECT_EQ(workspace.activePanelId, "doc-b");
+}
+
+TEST(UIEditorWorkspaceModelTest, DockTabRelativeCanRedockSingleTabBranchBackOntoSiblingStack) {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceTabStack(
+        "center-tabs",
+        {
+            BuildUIEditorWorkspacePanel("scene-node", "scene", "Scene", true),
+            BuildUIEditorWorkspacePanel("game-node", "game", "Game", true)
+        },
+        0u);
+    workspace.activePanelId = "scene";
+
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "scene", true, true },
+        { "game", true, true }
+    };
+
+    ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
+        workspace,
+        session,
+        "center-tabs",
+        "scene",
+        "center-tabs",
+        UIEditorWorkspaceDockPlacement::Top,
+        0.5f));
+
+    const UIEditorWorkspaceNode* firstDockStack =
+        FindUIEditorWorkspaceNode(workspace, "center-tabs__dock_scene_stack");
+    ASSERT_NE(firstDockStack, nullptr);
+    ASSERT_EQ(firstDockStack->kind, UIEditorWorkspaceNodeKind::TabStack);
+    ASSERT_EQ(firstDockStack->children.size(), 1u);
+    EXPECT_EQ(firstDockStack->children[0].panel.panelId, "scene");
+
+    ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
+        workspace,
+        session,
+        "center-tabs__dock_scene_stack",
+        "scene",
+        "center-tabs",
+        UIEditorWorkspaceDockPlacement::Top,
+        0.5f));
+
+    const auto validation = ValidateUIEditorWorkspace(workspace);
+    ASSERT_TRUE(validation.IsValid()) << validation.message;
+
+    const std::vector<UIEditorWorkspaceVisiblePanel> visiblePanels =
+        CollectUIEditorWorkspaceVisiblePanels(workspace);
+    ASSERT_EQ(visiblePanels.size(), 2u);
+    EXPECT_EQ(visiblePanels[0].panelId, "scene");
+    EXPECT_EQ(visiblePanels[1].panelId, "game");
+    EXPECT_EQ(workspace.activePanelId, "scene");
+}
+
+TEST(UIEditorWorkspaceModelTest, DockTabRelativeCanRedockGeneratedSingleTabStackWithoutChangingLayout) {
+    UIEditorWorkspaceModel workspace = {};
+    workspace.root = BuildUIEditorWorkspaceSplit(
+        "root-split",
+        UIEditorWorkspaceSplitAxis::Horizontal,
+        0.58f,
+        BuildUIEditorWorkspaceTabStack(
+            "left-tabs",
+            {
+                BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
+                BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
+            },
+            0u),
+        BuildUIEditorWorkspaceSingleTabStack(
+            "right-tabs",
+            "details",
+            "Details",
+            true));
+    workspace.activePanelId = "doc-a";
+
+    UIEditorWorkspaceSession session = {};
+    session.panelStates = {
+        { "doc-a", true, true },
+        { "doc-b", true, true },
+        { "details", true, true }
+    };
+
+    ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
+        workspace,
+        session,
+        "left-tabs",
+        "doc-b",
+        "right-tabs",
+        UIEditorWorkspaceDockPlacement::Bottom,
+        0.4f));
+
+    std::string movedStackId = {};
+    for (const std::string candidate : { "right-tabs__dock_doc-b_stack", "right-tabs__dock_doc-b_stack-1" }) {
+        if (FindUIEditorWorkspaceNode(workspace, candidate) != nullptr) {
+            movedStackId = candidate;
+            break;
+        }
+    }
+    ASSERT_FALSE(movedStackId.empty());
+
+    const UIEditorWorkspaceModel afterFirstDock = workspace;
+
+    ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
+        workspace,
+        session,
+        movedStackId,
+        "doc-b",
+        "right-tabs",
+        UIEditorWorkspaceDockPlacement::Bottom,
+        0.4f));
+
+    const auto validation = ValidateUIEditorWorkspace(workspace);
+    ASSERT_TRUE(validation.IsValid()) << validation.message;
+    EXPECT_TRUE(AreUIEditorWorkspaceModelsEquivalent(workspace, afterFirstDock));
+    EXPECT_EQ(workspace.activePanelId, "doc-b");
+
+    const UIEditorWorkspaceNode* rightTabs =
+        FindUIEditorWorkspaceNode(workspace, "right-tabs");
+    ASSERT_NE(rightTabs, nullptr);
+    EXPECT_EQ(rightTabs->kind, UIEditorWorkspaceNodeKind::TabStack);
+    ASSERT_EQ(rightTabs->children.size(), 1u);
+    EXPECT_EQ(rightTabs->children[0].panel.panelId, "details");
+
+    const UIEditorWorkspaceNode* movedTabStack =
+        FindUIEditorWorkspaceNode(workspace, movedStackId);
+    ASSERT_NE(movedTabStack, nullptr);
+    ASSERT_EQ(movedTabStack->kind, UIEditorWorkspaceNodeKind::TabStack);
+    ASSERT_EQ(movedTabStack->children.size(), 1u);
+    EXPECT_EQ(movedTabStack->children[0].panel.panelId, "doc-b");
+}