fix(reconciler): re-render context consumers behind reference-stable child skips (#811)

src/Reactor/Core/ChildReconciler.cs

@@ -213,9 +213,17 @@ private static void UpdateCommonChild(
         // of the COM fetch a membership check would cost on the hot skip-floor.
         var oldEl = oldChildren[i];
         var newEl = newChildren[i];
+        UIElement? existingControl = null;
         if (Element.CanSkipUpdate(oldEl, newEl)
             && !reconciler.ForceRenderThroughWrapper(newEl))
         {
+            if (reconciler.HasActiveContextValues)
+            {
+                existingControl = children.Get(i);
+                if (reconciler.HasConsumedContextChangedInSubtree(existingControl))
+                    goto perform_update;
+            }
+
             reconciler.DebugElementsSkipped++;
             // Refresh Tag when the element carries callbacks. The skip short-
             // circuits Update, so without this the event trampoline keeps
@@ -229,7 +237,7 @@ private static void UpdateCommonChild(
             if ((newEl.HasCallbacks
                     || Reconciler.HasGestureOrDragSlots(newEl.Modifiers)
                     || Reconciler.HasGestureOrDragSlots(oldEl.Modifiers))
-                && children.Get(i) is FrameworkElement fe)
+                && (existingControl ??= children.Get(i)) is FrameworkElement fe)
             {
                 if (newEl.HasCallbacks)
                     Reconciler.SetElementTag(fe, newEl);
@@ -238,9 +246,10 @@ private static void UpdateCommonChild(
             return;
         }
 
+perform_update:
         if (reconciler.CanUpdate(oldEl, newEl))
         {
-            var existingControl = children.Get(i);
+            existingControl ??= children.Get(i);
             var replacement = reconciler.UpdateChild(oldEl, newEl, existingControl, requestRerender);
             if (replacement is not null)
             {

src/Reactor/Core/ContextScope.cs

@@ -48,5 +48,7 @@ internal T Read<T>(Context<T> context)
         return context.DefaultValueBoxed;
     }
 
+    internal bool HasActiveValues => _stack.Count > 0;
+
     internal long Version => _version;
 }

src/Reactor/Core/Reconciler.Update.cs

@@ -93,11 +93,18 @@ public sealed partial class Reconciler
         // in UpdateXxx never gets to attach the WinRT event. If presence
         // changes, force Update so EnsureXxxWiring (poolable) or the diff-based
         // null→non-null checks (non-poolable) can subscribe.
+        // Context-consumer subtree check is placed LAST in the skip predicate so
+        // the recursive HasConsumedContextChangedInSubtree walk only runs after the
+        // cheap structural gates pass (via && short-circuiting). Elements that can't
+        // be skipped (e.g. ShallowEquals false) never pay for the subtree traversal,
+        // and HasActiveContextValues short-circuits it away entirely when no provider
+        // is on the stack.
         if (Element.ShallowEquals(oldEl, newEl)
             && Element.ModifiersEqual(oldModifiers, modifiers)
             && oldEl.HasCallbacks == newEl.HasCallbacks
             && !ForceRenderThroughWrapper(newEl)
-            && !IsOnDirtyAncestorPath(control))
+            && !IsOnDirtyAncestorPath(control)
+            && !(HasActiveContextValues && HasConsumedContextChangedInSubtree(control)))
         {
             DebugElementsSkipped++;
             // Refresh Tag so the event trampoline dispatches into the new element's

src/Reactor/Core/Reconciler.cs

@@ -1314,6 +1314,8 @@ internal IDisposable PushContextDisposable<T>(Context<T> context, T value)
     // without exposing the traversal stack itself.
     internal T ReadContext<T>(Context<T> context) => _contextScope.Read(context);
 
+    internal bool HasActiveContextValues => _contextScope.HasActiveValues;
+
     /// <summary>
     /// Spec 047 §14 Phase 1 (1.6) — push a stagger scope for child enter
     /// transitions. Returns an <see cref="IDisposable"/> that pops the
@@ -1908,6 +1910,27 @@ private bool HasConsumedContextChanged(ComponentNode node)
         return false;
     }
 
+    internal bool HasConsumedContextChangedInSubtree(UIElement control)
+    {
+        if (_componentNodes.TryGetValue(control, out var node)
+            && HasConsumedContextChanged(node))
+            return true;
+
+        bool found = false;
+        ForEachReactorChildControl(control, child =>
+        {
+            if (HasConsumedContextChangedInSubtree(child))
+            {
+                found = true;
+                return false;
+            }
+
+            return true;
+        });
+
+        return found;
+    }
+
     /// <summary>
     /// Calls ShouldUpdate(oldProps, newProps) on a Component&lt;TProps&gt; via interface dispatch.
     /// </summary>

tests/Reactor.AppTests.Host/SelfTest/Fixtures/Issue811ContextConsumerSkipFixtures.cs

@@ -0,0 +1,85 @@
+using Microsoft.UI.Reactor;
+using Microsoft.UI.Reactor.Core;
+using Microsoft.UI.Reactor.AppTests.Host.SelfTest;
+using static Microsoft.UI.Reactor.Factories;
+
+namespace Microsoft.UI.Reactor.AppTests.Host.SelfTest.Fixtures;
+
+/// <summary>
+/// Issue #811 — a reference-stable child subtree that consumes context must still
+/// re-render when the provided context value changes.
+///
+/// The reproducer is intentionally minimal: a parent owns internal interactive
+/// state, provides it via <c>.Provide(...)</c>, and re-emits the SAME overlay
+/// element instance on every render. The overlay consumes that context to derive
+/// both visible text and a click action. If child-skip short-circuits before the
+/// reconciler descends into the consumer, the label stays stale and the click path
+/// keeps dispatching the old action shape.
+/// </summary>
+internal static class Issue811ContextConsumerSkipFixtures
+{
+    private static readonly Context<bool> InteractiveCtx = new(true);
+
+    private sealed class Probe
+    {
+        public int RenderCount;
+        public string? LastAction;
+    }
+
+    private sealed record OverlayProps(Probe Probe);
+
+    private sealed class OverlayConsumer : Component<OverlayProps>
+    {
+        public override Element Render()
+        {
+            Props.Probe.RenderCount++;
+            bool interactive = UseContext(InteractiveCtx);
+
+            return VStack(
+                TextBlock(interactive ? "Lock interactivity" : "Unlock interactivity"),
+                Button("Invoke overlay action", () =>
+                    Props.Probe.LastAction = interactive ? "lock" : "unlock"));
+        }
+    }
+
+    internal sealed class ReferenceStableChildSkip_ContextConsumerRerenders(Harness h)
+        : SelfTestFixtureBase(h)
+    {
+        public override async Task RunAsync()
+        {
+            var probe = new Probe();
+            var stableOverlay = Component<OverlayConsumer, OverlayProps>(new OverlayProps(probe));
+
+            var host = H.CreateHost();
+            host.Mount(ctx =>
+            {
+                var (interactive, setInteractive) = ctx.UseState(true);
+
+                return VStack(
+                        TextBlock(interactive ? "surface:on" : "surface:off"),
+                        Button("Toggle interactive", () => setInteractive(!interactive)),
+                        stableOverlay)
+                    .Provide(InteractiveCtx, interactive);
+            });
+
+            await Harness.Render();
+
+            H.Check("Issue811_Mount_SurfaceOn", H.FindText("surface:on") is not null);
+            H.Check("Issue811_Mount_LabelLock", H.FindText("Lock interactivity") is not null);
+            H.Check("Issue811_Mount_OverlayRenderedOnce", probe.RenderCount == 1);
+
+            H.ClickButton("Toggle interactive");
+            await Harness.Render();
+
+            H.Check("Issue811_Toggle_SurfaceOff", H.FindText("surface:off") is not null);
+            H.Check("Issue811_Toggle_LabelUpdated", H.FindText("Unlock interactivity") is not null);
+            H.Check("Issue811_Toggle_OverlayRerendered", probe.RenderCount >= 2);
+
+            H.ClickButton("Invoke overlay action");
+            await Harness.Render();
+
+            H.Check("Issue811_ActionUsesCurrentContext", probe.LastAction == "unlock");
+            H.Check("Issue811_ActionDidNotUseStaleContext", probe.LastAction != "lock");
+        }
+    }
+}

tests/Reactor.AppTests.Host/SelfTest/SelfTestFixtureRegistry.cs

@@ -388,6 +388,7 @@ internal static class SelfTestFixtureRegistry
         "StructuralSkip_ThemeRangeParity",
         "UseMemoCells_BaseReThemeOnAncestorToggle",
         "StructuralSkip_HotReloadWrapperReRender",
+        "Issue811_ReferenceStableChildSkip_ContextConsumerRerenders",
         "ThemeBindingsSkip_ImmediateAncestorToggleSelfHeals",
         "ThemeBindingsSkip_InheritedAncestorToggleSelfHeals",
         "ThemeBindingsSkip_WholeListEarlyOutToggleSelfHeals",
@@ -1867,6 +1868,7 @@ internal static class SelfTestFixtureRegistry
         "StructuralSkip_ThemeRangeParity" => new StructuralSkipFixtures.ThemeRangeParity(harness),
         "UseMemoCells_BaseReThemeOnAncestorToggle" => new UseMemoCellsThemeReResolveFixtures.BaseMemoCellsReThemeOnAncestorToggle(harness),
         "StructuralSkip_HotReloadWrapperReRender" => new StructuralSkipFixtures.HotReloadWrapperReRender(harness),
+        "Issue811_ReferenceStableChildSkip_ContextConsumerRerenders" => new Issue811ContextConsumerSkipFixtures.ReferenceStableChildSkip_ContextConsumerRerenders(harness),
         "ThemeBindingsSkip_ImmediateAncestorToggleSelfHeals" => new ThemeBindingsSkipSelfHealFixtures.ImmediateAncestorToggleSelfHeals(harness),
         "ThemeBindingsSkip_InheritedAncestorToggleSelfHeals" => new ThemeBindingsSkipSelfHealFixtures.InheritedAncestorToggleSelfHeals(harness),
         "ThemeBindingsSkip_WholeListEarlyOutToggleSelfHeals" => new ThemeBindingsSkipSelfHealFixtures.WholeListEarlyOutToggleSelfHeals(harness),