NativeDockingSmokeFixture.cs

using Microsoft.UI.Reactor;
using Microsoft.UI.Reactor.Core;
using Microsoft.UI.Reactor.Docking;
using Microsoft.UI.Reactor.Docking.Native;
using Microsoft.UI.Reactor.Layout;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using static Microsoft.UI.Reactor.Factories;

namespace Microsoft.UI.Reactor.AppTests.Host.SelfTest.Fixtures;

/// <summary>
/// Spec 045 §2.1 / §2.2 / §2.16 — minimal smoke fixture for the Phase 2
/// native renderer. Asserts that <see cref="DockManager"/> mounts into a
/// Reactor-native subtree (FlexPanel + TabView) without depending on
/// WinUI.Dock controls. Mirrors <see cref="DockingSmokeFixtures"/> in
/// shape so the two renderers are reviewed side by side.
/// </summary>
internal static class NativeDockingSmokeFixtures
{
    internal class TwoPaneMountUpdateUnmount(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();

            // P2: register the native renderer. Same call site as the
            // XAML wrapper; last registration wins on the same TElement.
            DockingNativeInterop.Register(host.Reconciler);

            var pane1 = new DockableContent(
                Title: "Solution Explorer",
                Content: TextBlock("native-solution-content"),
                Key: "tool:solution");
            var pane2 = new DockableContent(
                Title: "Properties",
                Content: TextBlock("native-properties-content"),
                Key: "tool:properties");

            host.Mount(_ => new DockManager
            {
                Layout = new DockSplit(
                    Orientation.Horizontal,
                    new DockNode[] { pane1, pane2 }),
            });
            await Harness.Render();

            // The native renderer mounts a FlexPanel for the split.
            var flexes = H.FindAllControls<FlexPanel>(_ => true);
            H.Check("NativeDock_FlexPanelMounted", flexes.Count >= 1);

            // The leaf renderer for a bare DockableContent inlines the
            // Content element — text markers must appear in the visual
            // tree.
            H.Check("NativeDock_Pane1ContentRendered",
                H.FindText("native-solution-content") is not null);
            H.Check("NativeDock_Pane2ContentRendered",
                H.FindText("native-properties-content") is not null);

            // ── Update: swap one pane's content ─────────────────────
            host.Mount(_ => new DockManager
            {
                Layout = new DockSplit(
                    Orientation.Horizontal,
                    new DockNode[]
                    {
                        pane1,
                        pane2 with { Content = TextBlock("native-properties-updated") },
                    }),
            });
            await Harness.Render();

            H.Check("NativeDock_PaneContentUpdated",
                H.FindText("native-properties-updated") is not null);
            H.Check("NativeDock_PreviousContentReplaced",
                H.FindText("native-properties-content") is null);

            // ── Unmount: replace with a different element ───────────
            host.Mount(_ => TextBlock("native-docking-unmounted"));
            await Harness.Render();

            H.Check("NativeDock_UnmountedCleanly",
                H.FindText("native-docking-unmounted") is not null);
            H.Check("NativeDock_NoFlexPanelAfterUnmount",
                H.FindAllControls<FlexPanel>(_ => true).Count == 0);
        }
    }

    /// <summary>
    /// Mounts a tab group and verifies that the native renderer wires
    /// the TabView control with the right tab headers and that swapping
    /// the selected tab preserves the surrounding tree.
    /// </summary>
    internal class TabGroupRendersToTabView(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            host.Mount(_ => new DockManager
            {
                Layout = new DockTabGroup(new[]
                {
                    new DockableContent("Alpha", TextBlock("native-body-alpha"), Key: "k:a", CanClose: true),
                    new DockableContent("Beta",  TextBlock("native-body-beta"),  Key: "k:b"),
                }),
            });
            await Harness.Render();

            var tabs = H.FindAllControls<TabView>(_ => true);
            H.Check("NativeDock_TabView_Mounted", tabs.Count >= 1);

            var tab = tabs.FirstOrDefault();
            H.Check("NativeDock_TabView_HasTwoTabs", tab?.TabItems.Count == 2);

            // The selected (first) tab's content is rendered into the visual tree.
            H.Check("NativeDock_TabView_FirstBodyRendered",
                H.FindText("native-body-alpha") is not null);

            host.Mount(_ => TextBlock("native-tabs-unmounted"));
            await Harness.Render();
        }
    }

    /// <summary>
    /// Spec 045 §2.17 — asserts that a function component rendered inside
    /// a docked pane sees the live <c>DockContext</c> slots: <c>UseDockHost</c>
    /// returns a non-null model, <c>UsePane</c> returns identity matching
    /// the enclosing leaf, <c>UseActivePaneKey</c> reflects the manager's
    /// <c>ActiveDocument</c>, and <c>UseIsActivePane</c> flips correctly.
    /// </summary>
    internal class DockContextHooksResolveOnRealMount(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            // Build the docking tree inside the mount lambda each call —
            // matches the standard Reactor pattern where Content elements
            // are constructed fresh per render. (Storing element refs
            // outside Mount() means same-reference shallow-equality skips
            // the consumer's re-render before context propagation runs.)
            DockManager Build(bool alphaActive)
            {
                var alpha = new DockableContent(
                    Title: "Alpha",
                    Key: "k:alpha",
                    Content: Memo(ctx =>
                    {
                        var dockHost = ctx.UseDockHost();
                        var pane = ctx.UsePane();
                        var isActive = ctx.UseIsActivePane();
                        return VStack(
                            TextBlock($"alpha-host:{(dockHost is null ? "null" : "ok")}"),
                            TextBlock($"alpha-pane-title:{pane.Title}"),
                            TextBlock($"alpha-pane-key:{pane.Key}"),
                            TextBlock($"alpha-active:{isActive}"));
                    }));
                var beta = new DockableContent(
                    Title: "Beta",
                    Key: "k:beta",
                    Content: Memo(ctx =>
                    {
                        var isActive = ctx.UseIsActivePane();
                        return TextBlock($"beta-active:{isActive}");
                    }));
                return new DockManager
                {
                    Layout = new DockTabGroup(new[] { alpha, beta }),
                    ActiveDocument = alphaActive ? alpha : beta,
                };
            }

            host.Mount(_ => Build(alphaActive: true));
            await Harness.Render();

            H.Check("DockHooks_Host_Resolved",
                H.FindText("alpha-host:ok") is not null);
            H.Check("DockHooks_Pane_TitleResolved",
                H.FindText("alpha-pane-title:Alpha") is not null);
            H.Check("DockHooks_Pane_KeyResolved",
                H.FindText("alpha-pane-key:k:alpha") is not null);
            H.Check("DockHooks_IsActivePane_TrueWhenActive",
                H.FindText("alpha-active:True") is not null);

            host.Mount(_ => Build(alphaActive: false));
            await Harness.Render();

            H.Check("DockHooks_IsActivePane_FlipsOnActiveChange",
                H.FindText("alpha-active:False") is not null);

            host.Mount(_ => TextBlock("hooks-done"));
            await Harness.Render();
        }
    }

    /// <summary>
    /// Spec 045 §2.5 — side strip + side popup. Pinning a pane to the
    /// LeftSide renders a button strip; clicking the button opens a
    /// light-dismiss Popup with the pane's content. Click the button
    /// again (or close the popup) collapses it.
    /// </summary>
    internal class SidePopupExpandsAndCollapses(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            DockManager Build() => new()
            {
                Layout = new DockTabGroup(new[]
                {
                    new DockableContent("Center", TextBlock("center-body"), Key: "k:center"),
                }),
                LeftSide = new[]
                {
                    new DockableContent(
                        Title: "Outline",
                        Key: "k:outline",
                        Content: TextBlock("outline-popup-body"),
                        CanPin: true),
                },
            };

            host.Mount(_ => Build());
            await Harness.Render();

            // Strip button rendered with the pane title.
            var stripButton = H.FindButton("Outline");
            H.Check("SidePopup_StripButton_Rendered", stripButton is not null);

            // No open popups initially. Use VisualTreeHelper.GetOpenPopups
            // against the host's XamlRoot — WinUI hosts open Popups in a
            // private PopupRoot that VTH child-walks don't traverse, so
            // GetOpenPopups is the supported probe.
            var xamlRoot = stripButton!.XamlRoot;
            int OpenCount() => Microsoft.UI.Xaml.Media.VisualTreeHelper
                .GetOpenPopupsForXamlRoot(xamlRoot).Count;

            H.Check("SidePopup_NotOpenInitially", OpenCount() == 0);

            // Click → popup opens.
            H.ClickButton("Outline");
            await Harness.Render();
            H.Check("SidePopup_OpensOnClick", OpenCount() >= 1);

            // Click again → toggles closed.
            H.ClickButton("Outline");
            await Harness.Render();
            H.Check("SidePopup_TogglesClosedOnRepeatClick", OpenCount() == 0);

            host.Mount(_ => TextBlock("side-popup-done"));
            await Harness.Render();
        }
    }

    /// <summary>
    /// Spec 045 §2.6 — floating windows are real Reactor windows. Tear a
    /// pane out via the programmatic API; assert that a new
    /// <see cref="Microsoft.UI.Reactor.ReactorWindow"/> is registered and
    /// closing it removes it from the tracker.
    /// </summary>
    internal class FloatingWindowOpensAsRealWindow(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            host.Mount(_ => new DockManager
            {
                Layout = new DockTabGroup(new[]
                {
                    new DockableContent("Center", TextBlock("center-body"), Key: "k:center"),
                }),
            });
            await Harness.Render();

            var baselineCount = DockFloatingTracker.Count;

            var pane = new DockableContent(
                Title: "Output (floating)",
                Key: "k:output-floating",
                Content: TextBlock("floating-pane-body"));

            // The harness opens its own primary Window outside ReactorApp's
            // registry, so a fixture-spawned floating window can otherwise
            // become the framework's PrimaryWindow and trip
            // ShutdownPolicy.OnPrimaryWindowClosed when the test closes it.
            // Pin the policy to None for the duration of this fixture.
            var savedPolicy = ReactorApp.ShutdownPolicy;
            ReactorApp.ShutdownPolicy = ShutdownPolicy.Explicit;
            try
            {
                var floatingWindow = DockFloatingWindow.Open(pane, width: 600, height: 400);
                await Harness.Render();

                H.Check("FloatingWindow_OpenedAsRealReactorWindow",
                    floatingWindow is not null);
                H.Check("FloatingWindow_RegisteredWithTracker",
                    DockFloatingTracker.Count == baselineCount + 1);
                H.Check("FloatingWindow_TrackerSnapshotIncludesIt",
                    DockFloatingTracker.Snapshot().Contains(floatingWindow));

                // Close the floating window — tracker should drop it.
                floatingWindow!.Close();
                await Harness.Render();
                H.Check("FloatingWindow_RemovedFromTrackerOnClose",
                    DockFloatingTracker.Count == baselineCount);
            }
            finally
            {
                ReactorApp.ShutdownPolicy = savedPolicy;
            }

            host.Mount(_ => TextBlock("floating-done"));
            await Harness.Render();
        }
    }

    /// <summary>
    /// Spec 045 §2.10 — verify that the mounted host component registers
    /// the chord delegates into <see cref="DockChordBridge"/> on render
    /// and that the delegates remain invokable without throwing. The
    /// state-mutation side-effect path (selectedIndexStore → re-render →
    /// TabView SelectedIndex update) is exercised visually in the
    /// showcase and locked down by `DockHostKeyboardTests` unit tests;
    /// the sub-host the fixture mounts doesn't flush internal-state
    /// re-renders through `Harness.Render`'s primary-host wait, so we
    /// don't assert observable side effects here.
    /// </summary>
    internal class KeyboardChordsRegisteredOnMount(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            var a = new DockableContent("Alpha", TextBlock("body-alpha"), Key: "k:a", CanClose: true);
            var b = new DockableContent("Beta",  TextBlock("body-beta"),  Key: "k:b", CanClose: true);
            var managerEl = new DockManager
            {
                Layout = new DockTabGroup(new[] { a, b }, SelectedIndex: 0),
                ActiveDocument = a,
            };
            host.Mount(_ => managerEl);
            await Harness.Render();

            var chords = DockChordBridge.Get(managerEl);
            H.Check("Chords_BridgeRegistered_OnMount", chords is not null);
            H.Check("Chords_NextTab_DelegateNonNull", chords?.NextTab is not null);
            H.Check("Chords_PrevTab_DelegateNonNull", chords?.PrevTab is not null);
            H.Check("Chords_CloseActive_DelegateNonNull", chords?.CloseActive is not null);
            H.Check("Chords_EnterDropMode_DelegateNonNull", chords?.EnterDropMode is not null);

            // Observable side-effects on TabView.SelectedIndex live in
            // selectedIndexStore (UseRef captured inside the host's
            // Render closure). The harness's Render flushes the primary
            // host's reconcile pass but does not flush the sub-host's
            // bumpTick-driven re-render that NextTab/PrevTab schedule —
            // the dictionary update path is locked down by
            // DockHostKeyboardTests at the unit tier. Here we assert
            // the harness-observable contract: chord delegates are
            // wired and invocable without throwing.
            chords?.NextTab();
            chords?.PrevTab();
            chords?.CloseActive();
            chords?.EnterDropMode();
            H.Check("Chords_Invocation_DoesNotThrow", true);

            host.Mount(_ => TextBlock("chords-done"));
            await Harness.Render();
        }
    }

    /// <summary>
    /// Spec 045 §2.14 — verify the drag-start gate refuses panes whose
    /// <see cref="DockableContent.CanMove"/> is <c>false</c>. The gate
    /// lives inside the host component's <c>HandleTabDragStarting</c>
    /// closure, so this fixture asserts the contract indirectly: it
    /// confirms that <see cref="DockDragSession.Begin"/> (the production
    /// session-start path the component calls AFTER the gate) succeeds
    /// when invoked directly, and documents that the gate's predicate
    /// is verified via <see cref="DockableContent.CanMove"/> property
    /// tests in <c>DockApiShapeTests</c> + <c>DocumentToolWindowTests</c>.
    /// </summary>
    internal class PermissionGate_PinnedPaneSurfaceCheck(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            // CanMove is an init-only property on the base record, not on
            // the positional P1 ctor — set it via 'with'.
            var pinned = new DockableContent(
                Title: "Pinned",
                Content: TextBlock("body-pinned"),
                Key: "k:pinned",
                CanClose: false) with { CanMove = false };
            var movable = new DockableContent(
                Title: "Movable",
                Content: TextBlock("body-movable"),
                Key: "k:movable",
                CanClose: true);

            var managerEl = new DockManager
            {
                Layout = new DockTabGroup(new[] { pinned, movable }),
            };
            host.Mount(_ => managerEl);
            await Harness.Render();

            // Exercise the *production* drag-start gate via the bridge
            // the host registers each render. This is the same predicate
            // HandleTabDragStarting applies — refuses CanMove=false,
            // accepts CanMove=true. The prior version of this fixture
            // only asserted record-field values it constructed itself,
            // never invoking the gate.
            var gate = DockDragGateBridge.Get(managerEl);
            H.Check("PermGate_BridgeRegistered", gate is not null);
            if (gate is not null)
            {
                DockDragSession.ResetForTest();
                bool acceptedPinned = gate(pinned, sourceTabIndex: 0);
                H.Check("PermGate_RefusesPinnedPane", !acceptedPinned);
                H.Check("PermGate_PinnedRefusal_NoSessionStarted",
                    DockDragSession.Current is null or { IsActive: false });

                DockDragSession.ResetForTest();
                bool acceptedMovable = gate(movable, sourceTabIndex: 1);
                H.Check("PermGate_AcceptsMovablePane", acceptedMovable);
                H.Check("PermGate_MovableAccept_StartsSession",
                    DockDragSession.Current is { IsActive: true });
                DockDragSession.Current?.End();
            }

            host.Mount(_ => TextBlock("permgate-done"));
            await Harness.Render();
        }
    }

    /// <summary>
    /// Spec 045 §2.18 — verifies the "component is the rehydrator" pattern:
    /// app state holds a collection, the render lambda maps it through
    /// <c>.Select</c> into <c>DockableContent</c> records, and adds /
    /// removes / reorders propagate via keyed reconciliation. No
    /// <c>DocumentsSource</c> binding API exists — Reactor's functional
    /// composition is the data-to-tree mapping.
    /// </summary>
    internal class CompositionDrivenDocumentsRespectKeyedReconciliation(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            // App-level state: a list of document descriptors. The
            // wrapper component maps these to DockableContent each render.
            // Mutating the list + re-mounting demonstrates that the
            // mapping is just .Select — no separate template / binding
            // surface is required.
            var docs = new List<(string Id, string Title, string Body)>
            {
                ("d1", "First",  "body-first"),
                ("d2", "Second", "body-second"),
            };

            DockManager Build() => new DockManager
            {
                Layout = new DockTabGroup(
                    docs.Select(d => new DockableContent(
                        Title: d.Title,
                        Key: d.Id,
                        Content: TextBlock(d.Body),
                        CanClose: true)).ToArray()),
            };

            host.Mount(_ => Build());
            await Harness.Render();

            // Baseline: two tabs visible, both bodies in the tree.
            var initialTabs = H.FindAllControls<TabView>(_ => true);
            H.Check("DocsByComposition_InitialTwoTabs",
                initialTabs.Count == 1 && initialTabs[0].TabItems.Count == 2);
            H.Check("DocsByComposition_InitialFirstBodyRendered",
                H.FindText("body-first") is not null);

            // Capture the TabView reference for identity comparison after
            // the state change.
            var tabViewBefore = initialTabs[0];

            // Add a document to app state, re-mount.
            docs.Add(("d3", "Third", "body-third"));
            host.Mount(_ => Build());
            await Harness.Render();

            var afterAddTabs = H.FindAllControls<TabView>(_ => true);
            H.Check("DocsByComposition_AddedThirdTab",
                afterAddTabs.Count == 1 && afterAddTabs[0].TabItems.Count == 3);
            // Keyed reconciliation: same TabView instance preserved.
            H.Check("DocsByComposition_TabViewIdentityPreservedOnAdd",
                ReferenceEquals(afterAddTabs[0], tabViewBefore));

            // Remove the middle document — third tab should remain, second's body gone.
            docs.RemoveAt(1);
            host.Mount(_ => Build());
            await Harness.Render();

            var afterRemoveTabs = H.FindAllControls<TabView>(_ => true);
            H.Check("DocsByComposition_RemovedToTwoTabs",
                afterRemoveTabs.Count == 1 && afterRemoveTabs[0].TabItems.Count == 2);
            H.Check("DocsByComposition_RemovedBodyGone",
                H.FindText("body-second") is null);
            H.Check("DocsByComposition_SurvivingBodiesRendered",
                H.FindText("body-first") is not null);

            host.Mount(_ => TextBlock("composition-driven-done"));
            await Harness.Render();
        }
    }

    /// <summary>
    /// Spec 045 §2.1 — programmatic splitter-drag fixture. Mounts an
    /// IDE-style nested layout, fires <c>ResizeDelta</c> events directly
    /// on the splitter controls (simulating a pointer drag), and asserts
    /// that the FlexPanel's per-child <c>FlexGrow</c> attached value
    /// shifts as expected. Isolates the render → reconcile → FlexPanel
    /// pipeline from the pointer-capture / hit-test plumbing so failures
    /// fingerprint quickly: if these pass and the showcase doesn't, the
    /// bug is in <see cref="DockSplitterControl"/>'s pointer handling.
    /// </summary>
    internal class SplitterProgrammaticResizeAcrossRenders(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            // IDE-style nested layout. Apps typically rebuild Layout each
            // render — model that via a state counter the host bumps to
            // force fresh DockSplit instances.
            DockManager Build()
            {
                return new DockManager
                {
                    Layout = new DockSplit(
                        Orientation.Vertical,
                        new DockNode[]
                        {
                            // Top row — horizontal split with two leaves.
                            new DockSplit(
                                Orientation.Horizontal,
                                new DockNode[]
                                {
                                    new DockableContent("Editor",
                                        TextBlock("editor-body"),
                                        Key: "k:editor"),
                                    new DockableContent("Tools",
                                        TextBlock("tools-body"),
                                        Key: "k:tools"),
                                }),
                            // Bottom row — horizontal split with two leaves.
                            new DockSplit(
                                Orientation.Horizontal,
                                new DockNode[]
                                {
                                    new DockableContent("Output",
                                        TextBlock("output-body"),
                                        Key: "k:output"),
                                    new DockableContent("Terminal",
                                        TextBlock("terminal-body"),
                                        Key: "k:terminal"),
                                }),
                        }),
                };
            }

            host.Mount(_ => Build());
            await Harness.Render();

            // Discover the three splitter controls: 1 in outer (rows
            // splitter — horizontal bar) + 1 in each inner split (column
            // splitters — vertical bars). Distinguish by Direction.
            var splitters = H.FindAllControls<DockSplitterControl>(_ => true);
            H.Check("SplitProg_ThreeSplittersMounted", splitters.Count == 3);

            var rowSplitter = splitters.FirstOrDefault(s => s.Direction == DockSplitterDirection.Rows);
            var colSplitters = splitters.Where(s => s.Direction == DockSplitterDirection.Columns).ToList();
            H.Check("SplitProg_RowSplitterFound", rowSplitter is not null);
            H.Check("SplitProg_TwoColumnSplitters", colSplitters.Count == 2);

            // Capture the initial grow values from each splitter's parent
            // FlexPanel. Row direction parent splits vertically; column
            // direction parents split horizontally.
            double GrowOf(UIElement child) => FlexPanel.GetGrow(child);

            double[] GrowsFor(DockSplitterControl s)
            {
                var parent = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetParent(s) as FlexPanel;
                if (parent is null) return [];
                var result = new double[parent.Children.Count];
                for (int i = 0; i < parent.Children.Count; i++)
                    result[i] = GrowOf(parent.Children[i]);
                return result;
            }

            var beforeRowGrows = GrowsFor(rowSplitter!);
            var beforeCol0Grows = GrowsFor(colSplitters[0]);
            var beforeCol1Grows = GrowsFor(colSplitters[1]);
            Console.WriteLine($"# beforeRow=[{string.Join(",", beforeRowGrows)}]");
            Console.WriteLine($"# beforeCol0=[{string.Join(",", beforeCol0Grows)}]");
            Console.WriteLine($"# beforeCol1=[{string.Join(",", beforeCol1Grows)}]");

            H.Check("SplitProg_InitialRowsEqual",
                beforeRowGrows.Length >= 3
                && Math.Abs(beforeRowGrows[0] - beforeRowGrows[2]) < 0.0001);

            // ── Drag #1: shrink the row splitter's leading row by 100 DIP.
            // Fire ResizeDelta directly with hostExtent matching the
            // splitter's host. The control's OnDelta closure must compute
            // a new ratio and trigger re-render.
            FireResizeDelta(rowSplitter!, delta: 100, isFinal: false);
            FireResizeDelta(rowSplitter!, delta: 0, isFinal: true);
            await Harness.Render();

            var afterRowGrows1 = GrowsFor(rowSplitter!);
            Console.WriteLine($"# afterRowDrag1=[{string.Join(",", afterRowGrows1)}]");
            H.Check("SplitProg_RowDragShiftedLeadingDown",
                afterRowGrows1.Length >= 3 && afterRowGrows1[0] < beforeRowGrows[0] - 0.001);

            // ── Drag #2 on the SAME splitter: shrink another 50 DIP.
            // Verifies ratio accumulation across drags (not snap-back).
            FireResizeDelta(rowSplitter!, delta: 50, isFinal: false);
            FireResizeDelta(rowSplitter!, delta: 0, isFinal: true);
            await Harness.Render();

            var afterRowGrows2 = GrowsFor(rowSplitter!);
            Console.WriteLine($"# afterRowDrag2=[{string.Join(",", afterRowGrows2)}]");
            H.Check("SplitProg_RowDragCumulates",
                afterRowGrows2[0] < afterRowGrows1[0] - 0.001);

            // ── Drag the FIRST column splitter — should NOT affect the
            // row splitter's ratios, nor the OTHER column splitter's.
            FireResizeDelta(colSplitters[0], delta: 80, isFinal: false);
            FireResizeDelta(colSplitters[0], delta: 0, isFinal: true);
            await Harness.Render();

            var col0After = GrowsFor(colSplitters[0]);
            var col1After = GrowsFor(colSplitters[1]);
            var rowAfterCol = GrowsFor(rowSplitter!);
            Console.WriteLine($"# afterCol0Drag col0=[{string.Join(",", col0After)}] col1=[{string.Join(",", col1After)}] row=[{string.Join(",", rowAfterCol)}]");

            H.Check("SplitProg_Col0DragShiftedLeading",
                col0After[0] < beforeCol0Grows[0] - 0.001);
            H.Check("SplitProg_Col1Untouched",
                col1After.Length == beforeCol1Grows.Length
                && Math.Abs(col1After[0] - beforeCol1Grows[0]) < 0.0001);
            H.Check("SplitProg_RowUntouchedByColDrag",
                rowAfterCol.Length == afterRowGrows2.Length
                && Math.Abs(rowAfterCol[0] - afterRowGrows2[0]) < 0.0001);

            // ── Force a re-render by re-mounting a fresh Build(). All
            // DockSplit references change. Ratios MUST survive (the
            // tree-position-key fix).
            host.Mount(_ => Build());
            await Harness.Render();

            var splittersAfterRemount = H.FindAllControls<DockSplitterControl>(_ => true);
            var rowAfterRemount = splittersAfterRemount.FirstOrDefault(s => s.Direction == DockSplitterDirection.Rows);
            H.Check("SplitProg_RowSplitterStillPresentAfterRemount", rowAfterRemount is not null);

            var rowGrowsAfterRemount = GrowsFor(rowAfterRemount!);
            Console.WriteLine($"# afterRemount row=[{string.Join(",", rowGrowsAfterRemount)}]");
            H.Check("SplitProg_RowRatiosSurvivedRemount",
                rowGrowsAfterRemount.Length == afterRowGrows2.Length
                && Math.Abs(rowGrowsAfterRemount[0] - afterRowGrows2[0]) < 0.0001);

            host.Mount(_ => TextBlock("split-prog-done"));
            await Harness.Render();
        }

        /// <summary>
        /// Fires the splitter's internal ResizeDelta event using the
        /// splitter's live host extent. Bypasses pointer/keyboard.
        /// </summary>
        private static void FireResizeDelta(DockSplitterControl splitter, double delta, bool isFinal)
        {
            var hostExtent = splitter.GetHostExtent();
            if (hostExtent < 1) hostExtent = 1000;
            var args = new DockSplitterDeltaEventArgs(delta, splitter.Direction, hostExtent, isFinal);
            splitter.RaiseResizeDeltaForTest(args);
        }
    }

    /// <summary>
    /// Spec 045 §2.1 — rapid-fire drag simulator. Fires many small
    /// ResizeDelta events in quick succession (no render await between
    /// them) to model what a real pointer drag does. If the ratios shift
    /// smoothly cumulatively, the rewiring-during-render path is safe;
    /// if they snap or freeze, the bug is in the closure-recapture flow
    /// fired by mid-drag re-renders.
    /// </summary>
    internal class SplitterRapidFireDragSurvivesRerender(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            DockManager Build() => new()
            {
                Layout = new DockSplit(
                    Orientation.Horizontal,
                    new DockNode[]
                    {
                        new DockableContent("L", TextBlock("l-body"), Key: "k:l"),
                        new DockableContent("R", TextBlock("r-body"), Key: "k:r"),
                    }),
            };

            host.Mount(_ => Build());
            await Harness.Render();

            var splitter = H.FindAllControls<DockSplitterControl>(_ => true).FirstOrDefault();
            H.Check("SplitFire_SplitterMounted", splitter is not null);

            FlexPanel? parent = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetParent(splitter!) as FlexPanel;
            H.Check("SplitFire_ParentIsFlexPanel", parent is not null);

            double LeadingGrow() => FlexPanel.GetGrow(parent!.Children[0]);
            var initial = LeadingGrow();
            Console.WriteLine($"# initial leading grow={initial:F4}");

            // Fire 20 incremental deltas with NO await between them. Each
            // increment is 4 DIP. Total = 80 DIP. Mid-drag re-renders are
            // queued; the closures must continue to find the right ratios.
            for (int i = 0; i < 20; i++)
            {
                FireResizeDelta(splitter!, delta: 4, isFinal: false);
            }
            FireResizeDelta(splitter!, delta: 0, isFinal: true);
            await Harness.Render();

            var afterRapidGrow = LeadingGrow();
            Console.WriteLine($"# afterRapid leading grow={afterRapidGrow:F4} (delta from initial={initial - afterRapidGrow:F4})");

            // 80 DIP of accumulated drag on a ~945 DIP host should shift
            // the leading ratio by ~80/945 ≈ 0.085. Allow some slack for
            // the actual hostExtent the test runs in.
            H.Check("SplitFire_LeadingShrankByAccumulatedDelta",
                afterRapidGrow < initial - 0.01);

            // Fire 20 MORE deltas — the ratios should continue to shift,
            // NOT snap back, NOT freeze.
            for (int i = 0; i < 20; i++)
            {
                FireResizeDelta(splitter!, delta: 4, isFinal: false);
            }
            FireResizeDelta(splitter!, delta: 0, isFinal: true);
            await Harness.Render();

            var afterSecond = LeadingGrow();
            Console.WriteLine($"# afterSecond leading grow={afterSecond:F4}");
            H.Check("SplitFire_SecondRapidBurstCumulates",
                afterSecond < afterRapidGrow - 0.01);

            // Reverse direction — drag the trailing child back.
            for (int i = 0; i < 30; i++)
            {
                FireResizeDelta(splitter!, delta: -4, isFinal: false);
            }
            FireResizeDelta(splitter!, delta: 0, isFinal: true);
            await Harness.Render();

            var afterReverse = LeadingGrow();
            Console.WriteLine($"# afterReverse leading grow={afterReverse:F4}");
            H.Check("SplitFire_ReverseDragGrowsLeading",
                afterReverse > afterSecond + 0.01);

            host.Mount(_ => TextBlock("rapid-fire-done"));
            await Harness.Render();
        }

        private static void FireResizeDelta(DockSplitterControl splitter, double delta, bool isFinal)
        {
            var hostExtent = splitter.GetHostExtent();
            if (hostExtent < 1) hostExtent = 1000;
            var args = new DockSplitterDeltaEventArgs(delta, splitter.Direction, hostExtent, isFinal);
            splitter.RaiseResizeDeltaForTest(args);
        }
    }

    /// <summary>
    /// Spec 045 §2.3 — drop-target overlay smoke. Mounts a DockManager with
    /// <c>ShowDropTargets = true</c>, asserts the 9 buttons are present in
    /// the visual tree at minimum 44×44 DIP, drives a confirm via the
    /// internal test hook, and verifies the model gets the
    /// <see cref="DockTarget"/> the user picked. Verifies the dismiss
    /// callback fires when the overlay is dismissed (Esc).
    /// </summary>
    internal class DropTargetOverlayShowsAndDismisses(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            DockTarget? lastHover = null;
            DockTarget? lastConfirmed = null;
            int dismissCount = 0;

            DockManager Build(bool show) => new()
            {
                Layout = new DockTabGroup(new[]
                {
                    new DockableContent("Center", TextBlock("dt-center-body"), Key: "k:center"),
                }),
                ShowDropTargets = show,
                OnDropTargetHovered = t => lastHover = t,
                OnDropTargetConfirmed = t => lastConfirmed = t,
                OnDropTargetsDismissed = () => dismissCount++,
            };

            // ── Initial mount with overlay OFF — no overlay control yet.
            host.Mount(_ => Build(show: false));
            await Harness.Render();
            var noOverlay = H.FindAllControls<DockDropTargetOverlayControl>(_ => true);
            H.Check("DropTarget_NotMountedWhenFlagFalse", noOverlay.Count == 0);

            // ── Flip on — overlay mounts.
            host.Mount(_ => Build(show: true));
            await Harness.Render();

            var overlays = H.FindAllControls<DockDropTargetOverlayControl>(_ => true);
            H.Check("DropTarget_OverlayMounted", overlays.Count == 1);
            var overlay = overlays[0];

            // 9 target buttons + 1 preview rectangle ⇒ 10 children. Each
            // button is a Border with Width == ButtonSizeDip (44).
            var borders = new global::System.Collections.Generic.List<Microsoft.UI.Xaml.Controls.Border>();
            foreach (var child in overlay.Children)
                if (child is Microsoft.UI.Xaml.Controls.Border b) borders.Add(b);

            var targetButtons = borders.FindAll(b =>
                b.Width >= DockDropTargetOverlayControl.ButtonSizeDip - 0.001
                && b.Height >= DockDropTargetOverlayControl.ButtonSizeDip - 0.001
                && b.IsTabStop);
            H.Check("DropTarget_NineButtonsRendered", targetButtons.Count == 9);
            H.Check("DropTarget_ButtonsAtLeast44Dip",
                targetButtons.TrueForAll(b => b.Width >= 44.0 && b.Height >= 44.0));

            // ── Programmatically confirm SplitLeft via the test hook.
            // The model callback should receive the same target.
            overlay.ConfirmTargetForTest(DockTarget.SplitLeft);
            await Harness.Render();
            H.Check("DropTarget_ConfirmCallbackFired", lastConfirmed == DockTarget.SplitLeft);

            // ── Programmatic hover updates preview rect + callback.
            overlay.SetHoveredForTest(DockTarget.DockRight);
            await Harness.Render();
            H.Check("DropTarget_HoverCallbackFired", lastHover == DockTarget.DockRight);

            var bounds = overlay.PreviewBounds;
            H.Check("DropTarget_PreviewRectVisible",
                bounds.Width > 0 && bounds.Height > 0);

            // Right-edge strip should sit at the right of the overlay —
            // i.e. its X is near (overlay.ActualWidth - bounds.Width).
            if (overlay.ActualWidth > 0)
            {
                var expectedX = overlay.ActualWidth - bounds.Width;
                H.Check("DropTarget_DockRightPreviewAtRightEdge",
                    Math.Abs(bounds.X - expectedX) < 1.0);
            }

            // ── Clear hover — preview hides.
            overlay.SetHoveredForTest(null);
            await Harness.Render();
            var clearBounds = overlay.PreviewBounds;
            H.Check("DropTarget_PreviewHidesOnNoHover", clearBounds.IsEmpty);

            // ── Flip overlay OFF — control unmounts.
            host.Mount(_ => Build(show: false));
            await Harness.Render();
            var gone = H.FindAllControls<DockDropTargetOverlayControl>(_ => true);
            H.Check("DropTarget_UnmountedWhenFlagFlipsOff", gone.Count == 0);

            host.Mount(_ => TextBlock("dt-overlay-done"));
            await Harness.Render();

            // dismissCount comes from the Esc path; not exercised here since
            // the headless harness doesn't deliver real keystrokes. Kept
            // as a sentinel so the callback wire-up doesn't go untested.
            _ = dismissCount;
        }
    }

    /// <summary>
    /// Spec 045 §2.4 — smoke fixture for the drag pipeline. Simulates a
    /// tab drag by directly beginning a <see cref="DockDragSession"/> and
    /// then confirming a target on the overlay (using the §2.3 control's
    /// test hook). Asserts the host mutates its layout per the target and
    /// fires <c>OnContentDocked</c>. Bypasses real pointer events since
    /// the headless harness doesn't deliver them.
    /// </summary>
    internal class DragSessionConfirmMutatesLayout(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            DockDragSession.ResetForTest();
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            DockableContent? docked = null;
            DockTarget? dockedAt = null;

            var paneA = new DockableContent("Tab A", TextBlock("body-a"), Key: "h:a", CanClose: true);
            var paneB = new DockableContent("Tab B", TextBlock("body-b"), Key: "h:b", CanClose: true);

            host.Mount(_ => new DockManager
            {
                Layout = new DockTabGroup(new[] { paneA, paneB }),
                OnContentDocked = args => { docked = args.Content; dockedAt = args.Target; },
            });
            await Harness.Render();

            H.Check("DragMutate_TabViewMounted",
                H.FindAllControls<TabView>(_ => true).Count == 1);

            // ── Simulate drag begin (what TabDragStarting would fire).
            var manager = new DockManager
            {
                Layout = new DockTabGroup(new[] { paneA, paneB }),
            };
            var session = DockDragSession.Begin(paneA, manager, sourceTabIndex: 0);
            H.Check("DragMutate_SessionBegan", session is { IsActive: true });
            H.Check("DragMutate_SourcePane", ReferenceEquals(session!.Source, paneA));

            // Force overlay to appear by re-mounting with ShowDropTargets
            // = true. (The §2.4 path flips this internally via dragActive
            // state; the smoke harness can't deliver a real drag, so we
            // exercise the overlay via the manager prop instead.)
            host.Mount(_ => new DockManager
            {
                Layout = new DockTabGroup(new[] { paneA, paneB }),
                ShowDropTargets = true,
                OnContentDocked = args => { docked = args.Content; dockedAt = args.Target; },
            });
            await Harness.Render();

            var overlay = H.FindAllControls<DockDropTargetOverlayControl>(_ => true).FirstOrDefault();
            H.Check("DragMutate_OverlayMounted", overlay is not null);

            // ── Confirm SplitRight. The host's OnConfirm closure looks at
            // DockDragSession.Current and mutates the layout via override.
            overlay!.ConfirmTargetForTest(DockTarget.SplitRight);
            await Harness.Render();

            H.Check("DragMutate_OnContentDocked_Fired", docked is not null);
            H.Check("DragMutate_OnContentDocked_PaneMatches",
                ReferenceEquals(docked, paneA));
            H.Check("DragMutate_OnContentDocked_TargetMatches",
                dockedAt == DockTarget.SplitRight);

            // Session should be torn down after confirm.
            H.Check("DragMutate_SessionEnded",
                DockDragSession.Current is null || !DockDragSession.Current.IsActive);

            // The host's effective layout (visible in the visual tree)
            // should now be a horizontal split (the original group on the
            // left + paneA on the right since the mutator moved it). The
            // tab strip is still present for the remaining group.
            await Harness.Render();
            var flexes = H.FindAllControls<Microsoft.UI.Reactor.Layout.FlexPanel>(_ => true);
            H.Check("DragMutate_LayoutBecameSplit", flexes.Count >= 1);

            host.Mount(_ => TextBlock("drag-pipeline-done"));
            await Harness.Render();
            DockDragSession.ResetForTest();
        }
    }

    /// <summary>
    /// Visual demo fixture — mounts an IDE-style layout and drives each
    /// splitter programmatically with paced delays so a human observer
    /// can watch the panes resize step by step. Asserts the same as the
    /// other splitter fixtures but with ~800 ms gaps between operations.
    /// </summary>
    /// <summary>
    /// Spec 045 §2.3 per-group drop overlay visual demo. Mounts a 2×2
    /// layout of four tab groups (G1..G4) plus a 5th "mover" doc that
    /// starts inside G1. Walks the mover through every (group × target)
    /// position — Center / SplitLeft / SplitRight / SplitTop /
    /// SplitBottom — for each of the four groups (20 moves total),
    /// resetting between moves so the human observer sees each landing
    /// clearly. Uses <see cref="DockLayoutMutator.MovePaneToGroupTarget"/>
    /// directly so the test is independent of the gesture pipeline.
    /// </summary>
    internal class PerGroupDropTargetVisualDemo(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            // Five docs. "mover" is the one we relocate; the four
            // anchor docs stay put inside their own groups so the four
            // groups remain identifiable across moves.
            var anchorA = new DockableContent("Anchor A",
                TextBlock("anchor A — G1 home").SemiBold(),
                Key: "g:anchorA");
            var anchorB = new DockableContent("Anchor B",
                TextBlock("anchor B — G2 home").SemiBold(),
                Key: "g:anchorB");
            var anchorC = new DockableContent("Anchor C",
                TextBlock("anchor C — G3 home").SemiBold(),
                Key: "g:anchorC");
            var anchorD = new DockableContent("Anchor D",
                TextBlock("anchor D — G4 home").SemiBold(),
                Key: "g:anchorD");
            var mover = new DockableContent("Mover",
                VStack(4,
                    TextBlock("⭐ Mover").SemiBold(),
                    TextBlock("watch me move through every group + target").FontSize(11)),
                Key: "g:mover");

            // Initial layout: 2×2 grid of four single-doc groups; mover
            // starts as a sibling tab inside G1 so step 1 (G1.Center) is
            // a no-op-ish self-tab; subsequent steps tear it out.
            DockNode BuildInitial()
            {
                var g1 = new DockTabGroup(new DockableContent[] { anchorA, mover });
                var g2 = new DockTabGroup(new DockableContent[] { anchorB });
                var g3 = new DockTabGroup(new DockableContent[] { anchorC });
                var g4 = new DockTabGroup(new DockableContent[] { anchorD });
                return new DockSplit(Orientation.Vertical, new DockNode[]
                {
                    new DockSplit(Orientation.Horizontal, new DockNode[] { g1, g2 }),
                    new DockSplit(Orientation.Horizontal, new DockNode[] { g3, g4 }),
                });
            }

            var liveLayout = BuildInitial();
            host.Mount(_ => new DockManager { Layout = liveLayout });
            await Harness.Render();
            // Visual-demo "let the eye register" pauses — tightened for
            // CI stress runs (target ~4s total). Bump back up locally
            // for slow-motion manual viewing.
            await Task.Delay(20);

            // Targets we walk through in each group.
            var targets = new[]
            {
                DockTarget.Center,
                DockTarget.SplitLeft,
                DockTarget.SplitTop,
                DockTarget.SplitRight,
                DockTarget.SplitBottom,
            };

            // For each group, snapshot its identity by the anchor it
            // contains so we can re-locate the equivalent group across
            // re-mounts (records compare by value, so reference equality
            // is stable across BuildInitial()'s repeated calls).
            var groupAnchors = new[]
            {
                ("G1", anchorA),
                ("G2", anchorB),
                ("G3", anchorC),
                ("G4", anchorD),
            };

            int landed = 0;
            int splitObserved = 0;
            foreach (var (groupName, anchor) in groupAnchors)
            {
                foreach (var target in targets)
                {
                    // Fresh initial layout each step so the user sees
                    // each result against a clean baseline.
                    liveLayout = BuildInitial();
                    host.Mount(_ => new DockManager { Layout = liveLayout });
                    await Harness.Render();
                    await Task.Delay(5);

                    // Find the target group in the fresh tree by anchor.
                    var targetGroup = FindGroupContaining(liveLayout, anchor);
                    if (targetGroup is null)
                    {
                        H.Check($"PerGroupDemo_{groupName}_{target}_TargetGroupFound", false);
                        continue;
                    }

                    var newLayout = DockLayoutMutator.MovePaneToGroupTarget(
                        liveLayout, mover, targetGroup, target);
                    liveLayout = newLayout ?? liveLayout;
                    host.Mount(_ => new DockManager { Layout = liveLayout });
                    await Harness.Render();

                    // Verify: the mover is reachable (somewhere in the
                    // tree) and the four anchors are also still reachable.
                    bool moverIn = ContainsPane(liveLayout, mover);
                    bool allAnchorsIn = ContainsPane(liveLayout, anchorA)
                        && ContainsPane(liveLayout, anchorB)
                        && ContainsPane(liveLayout, anchorC)
                        && ContainsPane(liveLayout, anchorD);
                    H.Check($"PerGroupDemo_{groupName}_{target}_MoverIsInTree", moverIn);
                    H.Check($"PerGroupDemo_{groupName}_{target}_AnchorsPreserved", allAnchorsIn);
                    if (moverIn && allAnchorsIn) landed++;

                    // Count how many splits the tree contains — split
                    // moves should grow this; center moves shouldn't.
                    int splits = CountSplits(liveLayout);
                    if (target != DockTarget.Center && splits > 3) splitObserved++;

                    await Task.Delay(5); // observer pause — minimal for CI; bump for manual demo
                }
            }

            // 20 moves total (4 groups × 5 targets); every one should
            // have landed the mover + preserved the anchors.
            H.Check("PerGroupDemo_AllTwentyMovesLanded", landed == 20);
            // 16 of those moves are split-type (4 splits per group ×
            // 4 groups); each should produce strictly MORE splits than
            // the baseline 3 (top split + 2 row splits).
            H.Check("PerGroupDemo_SplitMovesProducedExtraSplits", splitObserved == 16);

            host.Mount(_ => TextBlock("per-group-drop-demo-done"));
            await Harness.Render();
        }

        private static DockTabGroup? FindGroupContaining(DockNode? node, DockableContent target)
        {
            switch (node)
            {
                case DockTabGroup g:
                    foreach (var d in g.Documents)
                        if (ReferenceEquals(d, target)) return g;
                    return null;
                case DockSplit s:
                    foreach (var c in s.Children)
                    {
                        var r = FindGroupContaining(c, target);
                        if (r is not null) return r;
                    }
                    return null;
                default: return null;
            }
        }

        private static bool ContainsPane(DockNode? node, DockableContent target)
        {
            switch (node)
            {
                case null: return false;
                case DockableContent leaf: return ReferenceEquals(leaf, target);
                case DockTabGroup g:
                    foreach (var d in g.Documents)
                        if (ReferenceEquals(d, target)) return true;
                    return false;
                case DockSplit s:
                    foreach (var c in s.Children)
                        if (ContainsPane(c, target)) return true;
                    return false;
                default: return false;
            }
        }

        private static int CountSplits(DockNode? node)
        {
            switch (node)
            {
                case DockSplit s:
                {
                    int n = 1;
                    foreach (var c in s.Children) n += CountSplits(c);
                    return n;
                }
                default: return 0;
            }
        }
    }

    internal class SplitterProgrammaticVisualDemo(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            DockManager Build() => new()
            {
                Layout = new DockSplit(
                    Orientation.Vertical,
                    new DockNode[]
                    {
                        new DockSplit(
                            Orientation.Horizontal,
                            new DockNode[]
                            {
                                new DockableContent("Editor",
                                    VStack(8,
                                        TextBlock("editor body — top half, left pane").SemiBold(),
                                        TextBlock("Drag programmatically below to watch this pane resize.")),
                                    Key: "k:editor"),
                                new DockableContent("Tools",
                                    VStack(8,
                                        TextBlock("tools body — top half, right pane").SemiBold(),
                                        TextBlock("Outline / properties etc.")),
                                    Key: "k:tools"),
                            }),
                        new DockSplit(
                            Orientation.Horizontal,
                            new DockNode[]
                            {
                                new DockableContent("Output",
                                    VStack(8,
                                        TextBlock("output body — bottom half, left").SemiBold(),
                                        TextBlock("Build / test output.")),
                                    Key: "k:output"),
                                new DockableContent("Terminal",
                                    VStack(8,
                                        TextBlock("terminal body — bottom half, right").SemiBold(),
                                        TextBlock("PS> _")),
                                    Key: "k:terminal"),
                            }),
                    }),
            };

            host.Mount(_ => Build());
            await Harness.Render();
            // Timing budget (target ~5s, 15s timeout):
            //   initial settle:      200ms
            //   5 loops × (5 nudges × 60ms + after-final 120ms): 2100ms
            //   total delay budget:  ~2.3s
            //   render overhead (~80ms × ~26 renders): ~2s
            //   grand total:         ~4.4s → comfortable margin under 5s
            // Nudge pacing still leaves the resize visible (~17fps);
            // tighter than the original 200ms but still observable for
            // manual debug runs. Stress runs benefit from the shorter
            // wall clock per shard.
            await Task.Delay(200);

            var splitters = H.FindAllControls<DockSplitterControl>(_ => true);
            var rowSplitter = splitters.FirstOrDefault(s => s.Direction == DockSplitterDirection.Rows);
            var colSplitters = splitters.Where(s => s.Direction == DockSplitterDirection.Columns).ToList();

            H.Check("VizDemo_LayoutMounted",
                rowSplitter is not null && colSplitters.Count == 2);

            // 1) Shrink the top row gradually — five 40-DIP nudges.
            for (int i = 0; i < 5; i++)
            {
                FireResizeDelta(rowSplitter!, delta: 40, isFinal: false);
                await Harness.Render();
                await Task.Delay(60);
            }
            FireResizeDelta(rowSplitter!, delta: 0, isFinal: true);
            await Harness.Render();
            await Task.Delay(120);

            // 2) Grow the top row back — five -40-DIP nudges.
            for (int i = 0; i < 5; i++)
            {
                FireResizeDelta(rowSplitter!, delta: -40, isFinal: false);
                await Harness.Render();
                await Task.Delay(60);
            }
            FireResizeDelta(rowSplitter!, delta: 0, isFinal: true);
            await Harness.Render();
            await Task.Delay(120);

            // 3) Shrink the top-row's left column (editor) — five 40 DIP.
            for (int i = 0; i < 5; i++)
            {
                FireResizeDelta(colSplitters[0], delta: 40, isFinal: false);
                await Harness.Render();
                await Task.Delay(60);
            }
            FireResizeDelta(colSplitters[0], delta: 0, isFinal: true);
            await Harness.Render();
            await Task.Delay(120);

            // 4) Restore the top-row's left column — five -40 DIP.
            for (int i = 0; i < 5; i++)
            {
                FireResizeDelta(colSplitters[0], delta: -40, isFinal: false);
                await Harness.Render();
                await Task.Delay(60);
            }
            FireResizeDelta(colSplitters[0], delta: 0, isFinal: true);
            await Harness.Render();
            await Task.Delay(120);

            // 5) Shrink the bottom-row's left column (output) — five 40 DIP.
            for (int i = 0; i < 5; i++)
            {
                FireResizeDelta(colSplitters[1], delta: 40, isFinal: false);
                await Harness.Render();
                await Task.Delay(60);
            }
            FireResizeDelta(colSplitters[1], delta: 0, isFinal: true);
            await Harness.Render();
            await Task.Delay(120);

            H.Check("VizDemo_CompletedAllFourQuadrants", true);

            host.Mount(_ => TextBlock("viz demo done"));
            await Harness.Render();
        }

        private static void FireResizeDelta(DockSplitterControl splitter, double delta, bool isFinal)
        {
            var hostExtent = splitter.GetHostExtent();
            if (hostExtent < 1) hostExtent = 1000;
            var args = new DockSplitterDeltaEventArgs(delta, splitter.Direction, hostExtent, isFinal);
            splitter.RaiseResizeDeltaForTest(args);
        }
    }

    /// <summary>
    /// Spec 045 §2.16 — model-mutation drain. Mounts a host, grabs the live
    /// <see cref="DockHostModel"/> via <see cref="DockHostModelBridge"/>,
    /// invokes the public mutators (Dock / Close / Activate / PinToSide),
    /// and asserts the rendered visual tree updates in the same frame as
    /// the mutation. This is the headless analogue of "click a button →
    /// pane appears" — without it, the model surface is a write-only sink.
    /// </summary>
    internal class ModelDrain_DockCloseActivatePinAffectsLiveTree(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            var initialDoc = new Document
            {
                Title = "Doc1",
                Key = "drain:doc1",
                Content = TextBlock("body-drain-doc1"),
            };
            var managerEl = new DockManager
            {
                Layout = new DockTabGroup(new DockableContent[] { initialDoc }),
                LeftSide = null,
            };
            host.Mount(_ => managerEl);
            await Harness.Render();

            // The bridge yields the same DockHostModel the component is
            // syncing into. Apps using DockContexts.Host inside the subtree
            // would resolve to the same instance.
            var model = DockHostModelBridge.Get(managerEl);
            H.Check("Drain_ModelBridge_ResolvesModel", model is not null);

            // ── Dock: program a fresh document into the layout ───────────
            var addedDoc = new Document
            {
                Title = "Doc2",
                Key = "drain:doc2",
                Content = TextBlock("body-drain-doc2"),
            };
            DockableContent? dockedCallback = null;
            DockTarget? dockedTarget = null;
            host.Mount(_ => managerEl with
            {
                OnContentDocked = a => { dockedCallback = a.Content; dockedTarget = a.Target; },
            });
            await Harness.Render();
            var modelAfterRemount = DockHostModelBridge.Get(managerEl);
            modelAfterRemount?.Dock(addedDoc, DockTarget.Center);
            await Harness.Render();
            H.Check("Drain_Dock_LiveTreeShowsNewPane",
                H.FindText("body-drain-doc2") is not null);
            H.Check("Drain_Dock_FiresOnContentDocked",
                dockedCallback is not null && ReferenceEquals(dockedCallback, addedDoc));
            H.Check("Drain_Dock_TargetIsCenter", dockedTarget == DockTarget.Center);

            // ── Close: programmatic close fires OnDocumentClosed + drops
            // the pane from the rendered tree ────────────────────────────
            DockableContent? closedCallback = null;
            host.Mount(_ => managerEl with
            {
                OnDocumentClosed = a => closedCallback = a.Document,
            });
            await Harness.Render();
            var model2 = DockHostModelBridge.Get(managerEl);
            model2?.Close(initialDoc);
            await Harness.Render();
            H.Check("Drain_Close_LiveTreeDropsClosedPane",
                H.FindText("body-drain-doc1") is null);
            H.Check("Drain_Close_FiresOnDocumentClosed",
                closedCallback is not null && ReferenceEquals(closedCallback, initialDoc));

            // ── Activate: fires OnActiveContentChanged ───────────────────
            DockableContent? activatedCallback = null;
            host.Mount(_ => managerEl with
            {
                OnActiveContentChanged = a => activatedCallback = a.ActiveContent,
            });
            await Harness.Render();
            var model3 = DockHostModelBridge.Get(managerEl);
            model3?.Activate(addedDoc);
            await Harness.Render();
            H.Check("Drain_Activate_FiresOnActiveContentChanged",
                activatedCallback is not null && ReferenceEquals(activatedCallback, addedDoc));

            // ── PinToSide: a ToolWindow moves from the docked tree into
            // the left side strip. Surface check: the tree no longer holds
            // the tool's body; a Button with the tool title is mounted by
            // the strip renderer.
            var twToPin = new ToolWindow
            {
                Title = "PinnedTool",
                Key = "drain:tw1",
                Content = TextBlock("body-drain-tw"),
            };
            var model4 = DockHostModelBridge.Get(managerEl);
            model4?.Dock(twToPin, DockTarget.Center);
            await Harness.Render();
            H.Check("Drain_PinPrep_ToolPresentBeforePin",
                H.FindText("body-drain-tw") is not null);
            model4?.PinToSide(twToPin, DockSide.Left);
            await Harness.Render();
            // The pinned tool's body is now in a Popup that's closed by
            // default, so the body text is not in the visual tree. The
            // side strip renders a Button captioned with the tool title.
            var stripButtons = H.FindAllControls<Button>(b =>
                b.Content is string s && s == "PinnedTool");
            H.Check("Drain_PinToSide_SideStripShowsButton",
                stripButtons.Count >= 1);

            host.Mount(_ => TextBlock("model-drain-done"));
            await Harness.Render();
        }
    }

    /// <summary>
    /// Spec 045 §4.6 — TabChrome chrome presets land as scoped resource-
    /// dictionary overrides on the underlying <see cref="TabView"/>. The
    /// fixture mounts three groups (Win11 / Flat / TitleBar) side-by-side
    /// and verifies each TabView's <c>Resources</c> matches the contract.
    /// Then flips Flat → Win11 to lock in the pool-safety "blanker"
    /// behavior: a TabView reused under a new chrome must not leak
    /// the prior preset's overrides.
    /// </summary>
    internal class TabChromePresetsApplyAndClear(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            DockManager BuildPair(TabChrome leftChrome, TabChrome rightChrome) => new DockManager
            {
                Layout = new DockSplit(
                    Orientation.Horizontal,
                    new DockNode[]
                    {
                        new DockTabGroup(
                            new DockableContent[]
                            {
                                new("L1", TextBlock("chrome-left-1"), Key: "ch:l:1"),
                                new("L2", TextBlock("chrome-left-2"), Key: "ch:l:2"),
                            },
                            TabChrome: leftChrome),
                        new DockTabGroup(
                            new DockableContent[]
                            {
                                new("R1", TextBlock("chrome-right-1"), Key: "ch:r:1"),
                                new("R2", TextBlock("chrome-right-2"), Key: "ch:r:2"),
                            },
                            TabChrome: rightChrome),
                    }),
            };

            // ── Mount: Win11 (left) + Flat (right) ──────────────────
            host.Mount(_ => BuildPair(TabChrome.Win11, TabChrome.Flat));
            await Harness.Render();

            var tabs = H.FindAllControls<TabView>(_ => true);
            H.Check("TabChrome_TwoTabViewsMounted", tabs.Count == 2);

            // Pair them by header text. Order isn't guaranteed across
            // FindAllControls iteration; we look for "L1" vs "R1" headers.
            TabView? left  = tabs.FirstOrDefault(tv => HasHeader(tv, "L1"));
            TabView? right = tabs.FirstOrDefault(tv => HasHeader(tv, "R1"));
            H.Check("TabChrome_LeftFound",  left  is not null);
            H.Check("TabChrome_RightFound", right is not null);

            // Win11 — no overrides for any managed key.
            H.Check("TabChrome_Win11_NoCornerRadiusOverride",
                left is not null && !left.Resources.ContainsKey("TabViewItemHeaderCornerRadius"));
            H.Check("TabChrome_Win11_NoPaddingOverride",
                left is not null && !left.Resources.ContainsKey("TabViewItemHeaderPadding"));

            // Flat — zero corner radius + tightened padding.
            H.Check("TabChrome_Flat_HasCornerRadiusOverride",
                right is not null && right.Resources.ContainsKey("TabViewItemHeaderCornerRadius"));
            if (right is not null
                && right.Resources.TryGetValue("TabViewItemHeaderCornerRadius", out var cr)
                && cr is CornerRadius radius)
            {
                // Production sets `new CornerRadius(0)` which produces
                // exact 0.0 doubles, but CodeQL flags any `== 0.0` on a
                // double — use an epsilon to silence the rule without
                // changing the intent ("effectively zero").
                const double epsilon = 1e-9;
                H.Check("TabChrome_Flat_CornerRadiusIsZero",
                    Math.Abs(radius.TopLeft) < epsilon
                    && Math.Abs(radius.TopRight) < epsilon
                    && Math.Abs(radius.BottomLeft) < epsilon
                    && Math.Abs(radius.BottomRight) < epsilon);
            }
            else
            {
                H.Check("TabChrome_Flat_CornerRadiusIsZero", false);
            }

            H.Check("TabChrome_Flat_HasPaddingOverride",
                right is not null && right.Resources.ContainsKey("TabViewItemHeaderPadding"));

            // ── Update: flip right Flat → Win11 (pool blanker) ──────
            host.Mount(_ => BuildPair(TabChrome.Win11, TabChrome.Win11));
            await Harness.Render();

            tabs = H.FindAllControls<TabView>(_ => true);
            right = tabs.FirstOrDefault(tv => HasHeader(tv, "R1"));
            H.Check("TabChrome_FlatToWin11_StillMounted", right is not null);
            H.Check("TabChrome_FlatToWin11_CornerRadiusCleared",
                right is not null && !right.Resources.ContainsKey("TabViewItemHeaderCornerRadius"));
            H.Check("TabChrome_FlatToWin11_PaddingCleared",
                right is not null && !right.Resources.ContainsKey("TabViewItemHeaderPadding"));

            // ── Update: flip to TitleBar — Resources entry for background ──
            // The TitleBar preset only sets TabViewBackground when the app
            // exposes TitleBarBackgroundFillBrush in its resources. The
            // selftest host registers XamlControlsResources, so the brush
            // resolves; assert the key lands.
            host.Mount(_ => BuildPair(TabChrome.TitleBar, TabChrome.Win11));
            await Harness.Render();

            tabs = H.FindAllControls<TabView>(_ => true);
            left = tabs.FirstOrDefault(tv => HasHeader(tv, "L1"));
            H.Check("TabChrome_TitleBar_LeftRemounted", left is not null);
            // Background may or may not resolve depending on theme stack —
            // assert tolerantly: either it's present (real app), or absent
            // (running before XamlControlsResources binds). The pool-safe
            // contract is that no _other_ managed key is set.
            if (left is not null)
            {
                H.Check("TabChrome_TitleBar_NoCornerRadiusOverride",
                    !left.Resources.ContainsKey("TabViewItemHeaderCornerRadius"));
                H.Check("TabChrome_TitleBar_NoPaddingOverride",
                    !left.Resources.ContainsKey("TabViewItemHeaderPadding"));
            }

            host.Mount(_ => TextBlock("chrome-done"));
            await Harness.Render();
        }

        // Walk a TabView's items and check if any header (string Header
        // or StackPanel with a TextBlock) matches `header`.
        private static bool HasHeader(TabView tv, string header)
        {
            foreach (var tvi in tv.TabItems.OfType<TabViewItem>())
            {
                if (tvi.Header is string s && s == header) return true;
                if (tvi.Header is StackPanel sp)
                {
                    foreach (var tb in sp.Children.OfType<TextBlock>())
                    {
                        if (tb.Text == header) return true;
                    }
                }
            }
            return false;
        }
    }

    /// <summary>
    /// Spec 045 §4.2 / §4.3 — floating dockable windows render the
    /// <c>DockTabGroup</c> tab strip directly into the OS title-bar
    /// zone (Edge / Files / VS Code pattern). The fixture opens a
    /// floating window with one pane and asserts:
    ///   • the window has <c>ExtendsContentIntoTitleBar=true</c>
    ///   • a WinUI <c>TabView</c> sits at the root (no separate
    ///     WinUI 3 <c>TitleBar</c> control wrapping it)
    ///   • the TabView has a <c>TabStripFooter</c> (drag region
    ///     handed to <c>Window.SetTitleBar</c> on mount)
    ///   • the pane body is reachable
    /// </summary>
    internal class FloatingWindow_TitleBarChromeAndTabsInTitleBar(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            host.Mount(_ => new DockManager
            {
                Layout = new DockTabGroup(new[]
                {
                    new DockableContent("Center", TextBlock("center-body"), Key: "k:center"),
                }),
            });
            await Harness.Render();

            var pane = new DockableContent(
                Title: "Floater",
                Key: "k:tb-float",
                Content: TextBlock("floating-tb-body"));

            var savedPolicy = ReactorApp.ShutdownPolicy;
            ReactorApp.ShutdownPolicy = ShutdownPolicy.Explicit;
            try
            {
                var floatingWindow = DockFloatingWindow.Open(pane, width: 600, height: 400);
                await Harness.Render();
                H.Check("FloatingTitleBar_WindowOpened", floatingWindow is not null);

                // §4.2 — ExtendsContentIntoTitleBar must be set by Open()
                // so the tab strip occupies the title-bar zone.
                H.Check("FloatingTitleBar_ExtendsContentIntoTitleBar",
                    floatingWindow!.NativeWindow.ExtendsContentIntoTitleBar);

                // Walk the floating window's visual tree (Harness.FindAllControls
                // searches the harness's main window only).
                var content = floatingWindow.NativeWindow.Content as DependencyObject;
                H.Check("FloatingTitleBar_HasContent", content is not null);

                // §4.3 — Edge pattern: TabView is the root chrome. The
                // WinUI 3 `TitleBar` control is intentionally NOT used
                // (its Content slot can't host a full TabView).
                var tabViews = FindAllInTree<TabView>(content);
                H.Check("FloatingTitleBar_TabViewAtRoot", tabViews.Count == 1);

                var titleBars = FindAllInTree<Microsoft.UI.Xaml.Controls.TitleBar>(content);
                H.Check("FloatingTitleBar_NoSeparateTitleBarControl", titleBars.Count == 0);

                // §4.2 / §4.4 — TabStripFooter holds the drag region;
                // OnMount on this element calls Window.SetTitleBar.
                H.Check("FloatingTitleBar_TabViewHasStripFooter",
                    tabViews.Count == 1 && tabViews[0].TabStripFooter is not null);

                // Pane body must be reachable.
                var bodyTexts = FindAllInTree<TextBlock>(content, t => t.Text == "floating-tb-body");
                H.Check("FloatingTitleBar_PaneBodyVisible", bodyTexts.Count >= 1);

                floatingWindow.Close();
                await Harness.Render();
            }
            finally
            {
                ReactorApp.ShutdownPolicy = savedPolicy;
            }

            host.Mount(_ => TextBlock("floating-tb-done"));
            await Harness.Render();
        }

        private static List<T> FindAllInTree<T>(DependencyObject? root, Func<T, bool>? predicate = null)
            where T : DependencyObject
        {
            var results = new List<T>();
            if (root is not null) Walk(root, predicate, results);
            return results;
        }

        private static void Walk<T>(DependencyObject root, Func<T, bool>? predicate, List<T> results)
            where T : DependencyObject
        {
            if (root is T match && (predicate is null || predicate(match))) results.Add(match);
            int count = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChildrenCount(root);
            for (int i = 0; i < count; i++)
                Walk(Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChild(root, i), predicate, results);
        }
    }

    /// <summary>
    /// Spec 045 §4.2 multi-window isolation — opening two floating
    /// windows concurrently must give each window its own TabView
    /// rendered into its own AppWindow. The OS-level
    /// `Window.SetTitleBar` registration in `BuildFloatingRoot.OnMount`
    /// captures `windowHolder` per-call, so there's no cross-wiring.
    /// </summary>
    internal class FloatingWindow_TitleBarPerWindow_NoCrossWiring(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            host.Mount(_ => new DockManager
            {
                Layout = new DockTabGroup(new[]
                {
                    new DockableContent("Center", TextBlock("multi-center-body"), Key: "k:multi-center"),
                }),
            });
            await Harness.Render();

            var pane1 = new DockableContent("FA", TextBlock("body-a"), Key: "k:fa");
            var pane2 = new DockableContent("FB", TextBlock("body-b"), Key: "k:fb");

            var savedPolicy = ReactorApp.ShutdownPolicy;
            ReactorApp.ShutdownPolicy = ShutdownPolicy.Explicit;
            try
            {
                var w1 = DockFloatingWindow.Open(pane1, width: 500, height: 300);
                var w2 = DockFloatingWindow.Open(pane2, width: 500, height: 300);
                await Harness.Render();

                H.Check("FloatingMulti_W1_ExtendsContent",
                    w1.NativeWindow.ExtendsContentIntoTitleBar);
                H.Check("FloatingMulti_W2_ExtendsContent",
                    w2.NativeWindow.ExtendsContentIntoTitleBar);

                // Each window has its own TabView at the root (Edge
                // tabs-in-titlebar pattern — no separate WinUI 3
                // `TitleBar` control).
                var tv1 = FindFirst<TabView>(w1.NativeWindow.Content as DependencyObject);
                var tv2 = FindFirst<TabView>(w2.NativeWindow.Content as DependencyObject);
                H.Check("FloatingMulti_W1_HasOwnTabView", tv1 is not null);
                H.Check("FloatingMulti_W2_HasOwnTabView", tv2 is not null);
                H.Check("FloatingMulti_TabViewsAreDistinctInstances",
                    tv1 is not null && tv2 is not null && !ReferenceEquals(tv1, tv2));

                // Each window's TabView shows its own pane (no swap).
                H.Check("FloatingMulti_W1_TabHeaderIsFA",
                    tv1 is not null && tv1.TabItems.Count == 1
                    && tv1.TabItems[0] is TabViewItem ti1 && ti1.Header is string h1 && h1 == "FA");
                H.Check("FloatingMulti_W2_TabHeaderIsFB",
                    tv2 is not null && tv2.TabItems.Count == 1
                    && tv2.TabItems[0] is TabViewItem ti2 && ti2.Header is string h2 && h2 == "FB");

                w1.Close();
                w2.Close();
                await Harness.Render();
            }
            finally
            {
                ReactorApp.ShutdownPolicy = savedPolicy;
            }

            host.Mount(_ => TextBlock("floating-multi-done"));
            await Harness.Render();
        }

        private static T? FindFirst<T>(DependencyObject? root) where T : DependencyObject
        {
            if (root is null) return null;
            if (root is T match) return match;
            int count = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChildrenCount(root);
            for (int i = 0; i < count; i++)
            {
                var hit = FindFirst<T>(Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChild(root, i));
                if (hit is not null) return hit;
            }
            return null;
        }
    }

    /// <summary>
    /// Spec 045 §2.4 / §4.2 regression — the Edge-pattern floating root
    /// (TabView with TabStripFooter drag region) must not break the
    /// close-window path. Open a floating window, close it, and assert
    /// the tracker drops it.
    /// </summary>
    internal class FloatingWindow_ClosingLastTabClosesWindow(Harness h) : SelfTestFixtureBase(h)
    {
        public override async Task RunAsync()
        {
            var host = H.CreateHost();
            DockingNativeInterop.Register(host.Reconciler);

            host.Mount(_ => new DockManager
            {
                Layout = new DockTabGroup(new[]
                {
                    new DockableContent("Center", TextBlock("close-center"), Key: "k:close-center"),
                }),
            });
            await Harness.Render();

            var pane = new DockableContent(
                Title: "ToClose",
                Key: "k:to-close",
                Content: TextBlock("close-floating-body"),
                CanClose: true);

            var savedPolicy = ReactorApp.ShutdownPolicy;
            ReactorApp.ShutdownPolicy = ShutdownPolicy.Explicit;
            try
            {
                var baseline = DockFloatingTracker.Count;
                var floatingWindow = DockFloatingWindow.Open(pane, width: 500, height: 300);
                await Harness.Render();
                H.Check("FloatingClose_RegisteredOnOpen",
                    DockFloatingTracker.Count == baseline + 1);

                // Window's TabView (root chrome) must still be
                // reachable — guards against tree-shape regressions.
                var contentRoot = floatingWindow.NativeWindow.Content as DependencyObject;
                var tabView = FindFirst<TabView>(contentRoot);
                H.Check("FloatingClose_TabViewReachable", tabView is not null);

                floatingWindow.Close();
                await Harness.Render();

                H.Check("FloatingClose_WindowRemovedAfterClose",
                    DockFloatingTracker.Count == baseline);
            }
            finally
            {
                ReactorApp.ShutdownPolicy = savedPolicy;
            }

            host.Mount(_ => TextBlock("floating-close-done"));
            await Harness.Render();
        }

        private static T? FindFirst<T>(DependencyObject? root) where T : DependencyObject
        {
            if (root is null) return null;
            if (root is T match) return match;
            int count = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChildrenCount(root);
            for (int i = 0; i < count; i++)
            {
                var hit = FindFirst<T>(Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChild(root, i));
                if (hit is not null) return hit;
            }
            return null;
        }
    }
}