test(treeview): wait for async node-view realization in TTV fixtures (AOT)

The AOT selftest failed deterministically on every TTV_ fixture that asserted
rendered node text after a single Render(), while JIT passed. Root cause is not
a product bug: per-node views host into their containers when the TreeView
realizes them, which lands a dispatcher cycle after mount — and the NativeAOT
host consistently needs one more pump cycle than JIT to get there (visible in
that TTV_AddChild_NewNodeRenders, which already did two render passes, passed
under AOT while the single-Render fixtures did not). Asserting after exactly one
Render() was a test-harness assumption, not a runtime contract.

Fix at the test layer: add a bounded WaitFor(condition) helper that pumps render
passes until the rendered content appears, and use it for the render-dependent
assertions. A genuinely blank/missing row never appears within the budget, so
the regression coverage (including the expand/collapse-cycle test) is preserved.

Also reverts the previous attempt to make hosting robust via a dispatcher-retry
attach: JIT selftests passed with the plain Loaded subscription, so Loaded does
fire in the headless host — the retry addressed a non-issue and is removed.
Hosting is back to subscribing the internal TreeViewList's
ContainerContentChanging on Loaded (idempotent), with no runtime side-effects
added for the test's sake.

Full self-test suite green.

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

Author: codemonkeychris

src/Reactor/Core/Reconciler.Mount.cs

@@ -2009,17 +2009,10 @@ private WinUI.TreeView MountTemplatedTreeView(TemplatedTreeViewElementBase el, A
 
         // Hook the internal TreeViewList ("ListControl") ContainerContentChanging
         // so node views are mounted into their realized containers. The
-        // ListControl only exists once the template applies (after the first
-        // layout, in-tree), so we can't subscribe at mount the way the typed
-        // ListView does. Drive the attach from a bounded dispatcher retry rather
-        // than relying solely on Loaded: Loaded depends on the element being
-        // connected to a live/activated visual tree (it does not fire reliably in
-        // headless hosts), whereas a queued callback drains on the next dispatcher
-        // pump — by which point the first layout has created the ListControl and
-        // realized the initial containers. Loaded stays as a backup for the
-        // show-later case (e.g. a tree inside an unselected tab). The attach is
-        // idempotent (presence in _typedTreeListControls guards it).
-        ScheduleTypedTreeHosting(treeView, requestRerender, attemptsLeft: 12);
+        // ListControl only exists once the template applies (after the control
+        // loads in-tree), so we subscribe on Loaded and populate the
+        // already-realized initial containers there. Loaded also re-attaches
+        // after an Unloaded/Loaded cycle; the attach is idempotent.
         treeView.Loaded += (s, _) => AttachTypedTreeHosting((WinUI.TreeView)s!, requestRerender);
 
         el.ApplyControlSetters(treeView);
@@ -2042,38 +2035,18 @@ private static WinUI.TreeViewNode BuildTemplatedTreeNode(TemplatedTreeViewElemen
         return node;
     }
 
-    /// <summary>
-    /// Attempts to attach hosting; if the internal list isn't realized yet,
-    /// re-queues itself on the dispatcher (up to <paramref name="attemptsLeft"/>
-    /// times) so the subscription lands as soon as the first layout creates the
-    /// ListControl — without depending on the Loaded event.
-    /// </summary>
-    private void ScheduleTypedTreeHosting(WinUI.TreeView treeView, Action requestRerender, int attemptsLeft)
-    {
-        if (TryAttachTypedTreeHosting(treeView, requestRerender)) return;
-        if (attemptsLeft <= 0) return;
-        // DispatcherQueue can be null in odd hosting/teardown states — Loaded
-        // remains the backup path there.
-        treeView.DispatcherQueue?.TryEnqueue(
-            () => ScheduleTypedTreeHosting(treeView, requestRerender, attemptsLeft - 1));
-    }
-
-    /// <summary>Loaded-backup entry point (see <see cref="ScheduleTypedTreeHosting"/>).</summary>
-    private void AttachTypedTreeHosting(WinUI.TreeView treeView, Action requestRerender) =>
-        TryAttachTypedTreeHosting(treeView, requestRerender);
-
     /// <summary>
     /// Subscribes the typed TreeView's internal list to ContainerContentChanging
     /// (once) and populates any containers that realized before the subscription.
-    /// Returns true once attached. Idempotent — presence in
-    /// <see cref="_typedTreeListControls"/> marks "already subscribed".
+    /// Idempotent — presence in <see cref="_typedTreeListControls"/> marks
+    /// "already subscribed", so it's safe to call on every Loaded.
     /// </summary>
-    private bool TryAttachTypedTreeHosting(WinUI.TreeView treeView, Action requestRerender)
+    private void AttachTypedTreeHosting(WinUI.TreeView treeView, Action requestRerender)
     {
-        if (_typedTreeListControls.TryGetValue(treeView, out _)) return true; // already subscribed
+        if (_typedTreeListControls.TryGetValue(treeView, out _)) return; // already subscribed
 
         var list = FindDescendantListView(treeView);
-        if (list is null) return false; // template not applied yet
+        if (list is null) return; // template not applied yet — a later Loaded will retry
 
         _typedTreeListControls.Add(treeView, list); // mark subscribed + cache for Update
         list.ContainerContentChanging += (_, args) =>
@@ -2083,7 +2056,6 @@ private bool TryAttachTypedTreeHosting(WinUI.TreeView treeView, Action requestRe
         for (int i = 0; i < list.Items.Count; i++)
             if (list.ContainerFromIndex(i) is WinUI.TreeViewItem container)
                 PopulateTypedTreeContainer(treeView, container, list.Items[i], requestRerender);
-        return true;
     }
 
     /// <summary>

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

@@ -47,6 +47,21 @@ private static FsNode[] SampleTree() =>
         _ => TextBlock("?"),
     };
 
+    // Per-node views host into their containers when the TreeView realizes them,
+    // which lands on a dispatcher cycle after mount — and the runtime decides how
+    // many pump cycles that takes (the NativeAOT host consistently needs one more
+    // than JIT). Pump render passes until the condition holds rather than
+    // asserting after a single Render(); returns false if it never does.
+    private static async Task<bool> WaitFor(Func<bool> condition, int maxPasses = 15)
+    {
+        for (int i = 0; i < maxPasses; i++)
+        {
+            if (condition()) return true;
+            await Harness.Render();
+        }
+        return condition();
+    }
+
     // ── 1. Rich content actually renders (the core #447 win) ──────────────
     internal class RendersRichContent(Harness h) : SelfTestFixtureBase(h)
     {
@@ -73,16 +88,16 @@ public override async Task RunAsync()
             // The node's view is a live HStack of TextBlocks — not a stringified
             // blank row. Finding the folder name proves the content hosted.
             H.Check("TTV_RendersRichContent_RootNodeVisible",
-                H.FindTextContaining("Documents") is not null);
+                await WaitFor(() => H.FindTextContaining("Documents") is not null));
 
             // The "[D]" prefix only exists inside the rich per-node template —
             // a stringified node could never produce it.
             H.Check("TTV_RendersRichContent_RichTemplateHosted",
-                H.FindText("[D]") is not null);
+                await WaitFor(() => H.FindText("[D]") is not null));
 
             // Expanded child leaf renders too.
             H.Check("TTV_RendersRichContent_ChildLeafVisible",
-                H.FindTextContaining("readme.md") is not null);
+                await WaitFor(() => H.FindTextContaining("readme.md") is not null));
         }
     }
 
@@ -104,8 +119,8 @@ public override async Task RunAsync()
 
             // Both the folder template ("[D]") and the file template ("[F]")
             // are realized from the single switch-based viewBuilder.
-            H.Check("TTV_Heterogeneous_FolderTemplate", H.FindText("[D]") is not null);
-            H.Check("TTV_Heterogeneous_FileTemplate", H.FindText("[F]") is not null);
+            H.Check("TTV_Heterogeneous_FolderTemplate", await WaitFor(() => H.FindText("[D]") is not null));
+            H.Check("TTV_Heterogeneous_FileTemplate", await WaitFor(() => H.FindText("[F]") is not null));
         }
     }
 
@@ -144,20 +159,23 @@ public override async Task RunAsync()
 
             await Harness.Render();
             firstInstance = H.FindControl<WinXC.TreeView>(_ => true);
-            H.Check("TTV_KeyedUpdate_InitialChild", H.FindTextContaining("alpha.txt") is not null);
+            H.Check("TTV_KeyedUpdate_InitialChild",
+                await WaitFor(() => H.FindTextContaining("alpha.txt") is not null));
 
             H.ClickButton("Mutate");
             await Harness.Render();
 
             // With per-container hosting the reused node's view reconciles in
             // place and stays rendered in the visual tree.
             H.Check("TTV_KeyedUpdate_RenamedChildReconciled",
-                H.FindTextContaining("alpha-renamed.txt") is not null);
+                await WaitFor(() => H.FindTextContaining("alpha-renamed.txt") is not null));
+            // The rename has rendered, so the old text is gone ("alpha-renamed.txt"
+            // does not contain the substring "alpha.txt").
             H.Check("TTV_KeyedUpdate_OldTextGone",
                 H.FindTextContaining("alpha.txt") is null);
             // The untouched sibling keeps rendering through the reconcile.
             H.Check("TTV_KeyedUpdate_SiblingPreserved",
-                H.FindTextContaining("beta.txt") is not null);
+                await WaitFor(() => H.FindTextContaining("beta.txt") is not null));
 
             // The reconcile updated the existing control in place rather than
             // remounting a fresh TreeView.
@@ -205,7 +223,7 @@ public override async Task RunAsync()
             H.Check("TTV_AddChild_NodeInserted",
                 tv!.RootNodes[0].Children.Count == 2);
             H.Check("TTV_AddChild_NewNodeRenders",
-                H.FindTextContaining("beta.txt") is not null);
+                await WaitFor(() => H.FindTextContaining("beta.txt") is not null));
         }
     }
 
@@ -272,8 +290,8 @@ public override async Task RunAsync()
             var host = H.CreateHost();
             host.Mount(_ => el);
             await Harness.Render();
-            H.Check("TTV_ValueType_Renders", H.FindTextContaining("#1") is not null);
-            H.Check("TTV_ValueType_ChildRenders", H.FindTextContaining("#10") is not null);
+            H.Check("TTV_ValueType_Renders", await WaitFor(() => H.FindTextContaining("#1") is not null));
+            H.Check("TTV_ValueType_ChildRenders", await WaitFor(() => H.FindTextContaining("#10") is not null));
         }
     }
 
@@ -331,12 +349,13 @@ public override async Task RunAsync()
 
             // Several collapse→expand cycles; after each expand both children
             // must be present (the bug blanked the first child every 2nd cycle).
+            // WaitFor tolerates the realization landing a pump-cycle later, but a
+            // genuinely blank row never appears within the budget → fails.
             for (int cycle = 0; cycle < 4; cycle++)
             {
                 docs.IsExpanded = true;
-                await Harness.Render();
-                bool firstChild = H.FindTextContaining("readme.md") is not null;
-                bool secondChild = H.FindTextContaining("notes.txt") is not null;
+                bool firstChild = await WaitFor(() => H.FindTextContaining("readme.md") is not null);
+                bool secondChild = await WaitFor(() => H.FindTextContaining("notes.txt") is not null);
                 if (!firstChild || !secondChild) allCyclesOk = false;
 
                 docs.IsExpanded = false;
@@ -347,10 +366,9 @@ public override async Task RunAsync()
 
             // Leave it expanded and confirm a final realization renders.
             docs.IsExpanded = true;
-            await Harness.Render();
             H.Check("TTV_Cycle_FinalExpandRenders",
-                H.FindTextContaining("readme.md") is not null
-                && H.FindTextContaining("notes.txt") is not null);
+                await WaitFor(() => H.FindTextContaining("readme.md") is not null)
+                && await WaitFor(() => H.FindTextContaining("notes.txt") is not null));
         }
     }