microsoft
diff --git a/‎src/Reactor/Core/ElementFactory.cs‎
Lines changed: 121 additions & 36 deletions b/‎src/Reactor/Core/ElementFactory.cs‎
Lines changed: 121 additions & 36 deletions
diff --git a/‎src/Reactor/Core/Reconciler.cs‎
Lines changed: 19 additions & 0 deletions b/‎src/Reactor/Core/Reconciler.cs‎
Lines changed: 19 additions & 0 deletions
diff --git a/‎src/Reactor/Yoga/FlexPanel.cs‎
Lines changed: 12 additions & 28 deletions b/‎src/Reactor/Yoga/FlexPanel.cs‎
Lines changed: 12 additions & 28 deletions
@@ -33,6 +33,43 @@ public sealed partial class ElementFactory<T> : IElementFactory
     private readonly Dictionary<string, Element> _mountedElements =
         new(global::System.StringComparer.Ordinal);
 
+    // Reverse lookup: realized WinUI control → key. Lets RecycleElement drop
+    // the matching _mountedElements entry in O(1) when ItemsRepeater hands a
+    // container back. Without this, entries accumulate one per unique key as
+    // the user scrolls (every realize adds; recycle never removes), and on
+    // any subsequent re-render RefreshRealizedItems walks stale entries
+    // whose row.Index now points at a different logical row's container —
+    // running Reconcile against a mismatched UIElement tree.
+    private readonly Dictionary<UIElement, string> _keyByControl = new();
+
+    // Recycle pool for proper WinUI ItemsRepeater integration. The framework
+    // keeps every realized UIElement parented to the repeater forever and
+    // expects the factory to cycle them — see ViewManager.cpp:865-869 in the
+    // microsoft-ui-xaml-lift source: on realize, it skips Append if the
+    // returned control is already parented to the repeater. So a recycled
+    // container must come back out via GetElement to keep the working set
+    // bounded; allocating fresh on every realize creates one orphan in
+    // Children per call.
+    private readonly Stack<UIElement> _recyclePool = new();
+
+    // Last Element bound to a given realized control. On reuse from the
+    // recycle pool, this is the oldElement passed to Reconciler.Reconcile so
+    // the existing WinUI tree gets diffed-in-place against the new content
+    // rather than thrown away and re-mounted.
+    private readonly Dictionary<UIElement, Element> _lastElementByControl = new();
+
+    // Test-only accessors for the regression fixture
+    // ElementFactoryRecyclingFixtures.Factory_BookkeepingBoundedAcrossCycles.
+    // Confirm that the four bookkeeping structures don't grow with the
+    // number of realize/recycle cycles. Gated by InternalsVisibleTo on
+    // Reactor.AppTests.Host (see Reactor.csproj).
+    internal int DebugRecyclePoolCount => _recyclePool.Count;
+    internal int DebugLastElementByControlCount => _lastElementByControl.Count;
+    internal int DebugMountedElementsCount => _mountedElements.Count;
+    internal int DebugKeyByControlCount => _keyByControl.Count;
+    internal bool DebugTryGetLastElementByControl(UIElement control, out Element? element)
+        => _lastElementByControl.TryGetValue(control, out element!);
+
     public ElementFactory(
         IReadOnlyList<T> items,
         Func<T, int, Element> viewBuilder,
@@ -126,6 +163,12 @@ internal void RefreshRealizedItems(Microsoft.UI.Xaml.Controls.ItemsRepeater repe
 
             var newElement = _viewBuilder(_items[currentIndex], currentIndex);
             _mountedElements[key] = newElement;
+            // Keep the per-control "last element" tracking in lockstep with
+            // _mountedElements. Without this, a later RecycleElement→GetElement
+            // round-trip for the same control would feed the pre-refresh
+            // Element to Reconcile as oldElement and diff against a stale
+            // tree shape. (PR #324 review)
+            _lastElementByControl[child] = newElement;
 
             _reconciler.Reconcile(oldElement, newElement, child, _requestRerender);
         }
@@ -160,51 +203,93 @@ public UIElement GetElement(ElementFactoryGetArgs args)
 
         var item = _items[index];
         var element = _viewBuilder(item, index);
+
+        UIElement? control;
+        if (_recyclePool.Count > 0)
+        {
+            // Reuse a previously-recycled container. The framework still has
+            // it parented to the ItemsRepeater, so the ViewManager.cpp:866
+            // Append-skip kicks in and the visual tree stays stable.
+            var reused = _recyclePool.Pop();
+            if (_lastElementByControl.TryGetValue(reused, out var oldElement))
+            {
+                var replacement = _reconciler.Reconcile(oldElement, element, reused, _requestRerender);
+                if (replacement is not null && !ReferenceEquals(replacement, reused))
+                {
+                    // Heterogeneous-row case: Reconcile decided the root
+                    // element type changed and built a fresh control.
+                    // `reused` is now unmounted but still parented to the
+                    // ItemsRepeater — detach so it doesn't sit there as
+                    // an orphan (the original leak shape we're fixing).
+                    // (PR #324 review)
+                    DetachFromParent(reused);
+                    _lastElementByControl.Remove(reused);
+                    control = replacement;
+                }
+                else
+                {
+                    control = reused;
+                }
+            }
+            else
+            {
+                // Defensive: pool entry without a tracked oldElement should
+                // not happen — fall back to re-mounting on top of it.
+                control = _reconciler.Mount(element, _requestRerender);
+            }
+        }
+        else
+        {
+            control = _reconciler.Mount(element, _requestRerender);
+        }
+
         _mountedElements[key] = element;
-        var control = _reconciler.Mount(element, _requestRerender);
+        if (control is not null)
+        {
+            _keyByControl[control] = key;
+            _lastElementByControl[control] = element;
+        }
+
         return control ?? new TextBlock { Text = "" };
     }
 
+    // Detach a UIElement from whatever container it's parented to. ItemsRepeater
+    // is a Panel subclass so the standard Children.Remove path applies; we also
+    // handle Border/ScrollViewer/ContentControl so this is safe to call on
+    // arbitrary recycled subtrees.
+    private static void DetachFromParent(UIElement control)
+    {
+        if (control is not FrameworkElement fe) return;
+        switch (fe.Parent)
+        {
+            case Microsoft.UI.Xaml.Controls.Panel panel:
+                panel.Children.Remove(fe);
+                break;
+            case Microsoft.UI.Xaml.Controls.Border border when ReferenceEquals(border.Child, fe):
+                border.Child = null;
+                break;
+            case Microsoft.UI.Xaml.Controls.ContentControl cc when ReferenceEquals(cc.Content, fe):
+                cc.Content = null;
+                break;
+        }
+    }
+
     public void RecycleElement(ElementFactoryRecycleArgs args)
     {
         if (args.Element is null) return;
 
-        // Clean up Reactor state (component contexts, effects).
-        _reconciler.UnmountChild(args.Element);
-
-        // Pool interactive leaf controls for reuse. Layout containers (Panel, Border)
-        // are NOT pooled here because ItemsRepeater may still reference the root element
-        // during its layout pass and modifying children causes COMExceptions. Interactive
-        // controls are safe to detach and pool because they are leaves with no children.
-        if (_pool is not null)
-            PoolInteractiveLeaves(args.Element);
-    }
+        // Drop the mounted-element tracking for this container so a later
+        // RefreshRealizedItems can't run Reconcile against a stale Element
+        // paired with a now-foreign realized child.
+        if (_keyByControl.Remove(args.Element, out var stashedKey))
+            _mountedElements.Remove(stashedKey);
 
-    /// <summary>
-    /// Walk the recycled subtree and pool interactive leaf controls (Button, TextBox,
-    /// ToggleSwitch). These are the most expensive controls to create and benefit most
-    /// from pooling. Detaches each from its parent panel before returning to the pool.
-    /// </summary>
-    private void PoolInteractiveLeaves(UIElement root)
-    {
-        if (root is Microsoft.UI.Xaml.Controls.Panel panel)
-        {
-            // Walk children in reverse so removal doesn't shift indices
-            for (int i = panel.Children.Count - 1; i >= 0; i--)
-                PoolInteractiveLeaves(panel.Children[i]);
-        }
-        else if (root is Microsoft.UI.Xaml.Controls.Border border && border.Child is not null)
-        {
-            PoolInteractiveLeaves(border.Child);
-        }
-        else if (root is FrameworkElement fe && IsPoolableInteractive(fe))
-        {
-            _pool!.Return(fe);
-        }
+        // DON'T UnmountChild — the WinUI tree stays alive and is reused on
+        // the next GetElement call via Reconciler.Reconcile. ItemsRepeater
+        // keeps the element parented either way (see ViewManager.cpp), so
+        // tearing down Reactor state here would just be discarded work.
+        // The _lastElementByControl entry stays valid for the next realize.
+        _recyclePool.Push(args.Element);
     }
 
-    private static bool IsPoolableInteractive(FrameworkElement fe) =>
-        fe is Microsoft.UI.Xaml.Controls.Button
-        or TextBox
-        or Microsoft.UI.Xaml.Controls.ToggleSwitch;
 }
@@ -1101,6 +1101,25 @@ private void UnmountRecursive(UIElement control)
             foreach (var child in panel.Children)
                 UnmountRecursive(child);
         }
+        else if (control is WinUI.ItemsRepeater repeater)
+        {
+            // ItemsRepeater projects to C# as a FrameworkElement (not a
+            // Panel — see microsoft-ui-xaml-lift/.../ItemsRepeater.idl), so
+            // the Panel branch above doesn't catch it even though the
+            // framework keeps both realized and recycled containers in
+            // its visual subtree. Without this branch, row Components'
+            // UseEffect cleanups would never run when the LazyStack is
+            // unmounted (e.g., on navigation), leaking any in-flight
+            // timers / subscriptions / async loops. We walk via
+            // VisualTreeHelper because the public ItemsRepeater surface
+            // doesn't expose a Children collection. (PR #324 review)
+            int count = Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChildrenCount(repeater);
+            for (int i = 0; i < count; i++)
+            {
+                if (Microsoft.UI.Xaml.Media.VisualTreeHelper.GetChild(repeater, i) is UIElement child)
+                    UnmountRecursive(child);
+            }
+        }
         else if (control is WinUI.Border border && border.Child is not null)
         {
             UnmountRecursive(border.Child);
 
@@ -31,50 +31,33 @@ public partial class FlexPanel : Panel
     private readonly YogaNode _rootNode;
     private readonly HashSet<UIElement> _syncCurrentChildren = new();
     private readonly List<UIElement> _syncToRemove = new();
-    private XamlRoot? _subscribedXamlRoot;
 
     public FlexPanel()
     {
         _rootNode = new YogaNode(_yogaConfig);
-        Loaded += OnLoaded;
         Unloaded += OnUnloaded;
     }
 
-    private void OnLoaded(object sender, RoutedEventArgs e)
+    /// <summary>
+    /// Read the current rasterization scale from this panel's XamlRoot and
+    /// update <see cref="YogaConfig.PointScaleFactor"/> if it changed. Called
+    /// from <see cref="MeasureOverride"/> so the scale tracks the live system
+    /// DPI without subscribing to <c>XamlRoot.Changed</c>. The subscription
+    /// approach pinned every FlexPanel through XamlRoot's multicast delegate
+    /// list — fatal for virtualized lists where ItemsRepeater's recycle path
+    /// does not reliably fire Unloaded on every recycled container.
+    /// </summary>
+    private void SyncPointScaleLazy()
     {
-        var current = XamlRoot;
-        if (current is null || ReferenceEquals(current, _subscribedXamlRoot))
-            return;
-
-        if (_subscribedXamlRoot is not null)
-            _subscribedXamlRoot.Changed -= OnXamlRootChanged;
-        _subscribedXamlRoot = current;
-        _subscribedXamlRoot.Changed += OnXamlRootChanged;
-        SyncPointScaleFromXamlRoot();
-    }
-
-    private void OnXamlRootChanged(XamlRoot sender, XamlRootChangedEventArgs args)
-    {
-        SyncPointScaleFromXamlRoot();
-    }
-
-    private void SyncPointScaleFromXamlRoot()
-    {
-        var scale = (float)(_subscribedXamlRoot?.RasterizationScale ?? 1.0);
+        var scale = (float)(XamlRoot?.RasterizationScale ?? 1.0);
         if (scale <= 0) return;
         if (Math.Abs(_yogaConfig.PointScaleFactor - scale) < 0.0001f) return;
         _yogaConfig.PointScaleFactor = scale;
         _rootNode.MarkDirtyAndPropagate();
-        InvalidateMeasure();
     }
 
     private void OnUnloaded(object sender, RoutedEventArgs e)
     {
-        if (_subscribedXamlRoot is not null)
-        {
-            _subscribedXamlRoot.Changed -= OnXamlRootChanged;
-            _subscribedXamlRoot = null;
-        }
         // Clear Yoga node cache when removed from the visual tree to avoid leaking references
         foreach (var node in _nodeCache.Values)
             _rootNode.RemoveChild(node);
@@ -311,6 +294,7 @@ private struct ChildLayout { public float X, Y, Width, Height; }
 
     protected override Size MeasureOverride(Size availableSize)
     {
+        SyncPointScaleLazy();
         _measuredThisPass.Clear();
         SyncYogaTree();
         SetRootConstraints(availableSize);