spec(047): Phase 3-final Batch G-prep — ItemsHost typing + descriptor-side ordering

Two engine fixes uncovered by the first Batch G1 attempt (which reverted
clean rather than ship broken). ItemsHost is now usable for descriptor
authors; flat-items ports (ListBox / ComboBox / RadioButtons in G1) and
typed templated lists (G2 keyed-reconcile shape, deferred) build on top.

Changes:
- ChildrenStrategy.ItemsHost.GetCollection signature: System.Collections.IList -> IList<object>.
  WinUI Microsoft.UI.Xaml.Controls.ItemCollection does not implement
  the non-generic IList projection under CsWinRT; a descriptor reaching
  for c.Items hit InvalidCastException at runtime. IList<object> is the
  projected interface ItemCollection actually exposes.
- DescriptorHandler.Mount / Update now dispatch ItemsHost INLINE between
  RentControl and the prop loop (Mount), and before the prop Update loop
  (Update). Selection-tracking initial writes (SelectedIndex /
  SelectedItem) need the collection in its final shape first — WinUI
  silently clamps selection against an empty collection. The strategy
  shape is unchanged; descriptors using ItemsHost simply get the items
  populated first, matching legacy MountListBox ordering.
  DescriptorHandler.Children returns null when the strategy is
  ItemsHost so V1HandlerAdapter doesn't double-dispatch.
- V1HandlerAdapter ItemsHost branches kept for hand-coded handlers
  (none today) and updated for the IList<object> typing.

Keyed-reconcile path (originally planned as part of G-prep for Batch G2)
deferred: typed templated lists need ReactorListState + KeyedListDiff
integration plus a Reconciler.BindKeyedItemsSource helper, which is
substantial engine work better landed alongside its consumer rather
than blind.

V1 ON: 511 ok / 0 failures
V1 OFF: 511 ok / 0 failures

Author: codemonkeychris

src/Reactor/Core/V1Protocol/ChildrenStrategy.cs

@@ -135,7 +135,7 @@ public sealed record NamedSlot<TElement, TControl>(
 [Experimental("REACTOR_V1_PREVIEW")]
 public sealed record ItemsHost<TElement, TControl>(
     Func<TElement, IReadOnlyList<object>> GetItems,
-    Func<TControl, global::System.Collections.IList> GetCollection) : ChildrenStrategy<TElement, TControl>
+    Func<TControl, IList<object>> GetCollection) : ChildrenStrategy<TElement, TControl>
     where TElement : Element
     where TControl : UIElement
 {

src/Reactor/Core/V1Protocol/Descriptor/DescriptorHandler.cs

@@ -47,12 +47,29 @@ public DescriptorHandler(ControlDescriptor<TElement, TControl> descriptor)
     /// and bench harnesses — not part of the steady-state author API.</summary>
     public ControlDescriptor<TElement, TControl> Descriptor => _descriptor;
 
-    public ChildrenStrategy<TElement, TControl>? Children => _descriptor.Children;
+    /// <summary>
+    /// Children strategy surfaced to <see cref="V1HandlerAdapter{TElement,TControl}"/>.
+    /// Returns the descriptor's strategy except when it's an
+    /// <see cref="ItemsHost{TElement,TControl}"/> — that one is dispatched
+    /// inline by <see cref="Mount"/> / <see cref="Update"/> before the prop
+    /// loop runs so initial writes like <c>SelectedIndex</c> land against a
+    /// populated collection (matches legacy mount ordering).
+    /// </summary>
+    public ChildrenStrategy<TElement, TControl>? Children =>
+        _descriptor.Children is ItemsHost<TElement, TControl> ? null : _descriptor.Children;
 
     public TControl Mount(MountContext ctx, TElement el)
     {
         var ctrl = ctx.RentControl(_descriptor.PoolPolicy, _descriptor.Factory);
 
+        // §14 Phase 3-final: when the descriptor declares an ItemsHost,
+        // populate the items collection BEFORE the prop loop. Initial writes
+        // for selection-tracking props (SelectedIndex/SelectedItem) need the
+        // collection populated first — WinUI silently clamps selection
+        // against an empty collection.
+        if (_descriptor.Children is ItemsHost<TElement, TControl> ih)
+            DispatchItemsHostMount(in ctx, el, ctrl, ih);
+
         // Phase 1: all bare initial writes (no echo possible — subscriptions
         // not yet live). §14 Phase 3-final: dispatch through the
         // context-carrying overload so OneWayBridged entries can reach the
@@ -75,6 +92,12 @@ public TControl Mount(MountContext ctx, TElement el)
 
     public void Update(UpdateContext ctx, TElement oldEl, TElement newEl, TControl ctrl)
     {
+        // §14 Phase 3-final: ItemsHost diff BEFORE prop Update loop, same
+        // ordering rationale as Mount — selection-tracking writes need the
+        // collection in its post-diff shape first.
+        if (_descriptor.Children is ItemsHost<TElement, TControl> ih)
+            DispatchItemsHostUpdate(in ctx, oldEl, newEl, ctrl, ih);
+
         var props = _descriptor.Properties;
         for (int i = 0; i < props.Count; i++)
             props[i].Update(in ctx, ctrl, oldEl, newEl);
@@ -90,4 +113,66 @@ public void Update(UpdateContext ctx, TElement oldEl, TElement newEl, TControl c
         if (getSetters is not null)
             ctx.ApplySetters(getSetters(newEl), ctrl);
     }
+
+    private static void DispatchItemsHostMount(
+        in MountContext ctx, TElement el, TControl ctrl,
+        ItemsHost<TElement, TControl> ih)
+    {
+        var newItems = ih.GetItems(el);
+        var collection = ih.GetCollection(ctrl);
+        if (collection.Count > 0) collection.Clear();
+        for (int i = 0; i < newItems.Count; i++)
+        {
+            var item = newItems[i];
+            if (item is Element childEl)
+            {
+                var mounted = ctx.MountChild(childEl);
+                if (mounted is not null) collection.Add(mounted);
+            }
+            else if (item is not null)
+                collection.Add(item);
+        }
+    }
+
+    private static void DispatchItemsHostUpdate(
+        in UpdateContext ctx, TElement oldEl, TElement newEl, TControl ctrl,
+        ItemsHost<TElement, TControl> ih)
+    {
+        var oldItems = ih.GetItems(oldEl);
+        var newItems = ih.GetItems(newEl);
+        if (ReferenceEquals(oldItems, newItems)) return;
+        var equals = ih.ItemEquals ?? object.Equals;
+        if (oldItems.Count == newItems.Count)
+        {
+            bool same = true;
+            for (int i = 0; i < newItems.Count; i++)
+            {
+                if (!equals(oldItems[i], newItems[i])) { same = false; break; }
+            }
+            if (same) return;
+        }
+        // Structural change — unmount Element items via the reconciler so
+        // any descendant component state is torn down, then rebuild flat.
+        // (Keyed reconcile lands separately for typed templated lists.)
+        var reconciler = ctx.Reconciler;
+        var rerender = ctx.RequestRerender;
+        for (int i = 0; i < oldItems.Count; i++)
+        {
+            if (oldItems[i] is Element oldChild)
+                reconciler.ReconcileV1Child(oldChild, null, null, rerender);
+        }
+        var collection = ih.GetCollection(ctrl);
+        if (collection.Count > 0) collection.Clear();
+        for (int i = 0; i < newItems.Count; i++)
+        {
+            var item = newItems[i];
+            if (item is Element childEl)
+            {
+                var mounted = ctx.MountChild(childEl);
+                if (mounted is not null) collection.Add(mounted);
+            }
+            else if (item is not null)
+                collection.Add(item);
+        }
+    }
 }

src/Reactor/Core/V1Protocol/V1HandlerAdapter.cs

@@ -129,6 +129,11 @@ private static void DispatchChildrenMount(
                 // Typed templated lists (ListView<T>, GridView<T>, etc.) keep
                 // their own delegate-body handlers in Batch G2 with spec-042
                 // keyed reconciliation; ItemsHost is for the flat case only.
+                //
+                // Note: descriptors hit this only via hand-coded handlers —
+                // DescriptorHandler interleaves ItemsHost dispatch between
+                // RentControl and the prop loop so initial writes like
+                // SelectedIndex see a populated collection.
                 var newItems = ih.GetItems(element);
                 var collection = ih.GetCollection(control);
                 if (collection.Count > 0) collection.Clear();