fix(treeview): stop reconcile from clobbering runtime expansion; keep TreeView<T> hosting declarative

Two expand/collapse fixes:

1. Legacy TreeView (the "expand flashes open then shut" regression that
   repros on main): DiffTreeViewNodes reset each live node's IsExpanded to
   the static TreeViewNodeData value on every reconcile. When a reconcile
   fires after the user toggles a node — e.g. an OnExpanding lazy-load that
   updates state, or any unrelated state change while nodes are data-expanded
   — it snapped the node back to the data's state. Now expansion is treated as
   uncontrolled: the data value is only applied when it actually changes
   between renders, never clobbering the user's (or WinUI's native) toggle.

2. TreeView<T>: applied the same uncontrolled-expansion rule, and reverted the
   experimental ContainerContentChanging hosting back to the declarative
   {Binding Content} template. The imperative host/recycle handler perturbed
   WinUI's synchronous expand pass (manifested as expand opening then closing,
   and child-click collapsing the parent); the binding never perturbs native
   expand/collapse.

Tests: legacy + typed expansion-not-clobbered guards, collapse/expand cycle,
expand-collapsed-node, constrained-viewport expand. Full suite green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: codemonkeychris

src/Reactor/Core/Reconciler.Mount.cs

@@ -1990,9 +1990,12 @@ internal WinUI.TreeView MountTemplatedTreeView(TemplatedTreeViewElementBase tv,
             CanDragItems = tv.CanDragItems,
             AllowDrop = tv.AllowDrop,
             CanReorderItems = tv.CanReorderItems,
-            // Unbound shell; per-node views are hosted/released through the
-            // internal list's ContainerContentChanging (see Loaded below).
-            ItemTemplate = SharedContentControlTemplate.Value,
+            // Each node's mounted view lives in TreeViewNode.Content and is
+            // surfaced by the {Binding Content} ContentControl template — the
+            // node-mode default template can only stringify (issue #447). A
+            // declarative binding (rather than imperative ContainerContentChanging
+            // hosting) keeps native expand/collapse from being perturbed.
+            ItemTemplate = TreeViewContentElementTemplate.Value,
         };
 
         foreach (var root in tv.GetRoots())
@@ -2005,46 +2008,18 @@ internal WinUI.TreeView MountTemplatedTreeView(TemplatedTreeViewElementBase tv,
         if (tv.HasExpanding)
             treeView.Expanding += TemplatedTreeExpanding;
 
-        // The TreeViewList (internal ListView, template part "ListControl")
-        // owns container realization/recycling. Hook its ContainerContentChanging
-        // so a node's mounted view is hosted on realize and its visual parent
-        // released on recycle — the only way to keep a shared live element from
-        // blanking out across collapse/expand under virtualization.
-        treeView.Loaded += static (s, _) =>
-        {
-            var tree = (WinUI.TreeView)s;
-            if (FindInnerList(tree) is not { } list) return;
-            // Idempotent: method-group -= removes the prior subscription if the
-            // tree reloaded, so we never double-host.
-            list.ContainerContentChanging -= TemplatedTreeContainerContentChanging;
-            list.ContainerContentChanging += TemplatedTreeContainerContentChanging;
-
-            // Fill containers already realized before we subscribed.
-            for (int i = 0; i < list.Items.Count; i++)
-                if (list.ContainerFromIndex(i) is WinUI.TreeViewItem tvi
-                    && tvi.ContentTemplateRoot is ContentControl cc
-                    && cc.Content is null
-                    && list.Items[i] is WinUI.TreeViewNode node
-                    && GetTreeNodeView(node) is UIElement view)
-                {
-                    DetachContentHost(view);
-                    cc.Content = view;
-                }
-        };
-
         ApplySetters(tv.SettersErased, treeView);
         return treeView;
     }
 
     private WinUI.TreeViewNode BuildTemplatedTreeNode(
         TemplatedTreeViewElementBase tv, object item, Action requestRerender)
     {
-        // Content holds the data item (identity/stringification); the mounted
-        // view rides on an attached property and is hosted on demand by the
-        // ContainerContentChanging handler.
-        var node = new WinUI.TreeViewNode { IsExpanded = tv.GetIsExpanded(item), Content = item };
+        // Content = the mounted view (surfaced by {Binding Content}); the
+        // originating T rides on an attached property for event resolution.
+        var node = new WinUI.TreeViewNode { IsExpanded = tv.GetIsExpanded(item) };
+        node.Content = Mount(tv.BuildView(item), requestRerender);
         SetTreeNodeItem(node, item);
-        SetTreeNodeView(node, Mount(tv.BuildView(item), requestRerender));
 
         var children = tv.GetChildren(item);
         if (children is not null)
@@ -2053,55 +2028,6 @@ private WinUI.TreeViewNode BuildTemplatedTreeNode(
         return node;
     }
 
-    // Hosts/releases the per-node mounted view as the internal list realizes
-    // and recycles TreeViewItem containers. Not setting args.Handled so the
-    // TreeViewList still applies its own chrome (expand glyph, indentation).
-    //
-    // The host is DEFERRED to a low-priority dispatch (after the synchronous
-    // prepare/layout pass) because mutating container content mid-prepare
-    // perturbs layout and can recycle/re-prepare the expanding node's own
-    // container with a stale IsExpanded — TreeViewList then enqueues a sync
-    // that snaps the node shut ("expand opens & closes"). The recycle release
-    // stays synchronous (always safe). The deferred host re-validates that the
-    // container still belongs to the same node (cc.DataContext) so a container
-    // recycled to another node in the meantime is never mis-hosted.
-    private static void TemplatedTreeContainerContentChanging(
-        Microsoft.UI.Xaml.Controls.ListViewBase sender,
-        Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs args)
-    {
-        if (args.ItemContainer?.ContentTemplateRoot is not ContentControl cc) return;
-        if (args.InRecycleQueue)
-        {
-            cc.Content = null; // release the element's visual parent; view persists on the node
-            return;
-        }
-        if (args.Item is not WinUI.TreeViewNode node) return;
-
-        var dq = cc.DispatcherQueue;
-        if (dq is null) { HostNodeView(cc, node); return; }
-        dq.TryEnqueue(Microsoft.UI.Dispatching.DispatcherQueuePriority.Low, () => HostNodeView(cc, node));
-    }
-
-    private static void HostNodeView(ContentControl cc, WinUI.TreeViewNode node)
-    {
-        // Container may have been recycled to a different node before this ran.
-        if (!ReferenceEquals(cc.DataContext, node)) return;
-        if (GetTreeNodeView(node) is not UIElement view || ReferenceEquals(cc.Content, view)) return;
-        DetachContentHost(view);
-        cc.Content = view;
-    }
-
-    // Releases a view from whatever ContentControl currently hosts it, so it
-    // can be parented elsewhere (a UIElement may have only one visual parent).
-    private static void DetachContentHost(UIElement view)
-    {
-        DependencyObject? p = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetParent(view);
-        while (p is not null and not ContentControl)
-            p = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetParent(p);
-        if (p is ContentControl host && host.Content is not null)
-            host.Content = null;
-    }
-
     private static Microsoft.UI.Xaml.Controls.ListViewBase? FindInnerList(DependencyObject root)
     {
         int n = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChildrenCount(root);

src/Reactor/Core/Reconciler.Update.cs

@@ -4017,7 +4017,13 @@ private void DiffTreeViewNodes(
                 var liveNode = match.Node;
                 var oldNodeData = oldData[match.OldIdx];
 
-                if (liveNode.IsExpanded != nd.IsExpanded)
+                // Uncontrolled expansion: only push the data value when it
+                // actually changed between renders. Otherwise leave the node's
+                // IsExpanded alone, so a reconcile triggered AFTER the user
+                // expands/collapses (e.g. OnExpanding lazy-load, or any state
+                // change) doesn't snap the node back to the static data value —
+                // the "expand flashes open then shut" regression.
+                if (oldNodeData.IsExpanded != nd.IsExpanded && liveNode.IsExpanded != nd.IsExpanded)
                     liveNode.IsExpanded = nd.IsExpanded;
 
                 ReconcileTreeNodeContent(liveNode, oldNodeData, nd, requestRerender);
@@ -4168,10 +4174,13 @@ private void DiffTemplatedTreeNodes(
                 int cur = liveNodes.IndexOf(node);
                 if (cur != i)
                 {
-                    // A move recycles + re-realizes the container; the
-                    // ContainerContentChanging handler re-hosts the view.
+                    // Move: release the live view's parent before re-realizing
+                    // so the bound ContentControl can re-host it at the new slot.
+                    var content = node.Content as UIElement;
+                    if (content is not null) node.Content = null;
                     liveNodes.RemoveAt(cur);
                     liveNodes.Insert(i, node);
+                    if (content is not null) node.Content = content;
                 }
                 ReconcileTemplatedNodeView(node, o, n, newItem, requestRerender);
                 DiffTemplatedTreeNodes(
@@ -4195,29 +4204,19 @@ private void ReconcileTemplatedNodeView(
         var oldItem = GetTreeNodeItem(node);
         var newView = n.BuildView(newItem);
         var oldView = oldItem is not null ? o.BuildView(oldItem) : null;
-        var existing = GetTreeNodeView(node);
 
-        if (oldView is not null && existing is not null && CanUpdate(oldView, newView))
+        if (oldView is not null && node.Content is UIElement existing && CanUpdate(oldView, newView))
         {
-            // In-place update mutates the live element; a realized container is
-            // already showing it, so nothing else to do unless it's replaced.
             var replacement = Update(oldView, newView, existing, requestRerender);
-            if (replacement is not null && !ReferenceEquals(existing, replacement))
-            {
-                SetTreeNodeView(node, replacement);
-                RehostReplacedView(existing, replacement);
-            }
+            if (replacement is not null && !ReferenceEquals(node.Content, replacement))
+                node.Content = replacement;
         }
         else
         {
-            if (existing is not null) UnmountChild(existing);
-            var mounted = Mount(newView, requestRerender);
-            SetTreeNodeView(node, mounted);
-            RehostReplacedView(existing, mounted);
+            if (node.Content is UIElement stale) UnmountChild(stale);
+            node.Content = Mount(newView, requestRerender);
         }
 
-        node.Content = newItem;
-
         // Expansion is uncontrolled: only push the selector value when it
         // actually CHANGES between renders (developer-driven control). Otherwise
         // leave node.IsExpanded alone so the user's own expand/collapse is never
@@ -4230,22 +4229,9 @@ private void ReconcileTemplatedNodeView(
         SetTreeNodeItem(node, newItem);
     }
 
-    // If a node's view was replaced (CanUpdate false) while its container is
-    // realized, swap the new view into the ContentControl currently hosting the
-    // old one so the change is visible without waiting for a recycle.
-    private static void RehostReplacedView(UIElement? oldView, UIElement newView)
-    {
-        if (oldView is null) return;
-        DependencyObject? p = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetParent(oldView);
-        while (p is not null and not WinUI.ContentControl)
-            p = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetParent(p);
-        if (p is WinUI.ContentControl host && ReferenceEquals(host.Content, oldView))
-            host.Content = newView;
-    }
-
     private void UnmountTemplatedTreeNode(WinUI.TreeViewNode node)
     {
-        if (GetTreeNodeView(node) is UIElement ui) UnmountChild(ui);
+        if (node.Content is UIElement ui) UnmountChild(ui);
         foreach (var child in node.Children)
             UnmountTemplatedTreeNode(child);
     }

src/Reactor/Core/Reconciler.cs

@@ -648,28 +648,6 @@ internal static void SetTreeNodeItem(WinUI.TreeViewNode node, object? item) =>
     internal static object? GetTreeNodeItem(WinUI.TreeViewNode node) =>
         node.GetValue(TreeNodeItemAttached.ItemProperty);
 
-    // Holds the node's mounted view for the typed TreeView<T>. The view is
-    // mounted ONCE and persists here across collapse/expand (so component
-    // state survives); the internal list's ContainerContentChanging hosts it
-    // into the realized container's ContentControl on realize and releases it
-    // (Content = null) on recycle. Without that release the shared element
-    // keeps a stale visual parent and the next realization renders blank
-    // (issue #447 follow-up: every-other expand/collapse blanked rows).
-    private static class TreeNodeViewAttached
-    {
-        public static readonly DependencyProperty MountedViewProperty =
-            DependencyProperty.RegisterAttached(
-                "ReactorTreeMountedView",
-                typeof(UIElement),
-                typeof(TreeNodeViewAttached),
-                new PropertyMetadata(null));
-    }
-
-    internal static void SetTreeNodeView(WinUI.TreeViewNode node, UIElement? view) =>
-        node.SetValue(TreeNodeViewAttached.MountedViewProperty, view);
-
-    internal static UIElement? GetTreeNodeView(WinUI.TreeViewNode node) =>
-        node.GetValue(TreeNodeViewAttached.MountedViewProperty) as UIElement;
 
     // ════════════════════════════════════════════════════════════════════
     //  ReactorAttached.StateProperty  (ReactorState)
@@ -2043,7 +2021,7 @@ private void UnmountRecursive(UIElement control)
 
     private void UnmountTemplatedTreeNodeContents(WinUI.TreeViewNode node)
     {
-        if (GetTreeNodeView(node) is UIElement ui) UnmountRecursive(ui);
+        if (node.Content is UIElement ui) UnmountRecursive(ui);
         foreach (var child in node.Children)
             UnmountTemplatedTreeNodeContents(child);
     }

tests/Reactor.AppTests.Host/SelfTest/Fixtures/TemplatedTreeViewFixtures.cs

@@ -288,6 +288,83 @@ public override async Task RunAsync()
         }
     }
 
+    // ── 3e. Constrained-height expand must stick (virtualization race) ───────
+    // Tiny viewport + many children forces container recycling; reproduces the
+    // GUI "expand opens & closes immediately" report.
+    internal sealed class ConstrainedExpandSticks(Harness h) : SelfTestFixtureBase(h)
+    {
+        public override async Task RunAsync()
+        {
+            var kids = new Node[20];
+            for (int i = 0; i < kids.Length; i++) kids[i] = new Node($"k{i}", $"KID_{i}");
+
+            var host = H.CreateHost();
+            host.Mount(_ => (TreeView<Node>(
+                items: new[] { new Node("root", "ROOT", kids) },
+                childrenSelector: Children,
+                viewBuilder: n => Button(n.Label)) with
+            {
+                IsExpanded = _ => false, // root starts collapsed
+            }).Height(90));
+
+            await Harness.Render();
+            var tv = H.FindControl<TreeView>(_ => true);
+            H.Check("TTV_Constrained_Mounted", tv is not null && tv.RootNodes.Count == 1);
+            if (tv is null || tv.RootNodes.Count == 0)
+            {
+                H.Check("TTV_Constrained_StaysExpanded", false);
+                return;
+            }
+
+            var root = tv.RootNodes[0];
+            root.IsExpanded = true;
+            await Harness.Render();
+            await Harness.Render();
+            await Harness.Render();
+
+            H.Check("TTV_Constrained_StaysExpanded", root.IsExpanded);
+        }
+    }
+
+    // ── Legacy TreeView (TreeViewElement): reconcile must not clobber the
+    //    user's runtime expansion back to the static data value (the
+    //    "expand flashes open then shut" regression — repros on main).
+    internal sealed class LegacyExpansionNotClobbered(Harness h) : SelfTestFixtureBase(h)
+    {
+        public override async Task RunAsync()
+        {
+            Action<int>? bump = null;
+            var host = H.CreateHost();
+            host.Mount(ctx =>
+            {
+                var (_, set) = ctx.UseState(0);
+                bump = set;
+                // Data default IsExpanded = false (collapsed).
+                return new TreeViewElement(new[]
+                {
+                    new TreeViewNodeData("root", new[] { new TreeViewNodeData("child") }),
+                });
+            });
+
+            await Harness.Render();
+            var tv = H.FindControl<TreeView>(_ => true);
+            H.Check("LegacyTV_Mounted", tv is not null && tv.RootNodes.Count == 1);
+            if (tv is null || tv.RootNodes.Count == 0)
+            {
+                H.Check("LegacyTV_StaysExpanded", false);
+                return;
+            }
+
+            var root = tv.RootNodes[0];
+            root.IsExpanded = true;   // user expands at runtime
+            bump?.Invoke(1);          // unrelated state change → reconcile (data unchanged)
+            await Harness.Render();
+
+            // Old code reset IsExpanded to the data value (false) → collapse.
+            H.Check("LegacyTV_StaysExpanded", root.IsExpanded);
+        }
+    }
+
     // ── 4. Value-type T (exercises the boxing Project path) ──────────────────
     internal sealed class ValueTypeItems(Harness h) : SelfTestFixtureBase(h)
     {

tests/Reactor.AppTests.Host/SelfTest/SelfTestFixtureRegistry.cs

@@ -1261,6 +1261,8 @@ internal static class SelfTestFixtureRegistry
         "TTV_ExpansionNotClobbered",
         "TTV_CollapseExpandCycle",
         "TTV_ExpandCollapsedNode",
+        "TTV_ConstrainedExpandSticks",
+        "TTV_LegacyExpansionNotClobbered",
         "TTV_ValueTypeItems",
     ];
 
@@ -1273,6 +1275,8 @@ internal static class SelfTestFixtureRegistry
         "TTV_ExpansionNotClobbered" => new TemplatedTreeViewFixtures.ExpansionNotClobbered(harness),
         "TTV_CollapseExpandCycle" => new TemplatedTreeViewFixtures.CollapseExpandCycle(harness),
         "TTV_ExpandCollapsedNode" => new TemplatedTreeViewFixtures.ExpandCollapsedNode(harness),
+        "TTV_ConstrainedExpandSticks" => new TemplatedTreeViewFixtures.ConstrainedExpandSticks(harness),
+        "TTV_LegacyExpansionNotClobbered" => new TemplatedTreeViewFixtures.LegacyExpansionNotClobbered(harness),
         "TTV_ValueTypeItems" => new TemplatedTreeViewFixtures.ValueTypeItems(harness),
         "ErrorBoundary_CatchesRenderError" => new ErrorBoundaryFixtures.CatchesRenderError(harness),
         "ErrorBoundary_Recovery" => new ErrorBoundaryFixtures.Recovery(harness),