fix(dialog): ContentDialog opens without manual XamlRoot (#246) (#247)

* fix(dialog): resolve ContentDialog XamlRoot from in-tree placeholder (#246)

ShowContentDialog mounted dialog content into a detached subtree, then
read contentUi.XamlRoot — which is always null because the content was
never attached. ShowAsync() then threw on the null XamlRoot, the empty
catch swallowed the error, and apps saw no dialog. Workaround was to
manually .Set(d => d.XamlRoot = ...).

Resolve XamlRoot from the in-tree placeholder (which the reconciler
already returned to the parent), falling back to PrimaryWindow. For the
mount-time IsOpen=true case the placeholder isn't attached yet, so defer
via Loaded. ApplySetters runs last so caller .Set(...) still wins.

Adds two regression fixtures (mount-time and state-flip paths) that
verify the dialog appears as a popup via GetOpenPopupsForXamlRoot.

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

* Address CR: defer on anchor.XamlRoot=null, re-read current element, log swallowed errors

- ShowContentDialog: only consult anchor.XamlRoot at mount-time; defer to
  Loaded whenever the anchor isn't attached, so dialogs mounted in a
  secondary window can't be misrouted to PrimaryWindow's XamlRoot. The
  PrimaryWindow fallback is now only a last resort after Loaded.
- In the Loaded handler, re-read the current element from the anchor's
  Tag and bail unless IsOpen is still true — guards against a stale show
  if state flipped back to false (or the element was replaced) before
  the placeholder attached.
- Revert ShowContentDialog from internal to private (no external caller).
- Log ShowAsync exceptions via Debug.WriteLine instead of silently
  swallowing, matching the rest of the framework's best-effort pattern.

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

---------

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

Author: codemonkeychris

src/Reactor/Core/Reconciler.Mount.cs

@@ -1732,30 +1732,60 @@ private UIElement MountContentDialog(ContentDialogElement cdEl, Action requestRe
     {
         var placeholder = new WinUI.StackPanel { Visibility = Visibility.Collapsed };
         SetElementTag(placeholder, cdEl);
-        if (cdEl.IsOpen) ShowContentDialog(cdEl, requestRerender);
+        if (cdEl.IsOpen) ShowContentDialog(cdEl, placeholder, requestRerender);
         return placeholder;
     }
 
-    private async void ShowContentDialog(ContentDialogElement cdEl, Action requestRerender)
+    private void ShowContentDialog(ContentDialogElement cdEl, FrameworkElement anchor, Action requestRerender)
+    {
+        // Source XamlRoot from the placeholder so the dialog routes to the
+        // window that owns the anchor. If the anchor isn't attached yet
+        // (mount-time IsOpen=true) defer via Loaded — falling back to
+        // PrimaryWindow here would misroute the dialog when the anchor lives
+        // in a secondary window.
+        if (anchor.XamlRoot is null)
+        {
+            void OnLoaded(object sender, RoutedEventArgs _)
+            {
+                anchor.Loaded -= OnLoaded;
+                // Re-read the current element from the anchor's Tag in case
+                // IsOpen was toggled back to false (or the element was
+                // replaced) before Loaded fired.
+                if (GetElementTag(anchor) is not ContentDialogElement current || !current.IsOpen)
+                    return;
+                var deferredRoot = anchor.XamlRoot
+                    ?? ReactorApp.PrimaryWindow?.NativeWindow.Content?.XamlRoot;
+                ShowContentDialogCore(current, deferredRoot, requestRerender);
+            }
+            anchor.Loaded += OnLoaded;
+            return;
+        }
+        ShowContentDialogCore(cdEl, anchor.XamlRoot, requestRerender);
+    }
+
+    private async void ShowContentDialogCore(ContentDialogElement cdEl, XamlRoot? xamlRoot, Action requestRerender)
     {
         var dialog = new WinUI.ContentDialog
         {
             Title = cdEl.Title, PrimaryButtonText = cdEl.PrimaryButtonText,
             DefaultButton = cdEl.DefaultButton,
-            XamlRoot = null,
         };
         if (cdEl.SecondaryButtonText is not null) dialog.SecondaryButtonText = cdEl.SecondaryButtonText;
         if (cdEl.CloseButtonText is not null) dialog.CloseButtonText = cdEl.CloseButtonText;
         dialog.Content = Mount(cdEl.Content, requestRerender);
+        if (xamlRoot is not null) dialog.XamlRoot = xamlRoot;
+        // ApplySetters last so caller .Set(...) wins (including overriding XamlRoot).
         ApplySetters(cdEl.Setters, dialog);
         try
         {
-            if (dialog.Content is UIElement contentUi && contentUi.XamlRoot is not null)
-                dialog.XamlRoot = contentUi.XamlRoot;
             var winUiResult = await dialog.ShowAsync();
             cdEl.OnClosed?.Invoke(winUiResult);
         }
-        catch { }
+        catch (Exception ex)
+        {
+            global::System.Diagnostics.Debug.WriteLine(
+                $"[Reactor.ContentDialog] ShowAsync failed: {ex.GetType().Name}: {ex.Message}");
+        }
     }
 
     private UIElement? MountFlyout(FlyoutElement flyEl, Action requestRerender)

src/Reactor/Core/Reconciler.Update.cs

@@ -2426,7 +2426,7 @@ private static bool StringArrayEquals(string[] a, string[] b)
 
     private UIElement? UpdateContentDialog(ContentDialogElement o, ContentDialogElement n, FrameworkElement fe, Action requestRerender)
     {
-        if (n.IsOpen && !o.IsOpen) ShowContentDialog(n, requestRerender);
+        if (n.IsOpen && !o.IsOpen) ShowContentDialog(n, fe, requestRerender);
         SetElementTag(fe, n);
         return null;
     }

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

@@ -320,6 +320,91 @@ public override async Task RunAsync()
         }
     }
 
+    // Regression for #246: declarative IsOpen=true at first mount must actually
+    // show the dialog. Previously the framework tried to read XamlRoot from the
+    // dialog's just-mounted (detached) content, which is always null, so
+    // ShowAsync() threw and the empty catch swallowed it.
+    internal class ContentDialogOpensAtMount(Harness h) : SelfTestFixtureBase(h)
+    {
+        public override async Task RunAsync()
+        {
+            var host = H.CreateHost();
+            host.Mount(_ => VStack(
+                TextBlock("anchor"),
+                ContentDialog("AutoOpen", TextBlock("dialog-body"), "OK") with { IsOpen = true }
+            ));
+
+            await Harness.Render(100);
+
+            var dialog = FindOpenContentDialog(H, "AutoOpen");
+            H.Check("ContentDialog_OpensAtMount_#246", dialog is not null);
+
+            dialog?.Hide();
+            await Harness.Render(50);
+        }
+    }
+
+    // Regression for #246: flipping IsOpen false→true via state must show the
+    // dialog without requiring the app to set XamlRoot manually.
+    internal class ContentDialogOpensOnStateFlip(Harness h) : SelfTestFixtureBase(h)
+    {
+        public override async Task RunAsync()
+        {
+            var host = H.CreateHost();
+            host.Mount(ctx =>
+            {
+                var (open, setOpen) = ctx.UseState(false);
+                return VStack(
+                    Button("Show", () => setOpen(true)),
+                    ContentDialog("Toggled", TextBlock("dialog-body"), "OK") with { IsOpen = open }
+                );
+            });
+
+            await Harness.Render();
+            H.Check("ContentDialog_NotOpenBeforeClick_#246", FindOpenContentDialog(H, "Toggled") is null);
+
+            H.ClickButton("Show");
+            await Harness.Render(50);
+
+            var dialog = FindOpenContentDialog(H, "Toggled");
+            H.Check("ContentDialog_OpensOnStateFlip_#246", dialog is not null);
+
+            dialog?.Hide();
+            await Harness.Render(50);
+        }
+    }
+
+    private static Microsoft.UI.Xaml.Controls.ContentDialog? FindOpenContentDialog(Harness h, string title)
+    {
+        var xamlRoot = (h.Window.Content as UIElement)?.XamlRoot
+                       ?? ReactorApp.PrimaryWindow?.NativeWindow.Content?.XamlRoot;
+        if (xamlRoot is null) return null;
+        foreach (var popup in VisualTreeHelper.GetOpenPopupsForXamlRoot(xamlRoot))
+        {
+            // Popup.Child is not enumerated by VisualTreeHelper.GetChildrenCount,
+            // so descend into it explicitly before recursing.
+            if (popup.Child is DependencyObject child)
+            {
+                var found = WalkForContentDialog(child, title);
+                if (found is not null) return found;
+            }
+        }
+        return null;
+    }
+
+    private static Microsoft.UI.Xaml.Controls.ContentDialog? WalkForContentDialog(DependencyObject node, string title)
+    {
+        if (node is Microsoft.UI.Xaml.Controls.ContentDialog cd && cd.Title as string == title)
+            return cd;
+        int count = VisualTreeHelper.GetChildrenCount(node);
+        for (int i = 0; i < count; i++)
+        {
+            var hit = WalkForContentDialog(VisualTreeHelper.GetChild(node, i), title);
+            if (hit is not null) return hit;
+        }
+        return null;
+    }
+
     // ════════════════════════════════════════════════════════════════════════
     //  6. CommandBar — mount + update (primary/secondary commands)
     //     Targets: Reconciler.Mount.cs lines 1636+, Reconciler.Update.cs lines 1593+

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

@@ -81,8 +81,10 @@ public override async Task RunAsync()
     //  ContentDialog mount + update (~15 lines each)
     // ════════════════════════════════════════════════════════════════════
 
-    // ContentDialog is rendered as a popup overlay and requires ShowAsync() to appear
-    // in the visual tree — tested via interactive tests instead of self-tests.
+    // ContentDialog mount + open coverage lives in CoreCoverageFixtures
+    // (ContentDialogMount + ContentDialogOpensAtMount + ContentDialogOpensOnStateFlip).
+    // The dialog appears as a popup; ShowAsync() is fire-and-forget here so the
+    // fixtures probe VisualTreeHelper.GetOpenPopupsForXamlRoot() after a render.
 
     // ════════════════════════════════════════════════════════════════════
     //  GridView mount + update

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

@@ -349,6 +349,8 @@ internal static class SelfTestFixtureRegistry
         "CoreCov_TemplatedFlipViewMountUpdate",
         "CoreCov_LazyVStackMountUpdate",
         "CoreCov_ContentDialogMount",
+        "CoreCov_ContentDialogOpensAtMount",
+        "CoreCov_ContentDialogOpensOnStateFlip",
         "CoreCov_CommandBarMountUpdate",
         "CoreCov_CommandHostMountUpdate",
         "CoreCov_MenuBarMountUpdate",
@@ -1137,6 +1139,8 @@ internal static class SelfTestFixtureRegistry
         "CoreCov_TemplatedFlipViewMountUpdate" => new CoreCoverageFixtures.TemplatedFlipViewMountUpdate(harness),
         "CoreCov_LazyVStackMountUpdate" => new CoreCoverageFixtures.LazyVStackMountUpdate(harness),
         "CoreCov_ContentDialogMount" => new CoreCoverageFixtures.ContentDialogMount(harness),
+        "CoreCov_ContentDialogOpensAtMount" => new CoreCoverageFixtures.ContentDialogOpensAtMount(harness),
+        "CoreCov_ContentDialogOpensOnStateFlip" => new CoreCoverageFixtures.ContentDialogOpensOnStateFlip(harness),
         "CoreCov_CommandBarMountUpdate" => new CoreCoverageFixtures.CommandBarMountUpdate(harness),
         "CoreCov_CommandHostMountUpdate" => new CoreCoverageFixtures.CommandHostMountUpdate(harness),
         "CoreCov_MenuBarMountUpdate" => new CoreCoverageFixtures.MenuBarMountUpdate(harness),