spec(047): address PR #440 CR feedback (Copilot reviewer)

* Carve GridViewDescriptor — its ItemsHost<> strategy pre-mounts every
  item into GridView.Items (no virtualization), diverging from legacy
  MountGridView's ItemsSource+CCC lazy realization. A|B tests still
  pass, but production memory/lifecycle would silently regress; closing
  needs hand-coded GridViewHandler or RecyclingItemsHost<> shape.
  Updated coverage table: 75 routed / 12 deferred / 8 primitives.

* Align legacy UpdateNavigationView with V1 NavigationViewDescriptor —
  add PaneDisplayMode, IsSettingsVisible, conditional PaneTitle,
  MenuItems rebuild on ref-change, and SelectedItem re-selection
  (with new FindNavItemByTag helper). Previously legacy only wrote
  a subset of these on update; reviewer correctly flagged the A|B
  divergence for record-with updates that change MenuItems / Selected.

* Fix PreMountedItems<> release fallback at ChildrenStrategy.cs:577 —
  the count-drift path was clamping oldCount=items.Count and continuing
  positional reconciliation, which would index past oldSource bounds
  when items.Count > oldSource.ItemCount or skip stale source items'
  teardown when smaller. Replaced with the same full-rebuild path as
  the type-mismatch release fallback above.

* Doc fix: remove ModifiedElement from the tracker's composition-
  primitive carve list — it's unwrapped before V1/legacy dispatch at
  the top of Reconciler.Mount, not a switch arm; coverage table stays
  at 8 primitives.

Validation: dotnet test 9134/0; full V1 ON selftest 4410/0;
full V1 OFF selftest 4410/0 (each suite required one re-run to clear
the known FloatRoot/Reliability/DockHooks docking flake family).

Ignored 9 github-code-quality bot comments: 8 are integer-valued
double == checks in test fixtures (values are assigned constants,
exact equality is reliable); 1 claims WinUI FontFamily is IDisposable
(it is not).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: codemonkeychris

docs/specs/047-extensible-control-model.md

@@ -1439,14 +1439,14 @@ ARM64 stable-AC re-capture on `LAPTOP-4MEP83VI` remains deferred for the §14 ra
 
 | Bucket | Arms | Notes |
 |---|---:|---|
-| Routed through V1 (Phase 1 handler or Phase 3 descriptor) | 76 | Production dispatch path when V1 ON |
-| Reachable-but-deferred (overlays 7 + NavigationHost 1 + TabView 1 + XamlHost/Page 2) | 11 | Follow-up PR closes these |
+| Routed through V1 (Phase 1 handler or Phase 3 descriptor) | 75 | Production dispatch path when V1 ON |
+| Reachable-but-deferred (overlays 7 + NavigationHost 1 + TabView 1 + GridView 1 + XamlHost/Page 2) | 12 | Follow-up PR closes these |
 | Intentionally above V1 (Reactor composition primitives) | 8 | Permanent carve; Phase 4 keeps legacy arms |
 | **Total switch arms** | **95** | — |
 
-- **Coverage of V1-reachable surface:** 76 / 87 ≈ **87%** (excludes the 8 composition primitives that are permanently above the protocol).
-- **Coverage of all element-type switch arms:** 76 / 95 ≈ **80%**.
-- **Path to 100% reachable:** the next PR ports the 11 deferred (overlays, NavigationHost, TabView gap closure, XamlHost/Page unification). Phase 4 cleanup follows.
+- **Coverage of V1-reachable surface:** 75 / 87 ≈ **86%** (excludes the 8 composition primitives that are permanently above the protocol).
+- **Coverage of all element-type switch arms:** 75 / 95 ≈ **79%**.
+- **Path to 100% reachable:** the next PR ports the 12 deferred (overlays, NavigationHost, TabView gap closure, GridView CCC virtualization, XamlHost/Page unification). Phase 4 cleanup follows.
 
 **Phase 3 finish advisory perf** — Cloud PC x64 re-capture under `docs/specs/047/phase3-results/CPC-ander-YTZ3O-x64-advisory/2026-05-28-phase3-finish-3x5/` (n=15, 3 launches × 5 reps). V1 ON (descriptors) vs V1 OFF (today), against prior `2026-05-27-phase3-closeout-3x5/`:
 

docs/specs/tasks/047-extensible-control-model-implementation.md

@@ -964,10 +964,19 @@ the audit at the end of `spec/047-phase3-finish`:
   up-front into `FlipView.Items` (no `ContainerContentChanging` to
   drive realization) and positionally reconciles via
   `Reconciler.ReconcileV1Child` on Update.
-- **Untyped items hosts (CLOSED — Phase 3 completion):**
-  `GridViewElement` (plain Element[]), `ItemsViewElementBase`,
-  `ItemContainerElement` — all ported as standard descriptors and
-  registered in `RegisterV1BuiltInHandlers`.
+- **Untyped items hosts (CLOSED — Phase 3 completion, partial):**
+  `ItemsViewElementBase`, `ItemContainerElement` — ported as
+  standard descriptors and registered in `RegisterV1BuiltInHandlers`.
+  `GridViewElement` (plain Element[]) — descriptor authored
+  (`GridViewDescriptor`) but **carved during PR #440 CR**: the
+  descriptor's `ItemsHost<>` strategy pre-mounts every item into
+  `GridView.Items` (one container per item, no virtualization),
+  while the legacy `MountGridView` arm uses
+  `ItemsSource = Range(0..N) + ItemTemplate + ContainerContentChanging`
+  to realize containers lazily (matches Phase 1 `ListViewHandler`).
+  Closing this needs either a hand-coded `GridViewHandler` or a new
+  ChildrenStrategy variant wrapping CCC. Tracked alongside TabView /
+  overlays / NavigationHost gap-closure.
 - **Heavy / specialized controls (CLOSED — Phase 3 completion):**
   `WebView2Element`, `NavigationViewElement`, `TitleBarElement`,
   `MediaPlayerElementElement`, `AnimatedVisualPlayerElement`,
@@ -1010,6 +1019,19 @@ scoped carve list documented inline in `RegisterV1BuiltInHandlers`):**
   Closing them requires engine work (post-children mount-hook so
   `SelectionChanged` subscribes after children-add + an
   `ImperativeBridged` shape for the named tab strip slots).
+- **`GridViewDescriptor` (descriptor exists, registration carved
+  during PR #440 CR):** The descriptor's `ItemsHost<>` ChildrenStrategy
+  pre-mounts every item into `GridView.Items` (one container per item,
+  no virtualization). The legacy `MountGridView` arm uses
+  `ItemsSource = Range(0..N) + ItemTemplate + ContainerContentChanging`
+  to realize containers lazily — matching Phase 1
+  `ListViewHandler`. A|B tests pass either way (no fixture stresses
+  GridView scale), but production memory/lifecycle would silently
+  regress. Closing this needs either a hand-coded `GridViewHandler`
+  mirroring `ListViewHandler`'s CCC virtualization, or a new
+  ChildrenStrategy variant (e.g. `RecyclingItemsHost<>`) that wraps
+  the `ItemsSource` + `ContainerContentChanging` realization
+  contract.
 - **Interop bridges:** `XamlHostElement`, `XamlPageElement`. V1
   descriptors exist (`XamlHostDescriptor`, `XamlPageDescriptor`)
   but stay unregistered because `XamlInterop.Register(reconciler)`
@@ -1021,11 +1043,15 @@ scoped carve list documented inline in `RegisterV1BuiltInHandlers`):**
 protocol — Phase 4 cleanup keeps their legacy arms):**
 
 - `ComponentElement`, `FuncElement`, `MemoElement`,
-  `ErrorBoundaryElement`, `CommandHostElement`, `ModifiedElement`,
+  `ErrorBoundaryElement`, `CommandHostElement`,
   `Validation.FormFieldElement` /
   `ValidationVisualizerElement` / `ValidationRuleElement`. These
   orchestrate child reconciliation rather than wrap a single WinUI
   control, so the V1 handler protocol does not apply.
+  (`ModifiedElement` is intentionally NOT in this list — it's
+  unwrapped to its wrapped element BEFORE dispatch at the top of
+  `Reconciler.Mount`, so it never reaches the switch and does not
+  count as a carved arm.)
 
 **Phase 3 completion status (PR #440 — landed-pending-merge):**
 Every element type in the production codebase either (a) routes
@@ -1046,21 +1072,22 @@ follow-up PRs land.
 
 | Bucket | Arms | % of total |
 |---|---:|---:|
-| Routed through V1 (76 = 5 Phase 1 + 6 base-derived + 64 standard descriptors + 1 decorator) | 76 | 80% |
-| Reachable-but-deferred (overlays 7, NavigationHost 1, TabView 1, XamlHost/Page 2) | 11 | 11.6% |
+| Routed through V1 (75 = 5 Phase 1 + 6 base-derived + 63 standard descriptors + 1 decorator) | 75 | 79% |
+| Reachable-but-deferred (overlays 7, NavigationHost 1, TabView 1, GridView 1, XamlHost/Page 2) | 12 | 12.6% |
 | Intentionally above V1 (composition primitives — permanent carve) | 8 | 8.4% |
 | **Total `Reconciler.Mount.cs` switch arms** | **95** | **100%** |
 
-- **Coverage of V1-reachable surface (excludes 8 composition primitives):** 76 / 87 ≈ **87%**.
-- **Coverage of all switch arms:** 76 / 95 ≈ **80%**.
-- **Path to 100% reachable:** the follow-up PR closes the 11 deferred:
+- **Coverage of V1-reachable surface (excludes 8 composition primitives):** 75 / 87 ≈ **86%**.
+- **Coverage of all switch arms:** 75 / 95 ≈ **79%**.
+- **Path to 100% reachable:** the follow-up PR closes the 12 deferred:
   1. Port the 7 overlay descriptors (ContentDialog, Flyout, Popup, MenuBar, MenuFlyout, CommandBar, CommandBarFlyout) — needs a decorator strategy variant for modal lifecycle beyond `IDecoratorElementHandler`.
   2. Refactor `NavigationHostElement` cleanup path so V1 can own it (internal-expose `MountNavigationHost` / `UpdateNavigationHost`, duplicate cleanup logic in the V1 handler, remove the `UnmountRecursive` intercept).
   3. Close `TabViewDescriptor` gaps (engine post-children mount-hook + `ImperativeBridged` for named slots + port `BuildTabHeader` / `BuildPinButton` / `TryUpdatePinHeaderInPlace` + drag pipeline trampolines + conditional `SelectedIndex` write + in-place `CanUpdate`).
-  4. Unify `XamlInterop.Register` with V1 auto-registration so `XamlHostElement` / `XamlPageElement` descriptors can register without `EnsureRegistrableElementType` clash.
+  4. Close `GridViewDescriptor` lifecycle gap — either author a Phase 1 hand-coded `GridViewHandler` mirroring `ListViewHandler`'s CCC virtualization, or introduce a `RecyclingItemsHost<>` ChildrenStrategy variant.
+  5. Unify `XamlInterop.Register` with V1 auto-registration so `XamlHostElement` / `XamlPageElement` descriptors can register without `EnsureRegistrableElementType` clash.
 
 Phase 4 cleanup (deletion of legacy switch arms + `UseV1Protocol`
-flag) is unblocked for the 76 routed arms today; the remaining 11
+flag) is unblocked for the 75 routed arms today; the remaining 12
 arms unblock as the follow-up PR lands each closure.
 
 **Carry-forward known defects** (from Phase 1):

src/Reactor/Core/Reconciler.Update.cs

@@ -1739,10 +1739,29 @@ void FinalizeOldPage(UIElement? oldCtrl, Element? oldElem, object? oldRoute)
     private UIElement? UpdateNavigationView(NavigationViewElement o, NavigationViewElement n, WinUI.NavigationView nv, Action requestRerender)
     {
         nv.IsPaneOpen = n.IsPaneOpen; nv.IsBackEnabled = n.IsBackEnabled;
+        // Spec 047 §14 Phase 3 completion CR — match V1 NavigationViewDescriptor
+        // (PaneDisplayMode / IsSettingsVisible / PaneTitle / MenuItems / SelectedItem
+        // were previously update-only on the V1 path). Aligning the legacy arm so
+        // V1 ON ≡ V1 OFF for record-with updates that change any of these fields.
+        nv.PaneDisplayMode = n.PaneDisplayMode;
+        nv.IsSettingsVisible = n.IsSettingsVisible;
+        if (n.PaneTitle is not null && nv.PaneTitle != n.PaneTitle) nv.PaneTitle = n.PaneTitle;
         if (!double.IsNaN(n.OpenPaneLength) && nv.OpenPaneLength != n.OpenPaneLength) nv.OpenPaneLength = n.OpenPaneLength;
         if (!double.IsNaN(n.CompactModeThresholdWidth) && nv.CompactModeThresholdWidth != n.CompactModeThresholdWidth) nv.CompactModeThresholdWidth = n.CompactModeThresholdWidth;
         if (!double.IsNaN(n.ExpandedModeThresholdWidth) && nv.ExpandedModeThresholdWidth != n.ExpandedModeThresholdWidth) nv.ExpandedModeThresholdWidth = n.ExpandedModeThresholdWidth;
 
+        if (!ReferenceEquals(o.MenuItems, n.MenuItems))
+        {
+            nv.MenuItems.Clear();
+            foreach (var item in n.MenuItems)
+            {
+                if (item.IsHeader)
+                    nv.MenuItems.Add(new WinUI.NavigationViewItemHeader { Content = item.Content });
+                else
+                    nv.MenuItems.Add(CreateNavItem(item));
+            }
+        }
+
         // AutoSuggestBox / PaneFooter / PaneCustomContent reconcile in place
         // when possible so the controls keep focus / scroll state across re-renders.
         ReconcileChild(o.AutoSuggestBox, n.AutoSuggestBox,
@@ -1782,6 +1801,13 @@ void FinalizeOldPage(UIElement? oldCtrl, Element? oldElem, object? oldRoute)
         }
 
         SetElementTag(nv, n);
+
+        // Spec 047 §14 Phase 3 completion CR — match V1 NavigationViewDescriptor:
+        // re-select when SelectedTag drifts OR MenuItems ref changes (the rebuild
+        // above can re-create the previously-selected container).
+        if (o.SelectedTag != n.SelectedTag || !ReferenceEquals(o.MenuItems, n.MenuItems))
+            nv.SelectedItem = FindNavItemByTag(nv.MenuItems, n.SelectedTag);
+
         if (o.OnSelectedTagChanged is null && n.OnSelectedTagChanged is not null)
             nv.SelectionChanged += (s, args) =>
             {
@@ -1794,6 +1820,21 @@ void FinalizeOldPage(UIElement? oldCtrl, Element? oldElem, object? oldRoute)
         return null;
     }
 
+    private static object? FindNavItemByTag(global::System.Collections.IEnumerable items, string? selectedTag)
+    {
+        if (selectedTag is null) return null;
+        foreach (var item in items)
+        {
+            if (item is WinUI.NavigationViewItem nvi)
+            {
+                if ((nvi.Tag as string) == selectedTag) return nvi;
+                var child = FindNavItemByTag(nvi.MenuItems, selectedTag);
+                if (child is not null) return child;
+            }
+        }
+        return null;
+    }
+
     private UIElement? UpdateTitleBar(TitleBarElement o, TitleBarElement n, WinUI.TitleBar titleBar, Action requestRerender)
     {
         titleBar.Title = n.Title;

src/Reactor/Core/Reconciler.cs

@@ -345,6 +345,16 @@ internal Reconciler(ILogger? logger, bool? useV1Protocol, bool registerBuiltinHa
     ///   (post-children mount-hook so SelectionChanged subscribes after
     ///   children-add, ImperativeBridged for the named tab strip slots)
     ///   tracked alongside the overlays + NavigationHost in the follow-up.</item>
+    ///   <item><b>Deferred — descriptor with lifecycle divergence from
+    ///   legacy</b> (follow-up PR) — <c>GridViewDescriptor</c>. The descriptor's
+    ///   <c>ItemsHost&lt;&gt;</c> strategy pre-mounts every item into
+    ///   <c>GridView.Items</c> (one container per item, no virtualization).
+    ///   The legacy <c>MountGridView</c> arm uses
+    ///   <c>ItemsSource = Range(0..N) + ItemTemplate + ContainerContentChanging</c>
+    ///   to realize containers lazily, matching the Phase 1
+    ///   <see cref="V1Protocol.Handlers.ListViewHandler"/> pattern. Closing
+    ///   this needs either a Phase 1 hand-coded <c>GridViewHandler</c> or a
+    ///   new ChildrenStrategy that wraps the CCC virtualization contract.</item>
     /// </list>
     /// </summary>
     private void RegisterV1BuiltInHandlers()
@@ -392,7 +402,23 @@ private void RegisterV1BuiltInHandlers()
         RegisterDescriptor(V1Protocol.Descriptor.Descriptors.FlipViewDescriptor.Descriptor);
         RegisterDescriptor(V1Protocol.Descriptor.Descriptors.FrameDescriptor.Descriptor);
         RegisterDescriptor(V1Protocol.Descriptor.Descriptors.GridDescriptor.Descriptor);
-        RegisterDescriptor(V1Protocol.Descriptor.Descriptors.GridViewDescriptor.Descriptor);
+        // Spec 047 §14 Phase 3 completion CR (Copilot review on PR #440) —
+        // GridViewDescriptor stays carved. The descriptor's ItemsHost<>
+        // strategy pre-mounts every item into GridView.Items (one container
+        // per item, no virtualization, no recycle). The legacy MountGridView
+        // path uses ItemsSource = Range(0..N) + ItemTemplate +
+        // ContainerContentChanging to realize containers lazily (one per
+        // visible viewport item) and unmount on RecycleQueue entry — same
+        // pattern as the Phase 1 hand-coded ListViewHandler. Registering
+        // GridViewDescriptor would not break A|B tests (no fixture stresses
+        // GridView scale), but it would silently regress production memory
+        // and lifecycle (item Mount/Unmount fires for every item up-front
+        // instead of per-viewport, breaking the recycle contract). Closing
+        // this needs either a Phase 1 hand-coded GridViewHandler mirroring
+        // ListViewHandler, or a new ChildrenStrategy variant that wraps
+        // ItemsSource + CCC. Tracked alongside the TabView/overlay/NavigationHost
+        // gap-closure follow-up.
+        // RegisterDescriptor(V1Protocol.Descriptor.Descriptors.GridViewDescriptor.Descriptor);
         RegisterDescriptor(V1Protocol.Descriptor.Descriptors.HyperlinkButtonDescriptor.Descriptor);
         RegisterDescriptor(V1Protocol.Descriptor.Descriptors.ImageDescriptor.Descriptor);
         RegisterDescriptor(V1Protocol.Descriptor.Descriptors.InfoBadgeDescriptor.Descriptor);

src/Reactor/Core/V1Protocol/ChildrenStrategy.cs

@@ -574,7 +574,28 @@ void IItemsBinderStrategy.Bind(FrameworkElement control, Element? oldElement, El
             items.Count == oldCount,
             "PreMountedItems<>: control items collection (" + items.Count
             + ") drifted from previous source ItemCount (" + oldCount + ").");
-        if (items.Count != oldCount) oldCount = items.Count;
+        if (items.Count != oldCount)
+        {
+            // Release fallback for count drift — same shape as the
+            // type-mismatch rebuild above. Cannot continue positional
+            // reconciliation safely: if items.Count > oldSource.ItemCount
+            // we'd index past oldSource bounds; if smaller, stale source
+            // items would be skipped without element-aware teardown.
+            for (int i = items.Count - 1; i >= 0; i--)
+            {
+                if (items[i] is UIElement orphan) reconciler.UnmountChild(orphan);
+                items.RemoveAt(i);
+            }
+            for (int i = 0; i < newCount; i++)
+            {
+                var fresh = reconciler.Mount(newSource.BuildItemView(i), requestRerender);
+                if (fresh is null)
+                    throw new global::System.InvalidOperationException(
+                        "PreMountedItems<>: item Element at index " + i + " mounted to a null UIElement.");
+                items.Add(fresh);
+            }
+            return;
+        }
 
         int shared = global::System.Math.Min(oldCount, newCount);
         for (int i = 0; i < shared; i++)