fix(treeview): AOT-robust Update reconcile + bounded initial-host handler

Two follow-ups after the initial-hosting fix landed under AOT:

1. TTV_KeyedUpdate failed under AOT because the Update path reconciled a
   matched node's view via list.ContainerFromItem(node) cast to TreeViewItem —
   ContainerFromItem doesn't resolve under NativeAOT and the container can be
   the base ListViewItem. Rework: decouple the structure diff from the view
   reconcile. DiffTemplatedTreeNodes now only updates the node hierarchy +
   node.Content; a separate RefreshRealizedTreeContainers pass walks the
   flattened ListView.Items by index (the AOT-robust lookup) and reconciles
   each realized container's view against its node's current data, at any depth.

2. Bound the initial-population LayoutUpdated handler to a fixed number of
   passes so it always detaches (CCC covers anything not yet hosted), avoiding
   any dangling per-list subscription.

JIT self-test green.

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

Author: codemonkeychris

src/Reactor/Core/Reconciler.Mount.cs

@@ -2058,13 +2058,16 @@ private void AttachTypedTreeHosting(WinUI.TreeView treeView, Action requestReren
         // later — observed under NativeAOT, where the realized container is even
         // still the base ListViewItem at Loaded time), so re-attempt on
         // LayoutUpdated until every realized container is hosted, then detach.
-        // Everything realized AFTER this point flows through CCC.
+        // Everything realized AFTER this point flows through CCC. The pass count
+        // is bounded so the handler always detaches (no dangling subscription),
+        // and CCC still covers anything not hosted by then.
         if (!PopulateRealizedTreeContainers(treeView, list, requestRerender))
         {
+            int passesLeft = 8;
             EventHandler<object>? onLayout = null;
             onLayout = (_, _) =>
             {
-                if (PopulateRealizedTreeContainers(treeView, list, requestRerender))
+                if (PopulateRealizedTreeContainers(treeView, list, requestRerender) || --passesLeft <= 0)
                     list.LayoutUpdated -= onLayout;
             };
             list.LayoutUpdated += onLayout;

src/Reactor/Core/Reconciler.Update.cs

@@ -4104,12 +4104,13 @@ private void ReconcileTreeNodeContent(
     /// </summary>
     private UIElement? UpdateTemplatedTreeView(TemplatedTreeViewElementBase o, TemplatedTreeViewElementBase n, WinUI.TreeView tv, Action requestRerender)
     {
-        // The internal list (if realized) lets us reconcile the views of
-        // currently-realized containers. Unrealized nodes need no work — their
-        // view is (re)built fresh from node.Content when they next realize.
-        var list = FindTypedTreeListControl(tv);
-
-        DiffTemplatedTreeNodes(tv.RootNodes, list, o, o.GetRoots(), n, n.GetRoots(), requestRerender);
+        // Diff the node hierarchy (structure + each node's data item). The view
+        // reconcile is a separate flat pass over the realized containers below —
+        // keeping the two concerns decoupled, and using the index-based container
+        // lookup that works under NativeAOT (ContainerFromItem does not resolve
+        // there, and a freshly-realized container can still be the base
+        // ListViewItem rather than TreeViewItem).
+        DiffTemplatedTreeNodes(tv.RootNodes, o, o.GetRoots(), n, n.GetRoots());
 
         tv.SelectionMode = n.GetSelectionMode();
         tv.CanDragItems = n.GetCanDragItems();
@@ -4118,9 +4119,45 @@ private void ReconcileTreeNodeContent(
 
         SetElementTag(tv, n);
         n.ApplyControlSetters(tv);
+
+        // Reconcile the view of every currently-realized container against its
+        // node's (now-updated) data. Unrealized nodes need no work — their view
+        // is (re)built fresh from node.Content when they next realize via CCC.
+        RefreshRealizedTreeContainers(tv, FindTypedTreeListControl(tv), n, requestRerender);
         return null;
     }
 
+    /// <summary>
+    /// Reconciles the hosted view of every realized container against its node's
+    /// current <c>node.Content</c> data. Iterates the flattened
+    /// <see cref="WinUI.ListView.Items"/> via index (the AOT-robust lookup), so
+    /// it covers visible nodes at every depth in one pass.
+    /// </summary>
+    private void RefreshRealizedTreeContainers(WinUI.TreeView tv, WinUI.ListView? list, TemplatedTreeViewElementBase n, Action requestRerender)
+    {
+        if (list is null) return;
+        for (int i = 0; i < list.Items.Count; i++)
+        {
+            if (list.ContainerFromIndex(i) is not ContentControl container) continue;
+            if (container.ContentTemplateRoot is not ContentControl cc) continue;
+            if (list.Items[i] is not WinUI.TreeViewNode node || node.Content is not { } data) continue;
+
+            var newView = n.BuildView(data);
+            if (cc.Content is UIElement existing && GetElementTag(cc) is Element oldView && CanUpdate(oldView, newView))
+            {
+                var replacement = Update(oldView, newView, existing, requestRerender);
+                if (replacement is not null && !ReferenceEquals(cc.Content, replacement))
+                    cc.Content = replacement;
+            }
+            else
+            {
+                if (cc.Content is UIElement old) UnmountChild(old);
+                cc.Content = Mount(newView, requestRerender);
+            }
+            SetElementTag(cc, newView);
+        }
+    }
+
     private static readonly object[] s_emptyTreeItems = [];
 
     /// <summary>
@@ -4134,10 +4171,8 @@ private void ReconcileTreeNodeContent(
     /// </summary>
     private void DiffTemplatedTreeNodes(
         IList<WinUI.TreeViewNode> liveNodes,
-        WinUI.ListView? list,
         TemplatedTreeViewElementBase oldEl, IReadOnlyList<object> oldItems,
-        TemplatedTreeViewElementBase newEl, IReadOnlyList<object> newItems,
-        Action requestRerender)
+        TemplatedTreeViewElementBase newEl, IReadOnlyList<object> newItems)
     {
         // Snapshot: map old key → (live node, old item). Live nodes correspond
         // 1:1 to oldItems in order.
@@ -4161,13 +4196,10 @@ private void DiffTemplatedTreeNodes(
                 bool expanded = newEl.GetIsExpanded(newItem);
                 if (node.IsExpanded != expanded) node.IsExpanded = expanded;
 
-                ReconcileRealizedTreeContainer(list, node, newEl, newItem, requestRerender);
-
                 DiffTemplatedTreeNodes(
-                    node.Children, list,
+                    node.Children,
                     oldEl, oldEl.GetChildren(match.OldItem) ?? s_emptyTreeItems,
-                    newEl, newEl.GetChildren(newItem) ?? s_emptyTreeItems,
-                    requestRerender);
+                    newEl, newEl.GetChildren(newItem) ?? s_emptyTreeItems);
 
                 target.Add(node);
             }
@@ -4206,33 +4238,6 @@ private static int IndexOfNode(IList<WinUI.TreeViewNode> nodes, WinUI.TreeViewNo
         return -1;
     }
 
-    /// <summary>
-    /// Reconciles the view hosted in a matched node's realized container (if it
-    /// is currently realized). Updates in place when the old/new views are
-    /// compatible, otherwise unmounts and re-mounts. Unrealized nodes are
-    /// skipped — they rebuild fresh from <c>node.Content</c> on next realization.
-    /// </summary>
-    private void ReconcileRealizedTreeContainer(
-        WinUI.ListView? list, WinUI.TreeViewNode node, TemplatedTreeViewElementBase newEl, object newItem, Action requestRerender)
-    {
-        if (list?.ContainerFromItem(node) is not WinUI.TreeViewItem container) return;
-        if (container.ContentTemplateRoot is not ContentControl cc) return;
-
-        var newView = newEl.BuildView(newItem);
-        if (cc.Content is UIElement existing && GetElementTag(cc) is Element oldView && CanUpdate(oldView, newView))
-        {
-            var replacement = Update(oldView, newView, existing, requestRerender);
-            if (replacement is not null && !ReferenceEquals(cc.Content, replacement))
-                cc.Content = replacement;
-        }
-        else
-        {
-            if (cc.Content is UIElement old) UnmountChild(old);
-            cc.Content = Mount(newView, requestRerender);
-        }
-        SetElementTag(cc, newView);
-    }
-
     private UIElement? UpdateRectangle(RectangleElement n, WinShapes.Rectangle r)
     {
         if (n.Fill is not null) r.Fill = n.Fill;