spec(047): Phase 3-final Batch E — Panel per-child attached props + WrapGrid

Wires Grid/Canvas/FlexPanel descriptors to use Batch A's additive
Panel<>.PerChildAttached callback. Each panel descriptor declares a
captured-free set lambda that reads the child element's attached-prop
hint (GridAttached / CanvasAttached / FlexAttached) and writes the
corresponding WinUI attached DP. Mirrors what the legacy MountXxx arms
do after each child mounts; closes the "descriptor-mounted children
stack at row 0 / column 0" known gap from PR #435 batch 8.

WrapGridDescriptor (new) — closes the Phase 3 batch 8 escape-hatch
("WrapGrid escape-hatched (needs per-child attached-prop hook)").
Mirrors MountWrapGrid: Orientation always written; MaximumRowsOrColumns
/ ItemWidth / ItemHeight via .OneWayConditional; per-child WrapGridAttached
(RowSpan / ColumnSpan) via PerChildAttached. Registered in the perf
DescriptorVariantFactory alongside the other panel descriptors.

FlexPanelDescriptor delegates to Reconciler.ApplyFlexAttached (promoted
from private to internal) so descriptor and legacy paths share the
"always apply — reset to defaults when no hint" semantics that protect
against stale Yoga config on pool-rented controls. CanvasDescriptor
delegates to Reconciler.ApplyCanvasPosition (already internal) so the
anchor-state ConditionalWeakTable + SizeChanged wiring is shared.

Each descriptor's PerChildAttached callback resets the relevant WinUI
attached DPs via ClearValue when the child has no hint, so a reordered
child whose attached prop drops between renders is not stuck with the
prior placement.

Documented gaps:
- RelativePanelDescriptor carved to Phase 4: the per-child callback
  fires sequentially during the mount loop, so name references like
  RightOf="foo" can't resolve against siblings that haven't been
  mounted yet. Needs either a post-loop second-pass shape on Panel<>
  or a dedicated NamedRelativePanel strategy. Doc updated in-place.

Self-test V1 ON/OFF Desc_ filter: 494/494 pass on both paths
(includes 4 new fixtures: Desc_Grid_AttachedRowColumn,
Desc_Canvas_AttachedLeftTop, Desc_FlexPanel_AttachedFlexProps,
Desc_WrapGrid_MountUpdate).

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

Author: codemonkeychris

src/Reactor/Core/Reconciler.Update.cs

@@ -3775,7 +3775,7 @@ private static void UpdateAppBarItems(
         return null;
     }
 
-    private static void ApplyFlexAttached(Element child, Microsoft.UI.Xaml.UIElement ctrl)
+    internal static void ApplyFlexAttached(Element child, Microsoft.UI.Xaml.UIElement ctrl)
     {
         var fa = child.GetAttached<FlexAttached>();
         // Always apply — reset to defaults when no FlexAttached, so stale values

src/Reactor/Core/V1Protocol/Descriptor/Descriptors/CanvasDescriptor.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.UI.Xaml;
 using WinUI = Microsoft.UI.Xaml.Controls;
 
 namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
@@ -12,21 +13,35 @@ namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
 /// Children are dispatched through the
 /// <see cref="Panel{TElement,TControl}"/> strategy.</para>
 ///
-/// <para><b>Known gaps:</b> the legacy hand-coded path applies
-/// <see cref="CanvasAttached"/> (Canvas.Left / Canvas.Top) per child after
-/// children mount. The Panel strategy in V1HandlerAdapter doesn't surface a
-/// per-child post-mount hook yet, so descriptor-mounted children stay at
-/// the panel origin. Authors who need <c>Canvas.SetLeft</c> /
-/// <c>Canvas.SetTop</c> stay on V1 OFF (legacy arm). Pure-children scenarios
-/// have parity.</para>
+/// <para><b>§14 Phase 3-final Batch E:</b> per-child
+/// <see cref="CanvasAttached"/> (Canvas.Left / Canvas.Top, plus the
+/// AnchorX / AnchorY post-layout offset) is now applied via
+/// <see cref="Panel{TElement,TControl}.PerChildAttached"/>. The callback
+/// delegates to <see cref="Reconciler.ApplyCanvasPosition"/> so descriptor
+/// children share the same anchor-state ConditionalWeakTable + size-change
+/// subscription used by the legacy <c>MountCanvas</c> arm.</para>
 /// </summary>
 [Experimental("REACTOR_V1_PREVIEW")]
 internal static class CanvasDescriptor
 {
     private static readonly Panel<CanvasElement, WinUI.Canvas> ChildrenStrategy =
         new Panel<CanvasElement, WinUI.Canvas>(
             GetChildren: static e => e.Children,
-            GetCollection: static c => c.Children);
+            GetCollection: static c => c.Children)
+        {
+            PerChildAttached = static (canvas, ui, childEl) =>
+            {
+                if (ui is not FrameworkElement fe) return;
+                var ca = childEl.GetAttached<CanvasAttached>();
+                if (ca is null)
+                {
+                    fe.ClearValue(WinUI.Canvas.LeftProperty);
+                    fe.ClearValue(WinUI.Canvas.TopProperty);
+                    return;
+                }
+                Reconciler.ApplyCanvasPosition(fe, ca);
+            },
+        };
 
     public static readonly ControlDescriptor<CanvasElement, WinUI.Canvas> Descriptor =
         new ControlDescriptor<CanvasElement, WinUI.Canvas>

src/Reactor/Core/V1Protocol/Descriptor/Descriptors/FlexPanelDescriptor.cs

@@ -15,21 +15,26 @@ namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
 /// (<c>FlexPanel : Panel</c>, so <c>Children</c> is the standard
 /// <c>UIElementCollection</c>).</para>
 ///
-/// <para><b>Known gaps:</b> the legacy hand-coded path applies
-/// <see cref="FlexAttached"/> per child after children mount (Grow / Shrink /
-/// Basis / Order / AlignSelf / margins). The Panel strategy in
-/// V1HandlerAdapter doesn't surface a per-child post-mount hook, so flex
-/// children stay at default Yoga node config. Authors who need per-child
-/// flex tuning stay on V1 OFF (legacy arm). Container-level layout has
-/// parity.</para>
+/// <para><b>§14 Phase 3-final Batch E:</b> per-child
+/// <see cref="FlexAttached"/> (Grow / Shrink / Basis / MinWidth / MinHeight
+/// / AlignSelf / Position / Left / Top / Right / Bottom) is now applied via
+/// <see cref="Panel{TElement,TControl}.PerChildAttached"/>. The callback
+/// delegates to <see cref="Reconciler.ApplyFlexAttached"/> so descriptor
+/// children share the same "always apply — reset to defaults when no hint"
+/// semantics as the legacy <c>MountFlex</c> arm (the reset is required for
+/// pool-rented controls that could otherwise inherit stale Yoga config).</para>
 /// </summary>
 [Experimental("REACTOR_V1_PREVIEW")]
 internal static class FlexPanelDescriptor
 {
     private static readonly Panel<FlexElement, FlexPanel> ChildrenStrategy =
         new Panel<FlexElement, FlexPanel>(
             GetChildren: static e => e.Children,
-            GetCollection: static c => c.Children);
+            GetCollection: static c => c.Children)
+        {
+            PerChildAttached = static (panel, ui, childEl) =>
+                Microsoft.UI.Reactor.Core.Reconciler.ApplyFlexAttached(childEl, ui),
+        };
 
     public static readonly ControlDescriptor<FlexElement, FlexPanel> Descriptor =
         new ControlDescriptor<FlexElement, FlexPanel>

src/Reactor/Core/V1Protocol/Descriptor/Descriptors/GridDescriptor.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.UI.Xaml;
 using WinUI = Microsoft.UI.Xaml.Controls;
 
 namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
@@ -20,21 +21,44 @@ namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
 /// gate). Children are dispatched through the
 /// <see cref="Panel{TElement,TControl}"/> strategy.</para>
 ///
-/// <para><b>Known gaps:</b> the legacy hand-coded path applies
-/// <see cref="GridAttached"/> (Row / Column / RowSpan / ColumnSpan) per
-/// child after children mount. The Panel strategy in V1HandlerAdapter
-/// doesn't surface a per-child post-mount hook yet, so descriptor-mounted
-/// children stack at row 0 / column 0. Authors who need
-/// <c>Grid.SetRow</c> / <c>Grid.SetColumn</c> stay on V1 OFF (legacy arm).
-/// Container-level spacing and definitions have parity.</para>
+/// <para><b>§14 Phase 3-final Batch E:</b> per-child
+/// <see cref="GridAttached"/> (Row / Column / RowSpan / ColumnSpan) is now
+/// applied via <see cref="Panel{TElement,TControl}.PerChildAttached"/>,
+/// which the V1HandlerAdapter fires after each child Mount and after each
+/// child Update. Mirrors the legacy <c>MountGrid</c> arm —
+/// <c>Grid.SetRow</c> / <c>Grid.SetColumn</c> always set; <c>SetRowSpan</c>
+/// / <c>SetColumnSpan</c> only when the hint is &gt; 1 (default).</para>
 /// </summary>
 [Experimental("REACTOR_V1_PREVIEW")]
 internal static class GridDescriptor
 {
     private static readonly Panel<GridElement, WinUI.Grid> ChildrenStrategy =
         new Panel<GridElement, WinUI.Grid>(
             GetChildren: static e => e.Children,
-            GetCollection: static c => c.Children);
+            GetCollection: static c => c.Children)
+        {
+            PerChildAttached = static (grid, ui, childEl) =>
+            {
+                if (ui is not FrameworkElement fe) return;
+                var ga = childEl.GetAttached<GridAttached>();
+                if (ga is null)
+                {
+                    // Reset to defaults so pool-rented / reused controls don't
+                    // inherit stale positioning from a prior parent.
+                    fe.ClearValue(WinUI.Grid.RowProperty);
+                    fe.ClearValue(WinUI.Grid.ColumnProperty);
+                    fe.ClearValue(WinUI.Grid.RowSpanProperty);
+                    fe.ClearValue(WinUI.Grid.ColumnSpanProperty);
+                    return;
+                }
+                WinUI.Grid.SetRow(fe, ga.Row);
+                WinUI.Grid.SetColumn(fe, ga.Column);
+                if (ga.RowSpan > 1) WinUI.Grid.SetRowSpan(fe, ga.RowSpan);
+                else fe.ClearValue(WinUI.Grid.RowSpanProperty);
+                if (ga.ColumnSpan > 1) WinUI.Grid.SetColumnSpan(fe, ga.ColumnSpan);
+                else fe.ClearValue(WinUI.Grid.ColumnSpanProperty);
+            },
+        };
 
     public static readonly ControlDescriptor<GridElement, WinUI.Grid> Descriptor =
         new ControlDescriptor<GridElement, WinUI.Grid>

src/Reactor/Core/V1Protocol/Descriptor/Descriptors/RelativePanelDescriptor.cs

@@ -13,14 +13,20 @@ namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
 /// <c>Setters</c>. Children are dispatched through the
 /// <see cref="Panel{TElement,TControl}"/> strategy.</para>
 ///
-/// <para><b>Known gaps:</b> the legacy hand-coded path executes a two-pass
-/// resolution to apply <see cref="RelativePanelAttached"/> attached
-/// properties (RightOf / Below / AlignLeftWith / AlignWithPanel etc.) using
-/// a name → control map. The Panel strategy in V1HandlerAdapter doesn't
-/// surface a per-child post-mount hook, so descriptor-mounted children
-/// stack at the panel origin without relative wiring. Authors who depend on
-/// <c>RelativePanelAttached</c> stay on V1 OFF (legacy arm). Pure-children
-/// scenarios have parity.</para>
+/// <para><b>Known gap — carved to Phase 4:</b> the legacy hand-coded path
+/// executes a two-pass resolution to apply
+/// <see cref="RelativePanelAttached"/> attached properties (RightOf / Below
+/// / AlignLeftWith / AlignWithPanel etc.) using a name → control map built
+/// up across all children. Phase 3-final Batch A's
+/// <see cref="Panel{TElement,TControl}.PerChildAttached"/> hook fires
+/// per-child sequentially — at the moment any given child's callback
+/// fires, later siblings haven't been mounted yet, so name references
+/// like <c>RightOf="foo"</c> can't resolve. A correct port requires
+/// either a post-loop second-pass shape on <see cref="Panel{TElement,TControl}"/>
+/// or a dedicated <c>NamedRelativePanel&lt;…&gt;</c> strategy; both are
+/// out of Batch E's scope. Pure-children scenarios remain at parity;
+/// authors who depend on <c>RelativePanelAttached</c> stay on V1 OFF
+/// (legacy arm) until the Phase 4 follow-up.</para>
 /// </summary>
 [Experimental("REACTOR_V1_PREVIEW")]
 internal static class RelativePanelDescriptor

src/Reactor/Core/V1Protocol/Descriptor/Descriptors/WrapGridDescriptor.cs

@@ -0,0 +1,73 @@
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.UI.Xaml;
+using WinUI = Microsoft.UI.Xaml.Controls;
+
+namespace Microsoft.UI.Reactor.Core.V1Protocol.Descriptor.Descriptors;
+
+/// <summary>
+/// Spec 047 §14 Phase 3-final Batch E — descriptor variant of the
+/// hand-coded <c>MountWrapGrid</c> / <c>UpdateWrapGrid</c> arms in
+/// <see cref="Reconciler"/>. Closes the Phase 3 batch-8 escape-hatch
+/// ("WrapGrid escape-hatched (needs per-child attached-prop hook)") — the
+/// Batch A additive <see cref="Panel{TElement,TControl}.PerChildAttached"/>
+/// surface makes the per-child <see cref="WrapGridAttached"/> writes
+/// expressible declaratively.
+///
+/// <para><b>Coverage:</b> a zero-event panel container backed by
+/// <see cref="WinUI.VariableSizedWrapGrid"/>. Four conditional one-way
+/// props (<c>MaximumRowsOrColumns</c> ≥ 0, <c>ItemWidth</c> /
+/// <c>ItemHeight</c> non-NaN, <c>Orientation</c> always written). Children
+/// are dispatched through the <see cref="Panel{TElement,TControl}"/>
+/// strategy with a <see cref="Panel{TElement,TControl}.PerChildAttached"/>
+/// callback that mirrors the legacy <c>MountWrapGrid</c> arm —
+/// <c>VariableSizedWrapGrid.SetRowSpan</c> /
+/// <c>VariableSizedWrapGrid.SetColumnSpan</c> only when the hint is
+/// &gt; 1 (default).</para>
+/// </summary>
+[Experimental("REACTOR_V1_PREVIEW")]
+internal static class WrapGridDescriptor
+{
+    private static readonly Panel<WrapGridElement, WinUI.VariableSizedWrapGrid> ChildrenStrategy =
+        new Panel<WrapGridElement, WinUI.VariableSizedWrapGrid>(
+            GetChildren: static e => e.Children,
+            GetCollection: static c => c.Children)
+        {
+            PerChildAttached = static (grid, ui, childEl) =>
+            {
+                if (ui is not FrameworkElement fe) return;
+                var wga = childEl.GetAttached<WrapGridAttached>();
+                if (wga is null)
+                {
+                    fe.ClearValue(WinUI.VariableSizedWrapGrid.RowSpanProperty);
+                    fe.ClearValue(WinUI.VariableSizedWrapGrid.ColumnSpanProperty);
+                    return;
+                }
+                if (wga.RowSpan > 1) WinUI.VariableSizedWrapGrid.SetRowSpan(fe, wga.RowSpan);
+                else fe.ClearValue(WinUI.VariableSizedWrapGrid.RowSpanProperty);
+                if (wga.ColumnSpan > 1) WinUI.VariableSizedWrapGrid.SetColumnSpan(fe, wga.ColumnSpan);
+                else fe.ClearValue(WinUI.VariableSizedWrapGrid.ColumnSpanProperty);
+            },
+        };
+
+    public static readonly ControlDescriptor<WrapGridElement, WinUI.VariableSizedWrapGrid> Descriptor =
+        new ControlDescriptor<WrapGridElement, WinUI.VariableSizedWrapGrid>
+        {
+            Children = ChildrenStrategy,
+            GetSetters = static e => e.Setters,
+        }
+        .OneWay(
+            get: static e => e.Orientation,
+            set: static (c, v) => c.Orientation = v)
+        .OneWayConditional(
+            get:         static e => e.MaximumRowsOrColumns,
+            set:         static (c, v) => c.MaximumRowsOrColumns = v,
+            shouldWrite: static e => e.MaximumRowsOrColumns >= 0)
+        .OneWayConditional(
+            get:         static e => e.ItemWidth,
+            set:         static (c, v) => c.ItemWidth = v,
+            shouldWrite: static e => !double.IsNaN(e.ItemWidth))
+        .OneWayConditional(
+            get:         static e => e.ItemHeight,
+            set:         static (c, v) => c.ItemHeight = v,
+            shouldWrite: static e => !double.IsNaN(e.ItemHeight));
+}