fix(treeview): CI — add typed-tree fluents + robust container-hosting attach

Two CI failures on the typed TreeView<T> change:

Unit Tests — PublicApiSurfaceGuardTests.EveryCallbackPropertyHasMatchingFluent
required every Action/Action<T> callback property to have a matching fluent
extension. Add `.ItemInvoked<T>` / `.Expanding<T>` for TemplatedTreeViewElement<T>
in ElementExtensions.Events.cs (mirrors the existing TreeViewElement fluents).

AOT Selftests — every visual-render TTV_ assertion failed while element-level
ones passed: node views were never hosted. Hosting was deferred to the
TreeView's Loaded event, which (unlike the typed ListView, which subscribes to
ContainerContentChanging at mount) does not fire reliably in the headless AOT
host before the fixture asserts. The internal TreeViewList only exists after the
template applies, so we can't subscribe at mount — instead drive the attach from
a bounded dispatcher retry that lands on the first pump (creating the
subscription before/around the first realization and catching any later
realization within the same render), with Loaded kept only as a backup for the
show-later case (e.g. a tree in an unselected tab). FindTypedTreeListControl no
longer writes the subscription-marker cache (read-only on the Update path).

Full self-test suite green (4454 ok, 0 failures).

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

Author: codemonkeychris

src/Reactor/Core/Reconciler.Mount.cs

@@ -2007,10 +2007,19 @@ private WinUI.TreeView MountTemplatedTreeView(TemplatedTreeViewElementBase el, A
         treeView.ItemInvoked += TemplatedTreeItemInvoked;
         treeView.Expanding += TemplatedTreeExpanding;
 
-        // The internal TreeViewList ("ListControl") only exists once the
-        // template applies (after the control enters the visual tree). Hook its
-        // ContainerContentChanging on Loaded, then populate the already-realized
-        // initial containers (which materialized before we could subscribe).
+        // 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);
         treeView.Loaded += (s, _) => AttachTypedTreeHosting((WinUI.TreeView)s!, requestRerender);
 
         el.ApplyControlSetters(treeView);
@@ -2033,26 +2042,48 @@ 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. Idempotent across Loaded/Unloaded cycles.
+    /// (once) and populates any containers that realized before the subscription.
+    /// Returns true once attached. Idempotent — presence in
+    /// <see cref="_typedTreeListControls"/> marks "already subscribed".
     /// </summary>
-    private void AttachTypedTreeHosting(WinUI.TreeView treeView, Action requestRerender)
+    private bool TryAttachTypedTreeHosting(WinUI.TreeView treeView, Action requestRerender)
     {
-        // FindTypedTreeListControl caches; if it was already cached the
-        // subscription is already in place — don't double-subscribe.
-        if (_typedTreeListControls.TryGetValue(treeView, out _)) return;
-        var list = FindTypedTreeListControl(treeView);
-        if (list is null) return;
+        if (_typedTreeListControls.TryGetValue(treeView, out _)) return true; // already subscribed
 
+        var list = FindDescendantListView(treeView);
+        if (list is null) return false; // template not applied yet
+
+        _typedTreeListControls.Add(treeView, list); // mark subscribed + cache for Update
         list.ContainerContentChanging += (_, args) =>
             OnTypedTreeContainerContentChanging(treeView, args, requestRerender);
 
-        // Populate the initial visible containers that realized before we hooked.
+        // Populate any containers that already realized before we subscribed.
         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>

src/Reactor/Core/Reconciler.cs

@@ -2026,17 +2026,16 @@ private void UnmountTypedTreeViewContainersRecursive(DependencyObject node)
 
     /// <summary>
     /// Finds the typed TreeView's internal <c>TreeViewList</c> (template part
-    /// "ListControl", a public <see cref="WinUI.ListView"/> subclass) by walking
-    /// the visual subtree. Cached per TreeView in <see cref="_typedTreeListControls"/>.
+    /// "ListControl", a public <see cref="WinUI.ListView"/> subclass). Returns
+    /// the cached instance when hosting is already attached; otherwise walks the
+    /// visual subtree without caching — only <c>AttachTypedTreeHosting</c> writes
+    /// <see cref="_typedTreeListControls"/> (its presence marks "subscribed", so
+    /// a read-side cache write here would suppress the real subscription).
     /// </summary>
-    internal WinUI.ListView? FindTypedTreeListControl(WinUI.TreeView treeView)
-    {
-        if (_typedTreeListControls.TryGetValue(treeView, out var cached))
-            return cached;
-        var found = FindDescendantListView(treeView);
-        if (found is not null) _typedTreeListControls.Add(treeView, found);
-        return found;
-    }
+    internal WinUI.ListView? FindTypedTreeListControl(WinUI.TreeView treeView) =>
+        _typedTreeListControls.TryGetValue(treeView, out var cached)
+            ? cached
+            : FindDescendantListView(treeView);
 
     private static WinUI.ListView? FindDescendantListView(DependencyObject root)
     {

src/Reactor/Elements/ElementExtensions.Events.cs

@@ -291,6 +291,14 @@ public static TreeViewElement ItemInvoked(this TreeViewElement el, Action<TreeVi
     public static TreeViewElement Expanding(this TreeViewElement el, Action<TreeViewNodeData>? handler) =>
         el with { OnExpanding = handler };
 
+    /// <summary>Wires the item-invoked handler for the typed tree (receives the developer's <c>T</c>). Passing <c>null</c> clears.</summary>
+    public static TemplatedTreeViewElement<T> ItemInvoked<T>(this TemplatedTreeViewElement<T> el, Action<T>? handler) =>
+        el with { OnItemInvoked = handler };
+
+    /// <summary>Wires the expanding handler for the typed tree (receives the developer's <c>T</c>). Passing <c>null</c> clears.</summary>
+    public static TemplatedTreeViewElement<T> Expanding<T>(this TemplatedTreeViewElement<T> el, Action<T>? handler) =>
+        el with { OnExpanding = handler };
+
     /// <summary>Wires the selected-index-changed handler. Passing <c>null</c> clears.</summary>
     public static FlipViewElement SelectedIndexChanged(this FlipViewElement el, Action<int>? handler) =>
         el with { OnSelectedIndexChanged = handler };