From 161a798d1fccfe5c88bd801ee051126356737253 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Mon, 31 Aug 2026 22:00:45 +0200
Subject: [PATCH 01/14] feat: add floating region views

---
 samples/Sample.Avalonia/App.axaml.cs          |   3 +-
 .../Sample.Avalonia/Sample.Avalonia.csproj    |   1 +
 .../Sample.Avalonia/Views/TabRegionView.axaml |  10 +
 .../Views/TabRegionView.axaml.cs              |  35 ++-
 samples/Sample.Wpf/App.xaml.cs                |   1 +
 samples/Sample.Wpf/Sample.Wpf.csproj          |   1 +
 samples/Sample.Wpf/Views/TabRegionView.xaml   |  10 +
 .../Sample.Wpf/Views/TabRegionView.xaml.cs    |  31 ++-
 .../AsyncNavigation.Avalonia.Floating.csproj  |  12 +
 .../AvaloniaFloatingWindowHost.cs             |  90 +++++++
 .../DependencyInjectionExtensions.cs          |  15 ++
 src/AsyncNavigation.Avalonia/ContentRegion.cs |  28 ++-
 src/AsyncNavigation.Avalonia/TabRegion.cs     |  39 ++-
 .../AsyncNavigation.Floating.csproj           |  11 +
 .../FloatingServiceCollectionExtensions.cs    |  16 ++
 .../FloatingWindowOptions.cs                  |  17 ++
 .../IFloatingViewSession.cs                   |  11 +
 .../IFloatingWindowHost.cs                    |  15 ++
 .../IViewPlacementService.cs                  |  10 +
 .../ViewPlacementService.cs                   | 225 ++++++++++++++++++
 .../ViewPlacementState.cs                     |   8 +
 .../AsyncNavigation.Wpf.Floating.csproj       |  13 +
 .../DependencyInjectionExtensions.cs          |  15 ++
 .../WpfFloatingWindowHost.cs                  |  88 +++++++
 src/AsyncNavigation.Wpf/ContentRegion.cs      |  28 ++-
 src/AsyncNavigation.Wpf/TabRegion.cs          |  39 ++-
 src/AsyncNavigation.slnx                      |   3 +
 .../IRegionPlacementParticipant.cs            |  18 ++
 src/AsyncNavigation/RegionPlacementItem.cs    |  21 ++
 .../AsyncNavigation.Tests.csproj              |   1 +
 .../ViewPlacementServiceTests.cs              | 172 +++++++++++++
 31 files changed, 979 insertions(+), 8 deletions(-)
 create mode 100644 src/AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj
 create mode 100644 src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
 create mode 100644 src/AsyncNavigation.Avalonia.Floating/DependencyInjectionExtensions.cs
 create mode 100644 src/AsyncNavigation.Floating/AsyncNavigation.Floating.csproj
 create mode 100644 src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs
 create mode 100644 src/AsyncNavigation.Floating/FloatingWindowOptions.cs
 create mode 100644 src/AsyncNavigation.Floating/IFloatingViewSession.cs
 create mode 100644 src/AsyncNavigation.Floating/IFloatingWindowHost.cs
 create mode 100644 src/AsyncNavigation.Floating/IViewPlacementService.cs
 create mode 100644 src/AsyncNavigation.Floating/ViewPlacementService.cs
 create mode 100644 src/AsyncNavigation.Floating/ViewPlacementState.cs
 create mode 100644 src/AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj
 create mode 100644 src/AsyncNavigation.Wpf.Floating/DependencyInjectionExtensions.cs
 create mode 100644 src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
 create mode 100644 src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs
 create mode 100644 src/AsyncNavigation/RegionPlacementItem.cs
 create mode 100644 tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs

diff --git a/samples/Sample.Avalonia/App.axaml.cs b/samples/Sample.Avalonia/App.axaml.cs
index da64262..9e030f9 100644
--- a/samples/Sample.Avalonia/App.axaml.cs
+++ b/samples/Sample.Avalonia/App.axaml.cs
@@ -30,6 +30,7 @@ public override void OnFrameworkInitializationCompleted()
 
         var services = new ServiceCollection();
         services.AddNavigationSupport(navigationOptions)
+                .AddFloatingSupport()
                 .AddSingletonWithAllMembers<MainWindowViewModel>()
                 .RegisterView<LightView, LightViewModel>(nameof(LightView))
                 .RegisterView<ItemsRegionView, ItemsRegionViewModel>(nameof(ItemsRegionView))
@@ -89,4 +90,4 @@ public override void OnFrameworkInitializationCompleted()
         }
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/samples/Sample.Avalonia/Sample.Avalonia.csproj b/samples/Sample.Avalonia/Sample.Avalonia.csproj
index 91ca3b0..3c65a09 100644
--- a/samples/Sample.Avalonia/Sample.Avalonia.csproj
+++ b/samples/Sample.Avalonia/Sample.Avalonia.csproj
@@ -30,6 +30,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\AsyncNavigation.Avalonia\AsyncNavigation.Avalonia.csproj" />
+    <ProjectReference Include="..\..\src\AsyncNavigation.Avalonia.Floating\AsyncNavigation.Avalonia.Floating.csproj" />
     <ProjectReference Include="..\Sample.Common\Sample.Common.csproj" />
   </ItemGroup>
 
diff --git a/samples/Sample.Avalonia/Views/TabRegionView.axaml b/samples/Sample.Avalonia/Views/TabRegionView.axaml
index 221630d..a8b5852 100644
--- a/samples/Sample.Avalonia/Views/TabRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/TabRegionView.axaml
@@ -45,6 +45,16 @@
                 Classes="NavigationAndForget"
                 Content="ToLightView:Forget;New"
                 Tag="LightView:New" />
+            <Separator Margin="4" />
+            <Button
+                Padding="8,4"
+                Click="FloatCurrent_Click"
+                Content="Float current tab" />
+            <TextBlock
+                Width="150"
+                Margin="4"
+                Text="Close the floating window to restore the tab."
+                TextWrapping="Wrap" />
         </StackPanel>
         <ScrollViewer>
             <TabControl
diff --git a/samples/Sample.Avalonia/Views/TabRegionView.axaml.cs b/samples/Sample.Avalonia/Views/TabRegionView.axaml.cs
index 0816009..66460c4 100644
--- a/samples/Sample.Avalonia/Views/TabRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/TabRegionView.axaml.cs
@@ -1,12 +1,43 @@
 using AsyncNavigation.Abstractions;
 using Avalonia.Controls;
+using AsyncNavigation.Floating;
+using Avalonia.Interactivity;
+using System.Diagnostics;
+using System;
 
 namespace Sample.Avalonia.Views;
 
 public partial class TabRegionView : UserControl, IView
 {
-    public TabRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public TabRegionView() : this(null)
+    {
+    }
+
+    public TabRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
-}
\ No newline at end of file
+
+    private async void FloatCurrent_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("TabRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating tab",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float tab: {ex.Message}");
+        }
+    }
+}
diff --git a/samples/Sample.Wpf/App.xaml.cs b/samples/Sample.Wpf/App.xaml.cs
index e997c49..dc2eaef 100644
--- a/samples/Sample.Wpf/App.xaml.cs
+++ b/samples/Sample.Wpf/App.xaml.cs
@@ -21,6 +21,7 @@ protected override void OnStartup(StartupEventArgs e)
 
         var services = new ServiceCollection();
         services.AddNavigationSupport()
+            .AddFloatingSupport()
             .AddSingleton<MainWindowViewModel>()
             .RegisterRegionAdapter<ListBoxRegionAdapter>()
             .RegisterView<LightView, LightViewModel>(nameof(LightView))
diff --git a/samples/Sample.Wpf/Sample.Wpf.csproj b/samples/Sample.Wpf/Sample.Wpf.csproj
index bd261a5..cc694f8 100644
--- a/samples/Sample.Wpf/Sample.Wpf.csproj
+++ b/samples/Sample.Wpf/Sample.Wpf.csproj
@@ -19,6 +19,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\AsyncNavigation.Wpf\AsyncNavigation.Wpf.csproj" />
+    <ProjectReference Include="..\..\src\AsyncNavigation.Wpf.Floating\AsyncNavigation.Wpf.Floating.csproj" />
     <ProjectReference Include="..\Sample.Common\Sample.Common.csproj" />
   </ItemGroup>
 
diff --git a/samples/Sample.Wpf/Views/TabRegionView.xaml b/samples/Sample.Wpf/Views/TabRegionView.xaml
index e6b7e1d..f6c6eeb 100644
--- a/samples/Sample.Wpf/Views/TabRegionView.xaml
+++ b/samples/Sample.Wpf/Views/TabRegionView.xaml
@@ -43,6 +43,16 @@
                 Content="ToLightView:Forget;New"
                 Style="{StaticResource NavigationAndForget}"
                 Tag="LightView:New" />
+            <Separator Margin="4" />
+            <Button
+                Padding="8,4"
+                Click="FloatCurrent_Click"
+                Content="Float current tab" />
+            <TextBlock
+                Width="150"
+                Margin="4"
+                Text="Close the floating window to restore the tab."
+                TextWrapping="Wrap" />
         </StackPanel>
         <ScrollViewer>
             <TabControl
diff --git a/samples/Sample.Wpf/Views/TabRegionView.xaml.cs b/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
index 6dbd290..96a91e2 100644
--- a/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
@@ -1,5 +1,7 @@
 using AsyncNavigation.Abstractions;
 using System.Windows.Controls;
+using AsyncNavigation.Floating;
+using System.Windows;
 
 namespace Sample.Wpf.Views;
 
@@ -8,8 +10,35 @@ namespace Sample.Wpf.Views;
 /// </summary>
 public partial class TabRegionView : UserControl, IView
 {
-    public TabRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public TabRegionView() : this(null)
+    {
+    }
+
+    public TabRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
+
+    private async void FloatCurrent_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("TabRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating tab",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (InvalidOperationException ex)
+        {
+            MessageBox.Show(ex.Message, "Cannot float tab", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
 }
diff --git a/src/AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj b/src/AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj
new file mode 100644
index 0000000..9c561c5
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../../package.props" />
+  <PropertyGroup>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\AsyncNavigation.Avalonia\AsyncNavigation.Avalonia.csproj" />
+    <ProjectReference Include="..\AsyncNavigation.Floating\AsyncNavigation.Floating.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
new file mode 100644
index 0000000..5a2dfb8
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
@@ -0,0 +1,90 @@
+using AsyncNavigation.Floating;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Threading;
+
+namespace AsyncNavigation.Avalonia.Floating;
+
+internal sealed class AvaloniaFloatingWindowHostFactory : IFloatingWindowHostFactory
+{
+    public IFloatingWindowHost Create(FloatingWindowOptions options)
+    {
+        if (!Dispatcher.UIThread.CheckAccess())
+            throw new InvalidOperationException("Floating windows must be created on the Avalonia UI thread.");
+        if (Application.Current?.ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime)
+            throw new NotSupportedException("Floating windows require Avalonia's classic desktop lifetime.");
+        return new AvaloniaFloatingWindowHost(options);
+    }
+}
+
+internal sealed class AvaloniaFloatingWindowHost : IFloatingWindowHost
+{
+    private readonly Window _window;
+    private bool _allowClose;
+
+    public AvaloniaFloatingWindowHost(FloatingWindowOptions options)
+    {
+        _window = new Window
+        {
+            Title = options.Title,
+            Topmost = options.Topmost,
+            SizeToContent = options.Width.HasValue || options.Height.HasValue
+                ? SizeToContent.Manual
+                : SizeToContent.WidthAndHeight
+        };
+        if (options.Width.HasValue) _window.Width = options.Width.Value;
+        if (options.Height.HasValue) _window.Height = options.Height.Value;
+        _window.Closing += OnClosing;
+    }
+
+    public event EventHandler? RestoreRequested;
+
+    public Task SetContentAsync(object? content, CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _window.Content = content, cancellationToken);
+
+    public Task ShowAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(_window.Show, cancellationToken);
+
+    public Task ActivateAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _window.Activate(), cancellationToken);
+
+    public Task CloseAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() =>
+        {
+            _allowClose = true;
+            _window.Close();
+        }, cancellationToken);
+
+    public async ValueTask DisposeAsync()
+    {
+        await InvokeAsync(() =>
+        {
+            _window.Closing -= OnClosing;
+            if (_window.IsVisible)
+            {
+                _allowClose = true;
+                _window.Close();
+            }
+        }, CancellationToken.None);
+    }
+
+    private void OnClosing(object? sender, WindowClosingEventArgs e)
+    {
+        if (_allowClose)
+            return;
+        e.Cancel = true;
+        RestoreRequested?.Invoke(this, EventArgs.Empty);
+    }
+
+    private async Task InvokeAsync(Action action, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (Dispatcher.UIThread.CheckAccess())
+        {
+            action();
+            return;
+        }
+        await Dispatcher.UIThread.InvokeAsync(action);
+    }
+}
diff --git a/src/AsyncNavigation.Avalonia.Floating/DependencyInjectionExtensions.cs b/src/AsyncNavigation.Avalonia.Floating/DependencyInjectionExtensions.cs
new file mode 100644
index 0000000..8dc3401
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/DependencyInjectionExtensions.cs
@@ -0,0 +1,15 @@
+using AsyncNavigation.Avalonia.Floating;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static class FloatingDependencyInjectionExtensions
+{
+    public static IServiceCollection AddFloatingSupport(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+        services.TryAddSingleton<IFloatingWindowHostFactory, AvaloniaFloatingWindowHostFactory>();
+        return services.AddFloatingSupportCore();
+    }
+}
diff --git a/src/AsyncNavigation.Avalonia/ContentRegion.cs b/src/AsyncNavigation.Avalonia/ContentRegion.cs
index b2cd170..03c8cbb 100644
--- a/src/AsyncNavigation.Avalonia/ContentRegion.cs
+++ b/src/AsyncNavigation.Avalonia/ContentRegion.cs
@@ -1,11 +1,12 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using Avalonia.Controls;
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
 
 namespace AsyncNavigation.Avalonia;
 
-public class ContentRegion : RegionBase<ContentRegion, ContentControl>
+public class ContentRegion : RegionBase<ContentRegion, ContentControl>, IRegionPlacementParticipant
 {
     public ContentRegion(string name, 
         ContentControl contentControl, 
@@ -56,4 +57,29 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         _context.Selected = null;
         return Task.CompletedTask;
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = _context.Selected;
+        if (context is null || navigationId.HasValue && context.NavigationId != navigationId.Value)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, 0, true);
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (!ReferenceEquals(_context.Selected, item.Context))
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+        _context.Selected = null;
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Selected is not null)
+            throw new InvalidOperationException($"Region '{Name}' already contains a navigation item.");
+        _context.Selected = item.Context;
+    }
 }
diff --git a/src/AsyncNavigation.Avalonia/TabRegion.cs b/src/AsyncNavigation.Avalonia/TabRegion.cs
index 275a957..39ac9fd 100644
--- a/src/AsyncNavigation.Avalonia/TabRegion.cs
+++ b/src/AsyncNavigation.Avalonia/TabRegion.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
@@ -6,7 +7,7 @@
 
 namespace AsyncNavigation.Avalonia;
 
-public class TabRegion : RegionBase<TabRegion, TabControl>
+public class TabRegion : RegionBase<TabRegion, TabControl>, IRegionPlacementParticipant
 {
     public TabRegion(string name,
         TabControl tabControl,
@@ -67,6 +68,42 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         return Task.CompletedTask;
     }
 
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected;
+
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context), ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
+
 }
 
 
diff --git a/src/AsyncNavigation.Floating/AsyncNavigation.Floating.csproj b/src/AsyncNavigation.Floating/AsyncNavigation.Floating.csproj
new file mode 100644
index 0000000..8578d28
--- /dev/null
+++ b/src/AsyncNavigation.Floating/AsyncNavigation.Floating.csproj
@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../../package.props" />
+  <PropertyGroup>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\AsyncNavigation\AsyncNavigation.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs b/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs
new file mode 100644
index 0000000..8277381
--- /dev/null
+++ b/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs
@@ -0,0 +1,16 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using System.ComponentModel;
+
+namespace AsyncNavigation.Floating;
+
+[EditorBrowsable(EditorBrowsableState.Never)]
+public static class FloatingServiceCollectionExtensions
+{
+    public static IServiceCollection AddFloatingSupportCore(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+        services.TryAddSingleton<IViewPlacementService, ViewPlacementService>();
+        return services;
+    }
+}
diff --git a/src/AsyncNavigation.Floating/FloatingWindowOptions.cs b/src/AsyncNavigation.Floating/FloatingWindowOptions.cs
new file mode 100644
index 0000000..946d66c
--- /dev/null
+++ b/src/AsyncNavigation.Floating/FloatingWindowOptions.cs
@@ -0,0 +1,17 @@
+namespace AsyncNavigation.Floating;
+
+public sealed class FloatingWindowOptions
+{
+    public string? Title { get; init; }
+    public double? Width { get; init; }
+    public double? Height { get; init; }
+    public bool Topmost { get; init; }
+
+    internal FloatingWindowOptions WithDefaultTitle(string title) => new()
+    {
+        Title = Title ?? title,
+        Width = Width,
+        Height = Height,
+        Topmost = Topmost
+    };
+}
diff --git a/src/AsyncNavigation.Floating/IFloatingViewSession.cs b/src/AsyncNavigation.Floating/IFloatingViewSession.cs
new file mode 100644
index 0000000..317220b
--- /dev/null
+++ b/src/AsyncNavigation.Floating/IFloatingViewSession.cs
@@ -0,0 +1,11 @@
+namespace AsyncNavigation.Floating;
+
+public interface IFloatingViewSession
+{
+    Guid Id { get; }
+    Guid NavigationId { get; }
+    string OriginRegionName { get; }
+    ViewPlacementState State { get; }
+    Task RestoreAsync(CancellationToken cancellationToken = default);
+    Task ActivateAsync(CancellationToken cancellationToken = default);
+}
diff --git a/src/AsyncNavigation.Floating/IFloatingWindowHost.cs b/src/AsyncNavigation.Floating/IFloatingWindowHost.cs
new file mode 100644
index 0000000..0ae5660
--- /dev/null
+++ b/src/AsyncNavigation.Floating/IFloatingWindowHost.cs
@@ -0,0 +1,15 @@
+namespace AsyncNavigation.Floating;
+
+public interface IFloatingWindowHost : IAsyncDisposable
+{
+    event EventHandler? RestoreRequested;
+    Task SetContentAsync(object? content, CancellationToken cancellationToken = default);
+    Task ShowAsync(CancellationToken cancellationToken = default);
+    Task ActivateAsync(CancellationToken cancellationToken = default);
+    Task CloseAsync(CancellationToken cancellationToken = default);
+}
+
+public interface IFloatingWindowHostFactory
+{
+    IFloatingWindowHost Create(FloatingWindowOptions options);
+}
diff --git a/src/AsyncNavigation.Floating/IViewPlacementService.cs b/src/AsyncNavigation.Floating/IViewPlacementService.cs
new file mode 100644
index 0000000..1bb001e
--- /dev/null
+++ b/src/AsyncNavigation.Floating/IViewPlacementService.cs
@@ -0,0 +1,10 @@
+namespace AsyncNavigation.Floating;
+
+public interface IViewPlacementService
+{
+    IReadOnlyCollection<IFloatingViewSession> FloatingViews { get; }
+    Task<IFloatingViewSession> FloatAsync(string regionName, Guid? navigationId = null,
+        FloatingWindowOptions? options = null, CancellationToken cancellationToken = default);
+    Task RestoreAsync(Guid sessionId, CancellationToken cancellationToken = default);
+    bool TryGetSession(Guid sessionId, out IFloatingViewSession? session);
+}
diff --git a/src/AsyncNavigation.Floating/ViewPlacementService.cs b/src/AsyncNavigation.Floating/ViewPlacementService.cs
new file mode 100644
index 0000000..af6e0af
--- /dev/null
+++ b/src/AsyncNavigation.Floating/ViewPlacementService.cs
@@ -0,0 +1,225 @@
+using AsyncNavigation.Abstractions;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+
+namespace AsyncNavigation.Floating;
+
+internal sealed class ViewPlacementService : IViewPlacementService, IDisposable
+{
+    private readonly IRegionManager _regionManager;
+    private readonly IFloatingWindowHostFactory _windowFactory;
+    private readonly ConcurrentDictionary<Guid, FloatingViewSession> _sessions = [];
+    private readonly ConcurrentDictionary<Guid, Guid> _sessionsByNavigationId = [];
+
+    public ViewPlacementService(IRegionManager regionManager, IFloatingWindowHostFactory windowFactory)
+    {
+        _regionManager = regionManager;
+        _windowFactory = windowFactory;
+    }
+
+    public IReadOnlyCollection<IFloatingViewSession> FloatingViews =>
+        _sessions.Values.Cast<IFloatingViewSession>().ToArray();
+
+    public async Task<IFloatingViewSession> FloatAsync(
+        string regionName,
+        Guid? navigationId = null,
+        FloatingWindowOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(regionName);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (navigationId.HasValue &&
+            _sessionsByNavigationId.TryGetValue(navigationId.Value, out var activeSessionId) &&
+            _sessions.TryGetValue(activeSessionId, out var activeSession))
+        {
+            await activeSession.ActivateAsync(cancellationToken);
+            return activeSession;
+        }
+
+        if (!_regionManager.TryGetRegion(regionName, out var region))
+            throw new InvalidOperationException($"Region '{regionName}' was not found.");
+        if (region is not IRegionPlacementParticipant participant)
+            throw new NotSupportedException($"Region '{regionName}' does not support view placement changes.");
+
+        var item = participant.Capture(navigationId);
+        if (_sessionsByNavigationId.TryGetValue(item.Context.NavigationId, out var existingId) &&
+            _sessions.TryGetValue(existingId, out var existing))
+        {
+            await existing.ActivateAsync(cancellationToken);
+            return existing;
+        }
+
+        options = (options ?? new FloatingWindowOptions()).WithDefaultTitle(item.Context.ViewName);
+        var host = _windowFactory.Create(options);
+        var session = new FloatingViewSession(this, Guid.NewGuid(), regionName, item, host);
+
+        if (!_sessionsByNavigationId.TryAdd(item.Context.NavigationId, session.Id))
+        {
+            await host.DisposeAsync();
+            if (_sessionsByNavigationId.TryGetValue(item.Context.NavigationId, out var concurrentId) &&
+                _sessions.TryGetValue(concurrentId, out var concurrentSession))
+            {
+                await concurrentSession.ActivateAsync(cancellationToken);
+                return concurrentSession;
+            }
+            throw new InvalidOperationException("Another floating operation is already in progress for this view.");
+        }
+        if (!_sessions.TryAdd(session.Id, session))
+        {
+            _sessionsByNavigationId.TryRemove(item.Context.NavigationId, out _);
+            await host.DisposeAsync();
+            throw new InvalidOperationException("Could not create a floating view session.");
+        }
+
+        host.RestoreRequested += session.OnRestoreRequested;
+        var detached = false;
+        try
+        {
+            participant.Detach(item);
+            detached = true;
+            await host.SetContentAsync(GetContentHost(item), cancellationToken);
+            await host.ShowAsync(cancellationToken);
+            return session;
+        }
+        catch
+        {
+            host.RestoreRequested -= session.OnRestoreRequested;
+            _sessions.TryRemove(session.Id, out _);
+            _sessionsByNavigationId.TryRemove(item.Context.NavigationId, out _);
+            try
+            {
+                await host.SetContentAsync(null, CancellationToken.None);
+                if (detached)
+                    participant.Attach(item);
+            }
+            finally
+            {
+                await host.DisposeAsync();
+            }
+            throw;
+        }
+    }
+
+    public Task RestoreAsync(Guid sessionId, CancellationToken cancellationToken = default)
+    {
+        if (!_sessions.TryGetValue(sessionId, out var session))
+            throw new KeyNotFoundException($"Floating view session '{sessionId}' was not found.");
+        return session.RestoreAsync(cancellationToken);
+    }
+
+    public bool TryGetSession(Guid sessionId, out IFloatingViewSession? session)
+    {
+        var found = _sessions.TryGetValue(sessionId, out var value);
+        session = value;
+        return found;
+    }
+
+    internal async Task RestoreCoreAsync(FloatingViewSession session, CancellationToken cancellationToken)
+    {
+        if (!_regionManager.TryGetRegion(session.OriginRegionName, out var region) ||
+            region is not IRegionPlacementParticipant participant)
+        {
+            throw new InvalidOperationException($"Origin region '{session.OriginRegionName}' is not available.");
+        }
+
+        await session.Host.SetContentAsync(null, cancellationToken);
+        try
+        {
+            participant.Attach(session.Item);
+        }
+        catch
+        {
+            await session.Host.SetContentAsync(GetContentHost(session.Item), CancellationToken.None);
+            throw;
+        }
+
+        _sessions.TryRemove(session.Id, out _);
+        _sessionsByNavigationId.TryRemove(session.NavigationId, out _);
+        session.Host.RestoreRequested -= session.OnRestoreRequested;
+        try
+        {
+            await session.Host.CloseAsync(CancellationToken.None);
+            await session.Host.DisposeAsync();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Could not close floating window for '{session.NavigationId}': {ex}");
+        }
+    }
+
+    public void Dispose()
+    {
+        foreach (var session in _sessions.Values)
+            session.Host.RestoreRequested -= session.OnRestoreRequested;
+        _sessions.Clear();
+        _sessionsByNavigationId.Clear();
+    }
+
+    private static object GetContentHost(RegionPlacementItem item) =>
+        item.Context.IndicatorHost.Value?.Host
+        ?? throw new InvalidOperationException("The navigation item does not have an indicator host.");
+
+    internal sealed class FloatingViewSession : IFloatingViewSession
+    {
+        private readonly ViewPlacementService _owner;
+        private readonly SemaphoreSlim _gate = new(1, 1);
+
+        internal FloatingViewSession(ViewPlacementService owner, Guid id, string originRegionName,
+            RegionPlacementItem item, IFloatingWindowHost host)
+        {
+            _owner = owner;
+            Id = id;
+            OriginRegionName = originRegionName;
+            Item = item;
+            Host = host;
+        }
+
+        public Guid Id { get; }
+        public Guid NavigationId => Item.Context.NavigationId;
+        public string OriginRegionName { get; }
+        public ViewPlacementState State { get; private set; } = ViewPlacementState.Floating;
+        internal RegionPlacementItem Item { get; }
+        internal IFloatingWindowHost Host { get; }
+
+        public async Task RestoreAsync(CancellationToken cancellationToken = default)
+        {
+            await _gate.WaitAsync(cancellationToken);
+            try
+            {
+                if (State == ViewPlacementState.Restored)
+                    return;
+                State = ViewPlacementState.Restoring;
+                try
+                {
+                    await _owner.RestoreCoreAsync(this, cancellationToken);
+                    State = ViewPlacementState.Restored;
+                }
+                catch
+                {
+                    State = ViewPlacementState.Floating;
+                    throw;
+                }
+            }
+            finally
+            {
+                _gate.Release();
+            }
+        }
+
+        public Task ActivateAsync(CancellationToken cancellationToken = default) =>
+            Host.ActivateAsync(cancellationToken);
+
+        internal async void OnRestoreRequested(object? sender, EventArgs e)
+        {
+            try
+            {
+                await RestoreAsync();
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"Could not restore floating view '{NavigationId}': {ex}");
+            }
+        }
+    }
+}
diff --git a/src/AsyncNavigation.Floating/ViewPlacementState.cs b/src/AsyncNavigation.Floating/ViewPlacementState.cs
new file mode 100644
index 0000000..4b08403
--- /dev/null
+++ b/src/AsyncNavigation.Floating/ViewPlacementState.cs
@@ -0,0 +1,8 @@
+namespace AsyncNavigation.Floating;
+
+public enum ViewPlacementState
+{
+    Floating,
+    Restoring,
+    Restored
+}
diff --git a/src/AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj b/src/AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj
new file mode 100644
index 0000000..3ba14a6
--- /dev/null
+++ b/src/AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="../../package.props" />
+  <PropertyGroup>
+    <TargetFrameworks>net8.0-windows;net10.0-windows</TargetFrameworks>
+    <UseWPF>true</UseWPF>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\AsyncNavigation.Wpf\AsyncNavigation.Wpf.csproj" />
+    <ProjectReference Include="..\AsyncNavigation.Floating\AsyncNavigation.Floating.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/src/AsyncNavigation.Wpf.Floating/DependencyInjectionExtensions.cs b/src/AsyncNavigation.Wpf.Floating/DependencyInjectionExtensions.cs
new file mode 100644
index 0000000..52de7e6
--- /dev/null
+++ b/src/AsyncNavigation.Wpf.Floating/DependencyInjectionExtensions.cs
@@ -0,0 +1,15 @@
+using AsyncNavigation.Floating;
+using AsyncNavigation.Wpf.Floating;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static class FloatingDependencyInjectionExtensions
+{
+    public static IServiceCollection AddFloatingSupport(this IServiceCollection services)
+    {
+        ArgumentNullException.ThrowIfNull(services);
+        services.TryAddSingleton<IFloatingWindowHostFactory, WpfFloatingWindowHostFactory>();
+        return services.AddFloatingSupportCore();
+    }
+}
diff --git a/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs b/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
new file mode 100644
index 0000000..d80dd80
--- /dev/null
+++ b/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
@@ -0,0 +1,88 @@
+using AsyncNavigation.Floating;
+using System.ComponentModel;
+using System.Windows;
+
+namespace AsyncNavigation.Wpf.Floating;
+
+internal sealed class WpfFloatingWindowHostFactory : IFloatingWindowHostFactory
+{
+    public IFloatingWindowHost Create(FloatingWindowOptions options)
+    {
+        var application = Application.Current
+            ?? throw new InvalidOperationException("A WPF Application must be running before a floating window can be created.");
+        if (!application.Dispatcher.CheckAccess())
+            throw new InvalidOperationException("Floating windows must be created on the WPF UI thread.");
+        return new WpfFloatingWindowHost(options);
+    }
+}
+
+internal sealed class WpfFloatingWindowHost : IFloatingWindowHost
+{
+    private readonly Window _window;
+    private bool _allowClose;
+
+    public WpfFloatingWindowHost(FloatingWindowOptions options)
+    {
+        _window = new Window
+        {
+            Title = options.Title ?? string.Empty,
+            Topmost = options.Topmost,
+            SizeToContent = options.Width.HasValue || options.Height.HasValue
+                ? SizeToContent.Manual
+                : SizeToContent.WidthAndHeight
+        };
+        if (options.Width.HasValue) _window.Width = options.Width.Value;
+        if (options.Height.HasValue) _window.Height = options.Height.Value;
+        _window.Closing += OnClosing;
+    }
+
+    public event EventHandler? RestoreRequested;
+
+    public Task SetContentAsync(object? content, CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _window.Content = content, cancellationToken);
+
+    public Task ShowAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(_window.Show, cancellationToken);
+
+    public Task ActivateAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _window.Activate(), cancellationToken);
+
+    public Task CloseAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() =>
+        {
+            _allowClose = true;
+            _window.Close();
+        }, cancellationToken);
+
+    public async ValueTask DisposeAsync()
+    {
+        await InvokeAsync(() =>
+        {
+            _window.Closing -= OnClosing;
+            if (_window.IsVisible)
+            {
+                _allowClose = true;
+                _window.Close();
+            }
+        }, CancellationToken.None);
+    }
+
+    private void OnClosing(object? sender, CancelEventArgs e)
+    {
+        if (_allowClose)
+            return;
+        e.Cancel = true;
+        RestoreRequested?.Invoke(this, EventArgs.Empty);
+    }
+
+    private Task InvokeAsync(Action action, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (_window.Dispatcher.CheckAccess())
+        {
+            action();
+            return Task.CompletedTask;
+        }
+        return _window.Dispatcher.InvokeAsync(action).Task;
+    }
+}
diff --git a/src/AsyncNavigation.Wpf/ContentRegion.cs b/src/AsyncNavigation.Wpf/ContentRegion.cs
index b489fdb..397aa20 100644
--- a/src/AsyncNavigation.Wpf/ContentRegion.cs
+++ b/src/AsyncNavigation.Wpf/ContentRegion.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
@@ -6,7 +7,7 @@
 
 namespace AsyncNavigation.Wpf;
 
-public class ContentRegion : RegionBase<ContentRegion, ContentControl>
+public class ContentRegion : RegionBase<ContentRegion, ContentControl>, IRegionPlacementParticipant
 {
     public ContentRegion(string name, 
         ContentControl contentControl, 
@@ -65,4 +66,29 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         _context.Selected = null;
         return Task.CompletedTask;
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = _context.Selected;
+        if (context is null || navigationId.HasValue && context.NavigationId != navigationId.Value)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, 0, true);
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (!ReferenceEquals(_context.Selected, item.Context))
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+        _context.Selected = null;
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Selected is not null)
+            throw new InvalidOperationException($"Region '{Name}' already contains a navigation item.");
+        _context.Selected = item.Context;
+    }
 }
diff --git a/src/AsyncNavigation.Wpf/TabRegion.cs b/src/AsyncNavigation.Wpf/TabRegion.cs
index 7a22302..18c44f4 100644
--- a/src/AsyncNavigation.Wpf/TabRegion.cs
+++ b/src/AsyncNavigation.Wpf/TabRegion.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
@@ -6,7 +7,7 @@
 
 namespace AsyncNavigation.Wpf;
 
-public class TabRegion : RegionBase<TabRegion, TabControl>
+public class TabRegion : RegionBase<TabRegion, TabControl>, IRegionPlacementParticipant
 {
     public TabRegion(string name, 
         TabControl tabControl, 
@@ -72,6 +73,42 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         _ = _context.Items.Remove(target);
         return Task.CompletedTask;
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected;
+
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context), ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
 }
 
 
diff --git a/src/AsyncNavigation.slnx b/src/AsyncNavigation.slnx
index b6deaa7..c7f36a2 100644
--- a/src/AsyncNavigation.slnx
+++ b/src/AsyncNavigation.slnx
@@ -36,7 +36,10 @@
     <Project Path="../tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj" />
   </Folder>
   <Project Path="AsyncNavigation.Avalonia/AsyncNavigation.Avalonia.csproj" />
+  <Project Path="AsyncNavigation.Avalonia.Floating/AsyncNavigation.Avalonia.Floating.csproj" />
+  <Project Path="AsyncNavigation.Floating/AsyncNavigation.Floating.csproj" />
   <Project Path="AsyncNavigation.WinUI/AsyncNavigation.WinUI.csproj" Id="c655a876-8f02-42e2-b29e-68e893f26170" />
   <Project Path="AsyncNavigation.Wpf/AsyncNavigation.Wpf.csproj" />
+  <Project Path="AsyncNavigation.Wpf.Floating/AsyncNavigation.Wpf.Floating.csproj" />
   <Project Path="AsyncNavigation/AsyncNavigation.csproj" />
 </Solution>
diff --git a/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs b/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs
new file mode 100644
index 0000000..6f3e77c
--- /dev/null
+++ b/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs
@@ -0,0 +1,18 @@
+namespace AsyncNavigation.Abstractions;
+
+/// <summary>
+/// Provides the minimal operations required to temporarily move a rendered
+/// navigation item out of a region and later put it back.
+/// </summary>
+/// <remarks>
+/// Placement changes are not navigation operations and therefore must not
+/// invoke navigation lifecycle callbacks or modify navigation history.
+/// </remarks>
+public interface IRegionPlacementParticipant
+{
+    RegionPlacementItem Capture(Guid? navigationId = null);
+
+    void Detach(RegionPlacementItem item);
+
+    void Attach(RegionPlacementItem item, bool activate = true);
+}
diff --git a/src/AsyncNavigation/RegionPlacementItem.cs b/src/AsyncNavigation/RegionPlacementItem.cs
new file mode 100644
index 0000000..26dbe1a
--- /dev/null
+++ b/src/AsyncNavigation/RegionPlacementItem.cs
@@ -0,0 +1,21 @@
+namespace AsyncNavigation;
+
+/// <summary>
+/// Describes a rendered navigation item and its original position in a region.
+/// </summary>
+public sealed class RegionPlacementItem
+{
+    public RegionPlacementItem(NavigationContext context, int index, bool wasSelected)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        Context = context;
+        Index = index;
+        WasSelected = wasSelected;
+    }
+
+    public NavigationContext Context { get; }
+
+    public int Index { get; }
+
+    public bool WasSelected { get; }
+}
diff --git a/tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj b/tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj
index 5d1b44d..bd352f6 100644
--- a/tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj
+++ b/tests/AsyncNavigation.Tests/AsyncNavigation.Tests.csproj
@@ -36,6 +36,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\AsyncNavigation\AsyncNavigation.csproj" />
+    <ProjectReference Include="..\..\src\AsyncNavigation.Floating\AsyncNavigation.Floating.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs b/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
new file mode 100644
index 0000000..2ab409c
--- /dev/null
+++ b/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
@@ -0,0 +1,172 @@
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+
+namespace AsyncNavigation.Tests;
+
+public sealed class ViewPlacementServiceTests
+{
+    [Fact]
+    public async Task FloatAndRestore_MovesTheSameRenderedHostWithoutNavigating()
+    {
+        var fixture = new Fixture();
+
+        var session = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+
+        Assert.Equal(1, fixture.Region.DetachCount);
+        Assert.Same(fixture.RenderedHost, fixture.Window.Content);
+        Assert.True(fixture.Window.WasShown);
+        Assert.Single(fixture.Service.FloatingViews);
+
+        await session.RestoreAsync();
+
+        Assert.Equal(1, fixture.Region.AttachCount);
+        Assert.Null(fixture.Window.Content);
+        Assert.True(fixture.Window.WasClosed);
+        Assert.Empty(fixture.Service.FloatingViews);
+        Assert.Equal(ViewPlacementState.Restored, session.State);
+    }
+
+    [Fact]
+    public async Task FloatWithSameNavigationId_ActivatesExistingSession()
+    {
+        var fixture = new Fixture();
+
+        var first = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+        var second = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+
+        Assert.Same(first, second);
+        Assert.Equal(1, fixture.Window.ActivateCount);
+        Assert.Equal(1, fixture.Region.CaptureCount);
+        Assert.Equal(1, fixture.Region.DetachCount);
+    }
+
+    [Fact]
+    public async Task FailedWindowShow_RestoresItemAndRemovesSession()
+    {
+        var fixture = new Fixture();
+        fixture.Window.ShowException = new InvalidOperationException("show failed");
+
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            fixture.Service.FloatAsync("main", fixture.Context.NavigationId));
+
+        Assert.Equal(1, fixture.Region.AttachCount);
+        Assert.Null(fixture.Window.Content);
+        Assert.Empty(fixture.Service.FloatingViews);
+        Assert.True(fixture.Window.WasDisposed);
+    }
+
+    private sealed class Fixture
+    {
+        public Fixture()
+        {
+            RenderedHost = new object();
+            Context = new NavigationContext { RegionName = "main", ViewName = "editor" };
+            var indicator = new Mock<IInnerRegionIndicatorHost>();
+            indicator.SetupGet(x => x.Host).Returns(RenderedHost);
+            Context.IndicatorHost.Value = indicator.Object;
+            Item = new RegionPlacementItem(Context, 2, true);
+
+            Region = new FakeRegion(Item);
+
+            IRegion? regionValue = Region;
+            var manager = new Mock<IRegionManager>();
+            manager.Setup(x => x.TryGetRegion("main", out regionValue)).Returns(true);
+
+            Window = new FakeWindowHost();
+            var factory = new Mock<IFloatingWindowHostFactory>();
+            factory.Setup(x => x.Create(It.IsAny<FloatingWindowOptions>())).Returns(Window);
+
+            var provider = new ServiceCollection()
+                .AddSingleton(manager.Object)
+                .AddSingleton(factory.Object)
+                .AddFloatingSupportCore()
+                .BuildServiceProvider();
+            Service = provider.GetRequiredService<IViewPlacementService>();
+        }
+
+        public object RenderedHost { get; }
+        public NavigationContext Context { get; }
+        public RegionPlacementItem Item { get; }
+        public FakeRegion Region { get; }
+        public FakeWindowHost Window { get; }
+        public IViewPlacementService Service { get; }
+    }
+
+    private sealed class FakeRegion : IRegion, IRegionPlacementParticipant
+    {
+        private readonly RegionPlacementItem _item;
+
+        public FakeRegion(RegionPlacementItem item) => _item = item;
+
+        public int CaptureCount { get; private set; }
+        public int DetachCount { get; private set; }
+        public int AttachCount { get; private set; }
+        public string Name => "main";
+        public event EventHandler<NavigationEventArgs>? Navigated;
+        IRegionPresenter IRegion.RegionPresenter => throw new NotSupportedException();
+
+        public RegionPlacementItem Capture(Guid? navigationId = null)
+        {
+            CaptureCount++;
+            return _item;
+        }
+
+        public void Detach(RegionPlacementItem item) => DetachCount++;
+        public void Attach(RegionPlacementItem item, bool activate = true) => AttachCount++;
+        public Task NavigateFromAsync(NavigationContext navigationContext) => Task.CompletedTask;
+        public Task<NavigationResult> ActivateViewAsync(NavigationContext navigationContext) => throw new NotSupportedException();
+        public Task<bool> CanGoBackAsync() => Task.FromResult(false);
+        public Task<NavigationResult> GoBackAsync(CancellationToken cancellationToken = default) => throw new NotSupportedException();
+        public Task<bool> CanGoForwardAsync() => Task.FromResult(false);
+        public Task<NavigationResult> GoForwardAsync(CancellationToken cancellationToken = default) => throw new NotSupportedException();
+        public Task RevertAsync(NavigationContext? navigationContext) => Task.CompletedTask;
+        public void Dispose() { }
+    }
+
+    private sealed class FakeWindowHost : IFloatingWindowHost
+    {
+        public event EventHandler? RestoreRequested;
+        public object? Content { get; private set; }
+        public bool WasShown { get; private set; }
+        public bool WasClosed { get; private set; }
+        public bool WasDisposed { get; private set; }
+        public int ActivateCount { get; private set; }
+        public Exception? ShowException { get; set; }
+
+        public Task SetContentAsync(object? content, CancellationToken cancellationToken = default)
+        {
+            Content = content;
+            return Task.CompletedTask;
+        }
+
+        public Task ShowAsync(CancellationToken cancellationToken = default)
+        {
+            if (ShowException is not null) throw ShowException;
+            WasShown = true;
+            return Task.CompletedTask;
+        }
+
+        public Task ActivateAsync(CancellationToken cancellationToken = default)
+        {
+            ActivateCount++;
+            return Task.CompletedTask;
+        }
+
+        public Task CloseAsync(CancellationToken cancellationToken = default)
+        {
+            WasClosed = true;
+            return Task.CompletedTask;
+        }
+
+        public ValueTask DisposeAsync()
+        {
+            WasDisposed = true;
+            return ValueTask.CompletedTask;
+        }
+
+        public void RequestRestore() => RestoreRequested?.Invoke(this, EventArgs.Empty);
+    }
+}

From c67c71f17913605a66981ebcfce225c6a94bde1c Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 1 Sep 2026 08:20:44 +0200
Subject: [PATCH 02/14] docs(sample): expose Avalonia floating demo

---
 samples/Sample.Avalonia/Views/MainView.axaml      |  2 +-
 samples/Sample.Avalonia/Views/TabRegionView.axaml | 15 +++++++++++++--
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/samples/Sample.Avalonia/Views/MainView.axaml b/samples/Sample.Avalonia/Views/MainView.axaml
index 70df72d..9bfc45f 100644
--- a/samples/Sample.Avalonia/Views/MainView.axaml
+++ b/samples/Sample.Avalonia/Views/MainView.axaml
@@ -77,7 +77,7 @@
                             Tag="ItemsRegionView" />
                         <Button
                             Classes="Navigation"
-                            Content="ToTabRegionView"
+                            Content="Floating demo (tabs)"
                             Tag="TabRegionView" />
                         <Button
                             Classes="Navigation"
diff --git a/samples/Sample.Avalonia/Views/TabRegionView.axaml b/samples/Sample.Avalonia/Views/TabRegionView.axaml
index a8b5852..284f902 100644
--- a/samples/Sample.Avalonia/Views/TabRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/TabRegionView.axaml
@@ -46,12 +46,23 @@
                 Content="ToLightView:Forget;New"
                 Tag="LightView:New" />
             <Separator Margin="4" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                FontWeight="SemiBold"
+                Text="Floating region demo"
+                TextWrapping="Wrap" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                Text="1. Open LightView or HeavyView.&#x0a;2. Select the tab.&#x0a;3. Float the selected tab."
+                TextWrapping="Wrap" />
             <Button
                 Padding="8,4"
                 Click="FloatCurrent_Click"
-                Content="Float current tab" />
+                Content="Float selected tab" />
             <TextBlock
-                Width="150"
+                Width="170"
                 Margin="4"
                 Text="Close the floating window to restore the tab."
                 TextWrapping="Wrap" />

From 739470b8c436902e6439a2ad25e2cedf83cdb0f0 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 1 Sep 2026 08:23:46 +0200
Subject: [PATCH 03/14] docs(sample): expose WPF floating demo

---
 samples/Sample.Wpf/MainWindow.xaml          |  2 +-
 samples/Sample.Wpf/Views/TabRegionView.xaml | 15 +++++++++++++--
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/samples/Sample.Wpf/MainWindow.xaml b/samples/Sample.Wpf/MainWindow.xaml
index 8917663..65b1ec4 100644
--- a/samples/Sample.Wpf/MainWindow.xaml
+++ b/samples/Sample.Wpf/MainWindow.xaml
@@ -66,7 +66,7 @@
                     Style="{StaticResource NavigationButton}"
                     Tag="ItemsRegionView" />
                 <Button
-                    Content="ToTabRegionView"
+                    Content="Floating demo (tabs)"
                     Style="{StaticResource NavigationButton}"
                     Tag="TabRegionView" />
                 <Button
diff --git a/samples/Sample.Wpf/Views/TabRegionView.xaml b/samples/Sample.Wpf/Views/TabRegionView.xaml
index f6c6eeb..ac4da21 100644
--- a/samples/Sample.Wpf/Views/TabRegionView.xaml
+++ b/samples/Sample.Wpf/Views/TabRegionView.xaml
@@ -44,12 +44,23 @@
                 Style="{StaticResource NavigationAndForget}"
                 Tag="LightView:New" />
             <Separator Margin="4" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                FontWeight="SemiBold"
+                Text="Floating region demo"
+                TextWrapping="Wrap" />
+            <TextBlock
+                Width="170"
+                Margin="4"
+                Text="1. Open LightView or HeavyView.&#x0a;2. Select the tab.&#x0a;3. Float the selected tab."
+                TextWrapping="Wrap" />
             <Button
                 Padding="8,4"
                 Click="FloatCurrent_Click"
-                Content="Float current tab" />
+                Content="Float selected tab" />
             <TextBlock
-                Width="150"
+                Width="170"
                 Margin="4"
                 Text="Close the floating window to restore the tab."
                 TextWrapping="Wrap" />

From e600ce35fe1d15214cffdaf2c2dac285c5ba97d3 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 1 Sep 2026 10:41:36 +0200
Subject: [PATCH 04/14] fix(floating): preserve rendered view state

---
 samples/Sample.Avalonia/App.axaml.cs          |  2 +-
 .../Views/ItemsRegionView.axaml               |  4 ++
 .../Views/ItemsRegionView.axaml.cs            | 35 ++++++++++++-
 .../Sample.Avalonia/Views/MainWindow.axaml    | 10 +++-
 .../Sample.Avalonia/Views/MainWindow.axaml.cs | 34 ++++++++++++-
 samples/Sample.Wpf/App.xaml.cs                |  2 +-
 samples/Sample.Wpf/MainWindow.xaml            |  4 ++
 samples/Sample.Wpf/MainWindow.xaml.cs         | 33 +++++++++++-
 samples/Sample.Wpf/Views/ItemsRegionView.xaml |  4 ++
 .../Sample.Wpf/Views/ItemsRegionView.xaml.cs  | 31 +++++++++++-
 .../InnerIndicatorHost.cs                     | 18 ++++++-
 .../ItemsRegionBase.cs                        | 39 ++++++++++++++-
 .../TabbedPageRegion.cs                       | 38 +++++++++++++-
 .../ViewPlacementService.cs                   | 37 ++++++++++++--
 src/AsyncNavigation.Wpf/InnerIndicatorHost.cs | 18 ++++++-
 src/AsyncNavigation.Wpf/ItemsRegion.cs        | 39 ++++++++++++++-
 .../IRegionPlacementContentHost.cs            | 12 +++++
 .../ViewPlacementServiceTests.cs              | 50 ++++++++++++++++---
 18 files changed, 385 insertions(+), 25 deletions(-)
 create mode 100644 src/AsyncNavigation/Abstractions/IRegionPlacementContentHost.cs

diff --git a/samples/Sample.Avalonia/App.axaml.cs b/samples/Sample.Avalonia/App.axaml.cs
index 9e030f9..1509e78 100644
--- a/samples/Sample.Avalonia/App.axaml.cs
+++ b/samples/Sample.Avalonia/App.axaml.cs
@@ -75,7 +75,7 @@ public override void OnFrameworkInitializationCompleted()
 
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
-            desktop.MainWindow = new MainWindow
+            desktop.MainWindow = new MainWindow(sp.GetRequiredService<AsyncNavigation.Floating.IViewPlacementService>())
             {
                 DataContext = sp.GetRequiredService<MainWindowViewModel>()
             };
diff --git a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
index d76789c..592927b 100644
--- a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
@@ -51,6 +51,10 @@
                 Classes="NavigationAndForget"
                 Content="ToLightView:Forget"
                 Tag="LightView" />
+            <Button
+                Padding="8,4"
+                Click="FloatSelectedItem_Click"
+                Content="Float selected ItemsRegion view" />
         </StackPanel>
         <ScrollViewer>
             <ItemsControl an:RegionManager.RegionName="ItemsRegion">
diff --git a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
index a4d5612..d4d6177 100644
--- a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
@@ -1,17 +1,48 @@
 using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
 using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using System;
+using System.Diagnostics;
 
 namespace Sample.Avalonia.Views;
 
 public partial class ItemsRegionView : UserControl, IView
 {
-    public ItemsRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ItemsRegionView() : this(null)
+    {
+    }
+
+    public ItemsRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
     protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
     {
         base.OnAttachedToVisualTree(e);
     }
-}
\ No newline at end of file
+
+    private async void FloatSelectedItem_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("ItemsRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating ItemsRegion item",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (InvalidOperationException ex)
+        {
+            Debug.WriteLine($"Cannot float ItemsRegion: {ex.Message}");
+        }
+    }
+}
diff --git a/samples/Sample.Avalonia/Views/MainWindow.axaml b/samples/Sample.Avalonia/Views/MainWindow.axaml
index 4342b23..e8e5485 100644
--- a/samples/Sample.Avalonia/Views/MainWindow.axaml
+++ b/samples/Sample.Avalonia/Views/MainWindow.axaml
@@ -14,5 +14,13 @@
     xmlns:views="clr-namespace:Sample.Avalonia.Views"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     x:DataType="vm:MainWindowViewModel">
-    <views:MainView />
+    <DockPanel LastChildFill="True">
+        <Border Padding="8" DockPanel.Dock="Top">
+            <StackPanel Orientation="Horizontal" Spacing="8">
+                <Button Click="FloatMainRegion_Click" Content="Float current MainRegion view" />
+                <TextBlock VerticalAlignment="Center" Text="The same UserControl instance moves to the window; close it to restore." />
+            </StackPanel>
+        </Border>
+        <views:MainView />
+    </DockPanel>
 </Window>
diff --git a/samples/Sample.Avalonia/Views/MainWindow.axaml.cs b/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
index a157c8b..9825d35 100644
--- a/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
+++ b/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
@@ -4,13 +4,43 @@
 using System.Threading;
 using System.Threading.Tasks;
 
+using AsyncNavigation.Floating;
+using Avalonia.Interactivity;
+
 namespace Sample.Avalonia.Views
 {
     public partial class MainWindow : Window
     {
-        public MainWindow()
+        private readonly IViewPlacementService? _placementService;
+
+        public MainWindow() : this(null)
+        {
+        }
+
+        public MainWindow(IViewPlacementService? placementService)
         {
+            _placementService = placementService;
             InitializeComponent();
         }
+
+        private async void FloatMainRegion_Click(object? sender, RoutedEventArgs e)
+        {
+            if (_placementService is null)
+                return;
+
+            try
+            {
+                await _placementService.FloatAsync("MainRegion", options: new FloatingWindowOptions
+                {
+                    Title = "AsyncNavigation floating MainRegion",
+                    Width = 900,
+                    Height = 600
+                });
+            }
+            catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+            {
+                Debug.WriteLine($"Cannot float MainRegion: {ex.Message}");
+            }
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/samples/Sample.Wpf/App.xaml.cs b/samples/Sample.Wpf/App.xaml.cs
index dc2eaef..cff0c75 100644
--- a/samples/Sample.Wpf/App.xaml.cs
+++ b/samples/Sample.Wpf/App.xaml.cs
@@ -59,7 +59,7 @@ protected override void OnStartup(StartupEventArgs e)
         base.OnStartup(e);
         var converter = sp.GetRequiredService<IconDescriptorConverter>();
         Application.Current.Resources[nameof(IconDescriptorConverter)] = converter;
-        var mainWindow = new MainWindow
+        var mainWindow = new MainWindow(sp.GetRequiredService<AsyncNavigation.Floating.IViewPlacementService>())
         {
             DataContext = sp.GetRequiredService<MainWindowViewModel>()
         };
diff --git a/samples/Sample.Wpf/MainWindow.xaml b/samples/Sample.Wpf/MainWindow.xaml
index 65b1ec4..47d46b6 100644
--- a/samples/Sample.Wpf/MainWindow.xaml
+++ b/samples/Sample.Wpf/MainWindow.xaml
@@ -33,6 +33,10 @@
                     <Button Style="{StaticResource GoBack}" />
                     <Button Style="{StaticResource GoForward}" />
                 </StackPanel>
+                <Button
+                    Padding="8,4"
+                    Click="FloatMainRegion_Click"
+                    Content="Float current MainRegion view" />
                 <Button
                     Content="ToLightView"
                     Style="{StaticResource NavigationButton}"
diff --git a/samples/Sample.Wpf/MainWindow.xaml.cs b/samples/Sample.Wpf/MainWindow.xaml.cs
index 9c36752..ad3850e 100644
--- a/samples/Sample.Wpf/MainWindow.xaml.cs
+++ b/samples/Sample.Wpf/MainWindow.xaml.cs
@@ -1,5 +1,7 @@
 using System.Windows;
 
+using AsyncNavigation.Floating;
+
 namespace Sample.Wpf;
 
 /// <summary>
@@ -7,8 +9,35 @@ namespace Sample.Wpf;
 /// </summary>
 public partial class MainWindow : Window
 {
-    public MainWindow()
+    private readonly IViewPlacementService? _placementService;
+
+    public MainWindow() : this(null)
+    {
+    }
+
+    public MainWindow(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
-}
\ No newline at end of file
+
+    private async void FloatMainRegion_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("MainRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating MainRegion",
+                Width = 900,
+                Height = 600
+            });
+        }
+        catch (InvalidOperationException ex)
+        {
+            MessageBox.Show(ex.Message, "Cannot float MainRegion", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
+}
diff --git a/samples/Sample.Wpf/Views/ItemsRegionView.xaml b/samples/Sample.Wpf/Views/ItemsRegionView.xaml
index 0b261aa..55ca185 100644
--- a/samples/Sample.Wpf/Views/ItemsRegionView.xaml
+++ b/samples/Sample.Wpf/Views/ItemsRegionView.xaml
@@ -50,6 +50,10 @@
                 Content="ToLightView:Forget"
                 Style="{StaticResource NavigationAndForget}"
                 Tag="LightView" />
+            <Button
+                Padding="8,4"
+                Click="FloatSelectedItem_Click"
+                Content="Float selected ItemsRegion view" />
         </StackPanel>
         <ScrollViewer>
             <ItemsControl an:RegionManager.RegionName="ItemsRegion">
diff --git a/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs b/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
index 5fad3cf..2f08ac0 100644
--- a/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
@@ -1,4 +1,6 @@
 using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
+using System.Windows;
 using System.Windows.Controls;
 
 namespace Sample.Wpf.Views;
@@ -8,8 +10,35 @@ namespace Sample.Wpf.Views;
 /// </summary>
 public partial class ItemsRegionView : UserControl,IView
 {
-    public ItemsRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ItemsRegionView() : this(null)
+    {
+    }
+
+    public ItemsRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
+
+    private async void FloatSelectedItem_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("ItemsRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating ItemsRegion item",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (InvalidOperationException ex)
+        {
+            MessageBox.Show(ex.Message, "Cannot float ItemsRegion", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
 }
diff --git a/src/AsyncNavigation.Avalonia/InnerIndicatorHost.cs b/src/AsyncNavigation.Avalonia/InnerIndicatorHost.cs
index 1276783..ec4b23a 100644
--- a/src/AsyncNavigation.Avalonia/InnerIndicatorHost.cs
+++ b/src/AsyncNavigation.Avalonia/InnerIndicatorHost.cs
@@ -4,7 +4,7 @@
 
 namespace AsyncNavigation.Avalonia;
 
-internal sealed class InnerIndicatorHost : IInnerRegionIndicatorHost, IInnerIndicatorProvider
+internal sealed class InnerIndicatorHost : IInnerRegionIndicatorHost, IInnerIndicatorProvider, IRegionPlacementContentHost
 {
     private readonly ContentControl _host;
     private readonly IInnerIndicatorProvider _innerIndicatorProvider;
@@ -24,6 +24,22 @@ public InnerIndicatorHost(IServiceProvider serviceProvider)
 
     public object Host => _host;
 
+    object IRegionPlacementContentHost.DetachContent()
+    {
+        var content = _host.Content
+            ?? throw new InvalidOperationException("The region indicator host does not contain a rendered view.");
+        _host.Content = null;
+        return content;
+    }
+
+    void IRegionPlacementContentHost.AttachContent(object content)
+    {
+        ArgumentNullException.ThrowIfNull(content);
+        if (_host.Content is not null)
+            throw new InvalidOperationException("The region indicator host already contains content.");
+        _host.Content = content;
+    }
+
     Task IRegionIndicator.OnCancelledAsync(NavigationContext context)
     {
         _host.Content = null;
diff --git a/src/AsyncNavigation.Avalonia/ItemsRegionBase.cs b/src/AsyncNavigation.Avalonia/ItemsRegionBase.cs
index 1d0327d..cb5146d 100644
--- a/src/AsyncNavigation.Avalonia/ItemsRegionBase.cs
+++ b/src/AsyncNavigation.Avalonia/ItemsRegionBase.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using Avalonia.Controls;
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
@@ -7,7 +8,7 @@
 namespace AsyncNavigation.Avalonia;
 
 public abstract class ItemsRegionBase<TRegion, TItemsControl>
-    : RegionBase<TRegion, TItemsControl>
+    : RegionBase<TRegion, TItemsControl>, IRegionPlacementParticipant
     where TRegion : ItemsRegionBase<TRegion, TItemsControl>
     where TItemsControl : ItemsControl
 {
@@ -71,4 +72,40 @@ public override void Dispose()
         base.Dispose();
         _context.Clear();
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected ?? _context.Items.LastOrDefault();
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context),
+            ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
 }
diff --git a/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs b/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
index 8a7b335..e057bcf 100644
--- a/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
+++ b/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
@@ -7,7 +7,7 @@
 
 namespace AsyncNavigation.Avalonia;
 
-public class TabbedPageRegion : RegionBase<TabbedPageRegion, TabbedPage>
+public class TabbedPageRegion : RegionBase<TabbedPageRegion, TabbedPage>, IRegionPlacementParticipant
 {
     private readonly IIconResolver<Control> _iconResolver;
     public TabbedPageRegion(string name,
@@ -80,4 +80,40 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         return Task.CompletedTask;
     }
 
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected;
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context),
+            ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
+
 }
diff --git a/src/AsyncNavigation.Floating/ViewPlacementService.cs b/src/AsyncNavigation.Floating/ViewPlacementService.cs
index af6e0af..c6e5116 100644
--- a/src/AsyncNavigation.Floating/ViewPlacementService.cs
+++ b/src/AsyncNavigation.Floating/ViewPlacementService.cs
@@ -52,7 +52,8 @@ public async Task<IFloatingViewSession> FloatAsync(
 
         options = (options ?? new FloatingWindowOptions()).WithDefaultTitle(item.Context.ViewName);
         var host = _windowFactory.Create(options);
-        var session = new FloatingViewSession(this, Guid.NewGuid(), regionName, item, host);
+        var contentOwner = item.Context.IndicatorHost.Value as IRegionPlacementContentHost;
+        var session = new FloatingViewSession(this, Guid.NewGuid(), regionName, item, contentOwner, host);
 
         if (!_sessionsByNavigationId.TryAdd(item.Context.NavigationId, session.Id))
         {
@@ -74,11 +75,15 @@ public async Task<IFloatingViewSession> FloatAsync(
 
         host.RestoreRequested += session.OnRestoreRequested;
         var detached = false;
+        var contentDetached = false;
         try
         {
+            var content = contentOwner?.DetachContent() ?? GetContentHost(item);
+            contentDetached = contentOwner is not null;
+            session.SetContent(content);
             participant.Detach(item);
             detached = true;
-            await host.SetContentAsync(GetContentHost(item), cancellationToken);
+            await host.SetContentAsync(content, cancellationToken);
             await host.ShowAsync(cancellationToken);
             return session;
         }
@@ -92,6 +97,8 @@ public async Task<IFloatingViewSession> FloatAsync(
                 await host.SetContentAsync(null, CancellationToken.None);
                 if (detached)
                     participant.Attach(item);
+                if (contentDetached)
+                    contentOwner!.AttachContent(session.Content);
             }
             finally
             {
@@ -127,10 +134,22 @@ internal async Task RestoreCoreAsync(FloatingViewSession session, CancellationTo
         try
         {
             participant.Attach(session.Item);
+            session.ContentOwner?.AttachContent(session.Content);
         }
         catch
         {
-            await session.Host.SetContentAsync(GetContentHost(session.Item), CancellationToken.None);
+            if (session.ContentOwner is not null)
+            {
+                try
+                {
+                    participant.Detach(session.Item);
+                }
+                catch (Exception ex)
+                {
+                    Debug.WriteLine($"Could not roll back region attachment for '{session.NavigationId}': {ex}");
+                }
+            }
+            await session.Host.SetContentAsync(session.Content, CancellationToken.None);
             throw;
         }
 
@@ -166,12 +185,13 @@ internal sealed class FloatingViewSession : IFloatingViewSession
         private readonly SemaphoreSlim _gate = new(1, 1);
 
         internal FloatingViewSession(ViewPlacementService owner, Guid id, string originRegionName,
-            RegionPlacementItem item, IFloatingWindowHost host)
+            RegionPlacementItem item, IRegionPlacementContentHost? contentOwner, IFloatingWindowHost host)
         {
             _owner = owner;
             Id = id;
             OriginRegionName = originRegionName;
             Item = item;
+            ContentOwner = contentOwner;
             Host = host;
         }
 
@@ -180,8 +200,17 @@ internal FloatingViewSession(ViewPlacementService owner, Guid id, string originR
         public string OriginRegionName { get; }
         public ViewPlacementState State { get; private set; } = ViewPlacementState.Floating;
         internal RegionPlacementItem Item { get; }
+        internal object Content { get; private set; } = null!;
+        internal IRegionPlacementContentHost? ContentOwner { get; }
         internal IFloatingWindowHost Host { get; }
 
+        internal void SetContent(object content)
+        {
+            if (Content is not null)
+                throw new InvalidOperationException("Floating session content has already been assigned.");
+            Content = content;
+        }
+
         public async Task RestoreAsync(CancellationToken cancellationToken = default)
         {
             await _gate.WaitAsync(cancellationToken);
diff --git a/src/AsyncNavigation.Wpf/InnerIndicatorHost.cs b/src/AsyncNavigation.Wpf/InnerIndicatorHost.cs
index 4a5af23..c53cd98 100644
--- a/src/AsyncNavigation.Wpf/InnerIndicatorHost.cs
+++ b/src/AsyncNavigation.Wpf/InnerIndicatorHost.cs
@@ -5,7 +5,7 @@
 
 namespace AsyncNavigation.Wpf;
 
-internal sealed class InnerIndicatorHost : IInnerRegionIndicatorHost, IInnerIndicatorProvider
+internal sealed class InnerIndicatorHost : IInnerRegionIndicatorHost, IInnerIndicatorProvider, IRegionPlacementContentHost
 {
     private readonly ContentControl _host;
     private readonly IInnerIndicatorProvider _innerIndicatorProvider;
@@ -25,6 +25,22 @@ public InnerIndicatorHost(IServiceProvider serviceProvider)
 
     public object Host => _host;
 
+    object IRegionPlacementContentHost.DetachContent()
+    {
+        var content = _host.Content
+            ?? throw new InvalidOperationException("The region indicator host does not contain a rendered view.");
+        _host.Content = null;
+        return content;
+    }
+
+    void IRegionPlacementContentHost.AttachContent(object content)
+    {
+        ArgumentNullException.ThrowIfNull(content);
+        if (_host.Content is not null)
+            throw new InvalidOperationException("The region indicator host already contains content.");
+        _host.Content = content;
+    }
+
     public UIElement GetErrorIndicator(NavigationContext navigationContext)
     {
         return new Grid();
diff --git a/src/AsyncNavigation.Wpf/ItemsRegion.cs b/src/AsyncNavigation.Wpf/ItemsRegion.cs
index 97343a0..693f8af 100644
--- a/src/AsyncNavigation.Wpf/ItemsRegion.cs
+++ b/src/AsyncNavigation.Wpf/ItemsRegion.cs
@@ -1,4 +1,5 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Abstractions;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
@@ -6,7 +7,7 @@
 
 namespace AsyncNavigation.Wpf;
 
-public class ItemsRegion : RegionBase<ItemsRegion, ItemsControl>
+public class ItemsRegion : RegionBase<ItemsRegion, ItemsControl>, IRegionPlacementParticipant
 {
     public ItemsRegion(string name,
         ItemsControl itemsControl, 
@@ -70,4 +71,40 @@ public override Task ProcessDeactivateAsync(NavigationContext? navigationContext
         _ = _context.Items.Remove(target);
         return Task.CompletedTask;
     }
+
+    public RegionPlacementItem Capture(Guid? navigationId = null)
+    {
+        var context = navigationId.HasValue
+            ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
+            : _context.Selected ?? _context.Items.LastOrDefault();
+        if (context is null)
+            throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
+
+        return new RegionPlacementItem(context, _context.Items.IndexOf(context),
+            ReferenceEquals(_context.Selected, context));
+    }
+
+    public void Detach(RegionPlacementItem item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        var index = _context.Items.IndexOf(item.Context);
+        if (index < 0)
+            throw new InvalidOperationException($"The navigation item is not attached to region '{Name}'.");
+
+        var wasSelected = ReferenceEquals(_context.Selected, item.Context);
+        _context.Items.RemoveAt(index);
+        if (wasSelected)
+            _context.Selected = _context.Items.Count == 0 ? null : _context.Items[Math.Min(index, _context.Items.Count - 1)];
+    }
+
+    public void Attach(RegionPlacementItem item, bool activate = true)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        if (_context.Items.Contains(item.Context))
+            throw new InvalidOperationException($"The navigation item is already attached to region '{Name}'.");
+
+        _context.Items.Insert(Math.Clamp(item.Index, 0, _context.Items.Count), item.Context);
+        if (activate || item.WasSelected)
+            _context.Selected = item.Context;
+    }
 }
diff --git a/src/AsyncNavigation/Abstractions/IRegionPlacementContentHost.cs b/src/AsyncNavigation/Abstractions/IRegionPlacementContentHost.cs
new file mode 100644
index 0000000..bd65043
--- /dev/null
+++ b/src/AsyncNavigation/Abstractions/IRegionPlacementContentHost.cs
@@ -0,0 +1,12 @@
+namespace AsyncNavigation.Abstractions;
+
+/// <summary>
+/// Allows a region indicator host to temporarily lend its rendered view to
+/// another visual host without resolving or creating the view again.
+/// </summary>
+public interface IRegionPlacementContentHost
+{
+    object DetachContent();
+
+    void AttachContent(object content);
+}
diff --git a/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs b/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
index 2ab409c..d244b94 100644
--- a/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
+++ b/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
@@ -16,7 +16,8 @@ public async Task FloatAndRestore_MovesTheSameRenderedHostWithoutNavigating()
         var session = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
 
         Assert.Equal(1, fixture.Region.DetachCount);
-        Assert.Same(fixture.RenderedHost, fixture.Window.Content);
+        Assert.Same(fixture.RenderedView, fixture.Window.Content);
+        Assert.Null(fixture.Indicator.Content);
         Assert.True(fixture.Window.WasShown);
         Assert.Single(fixture.Service.FloatingViews);
 
@@ -24,6 +25,8 @@ public async Task FloatAndRestore_MovesTheSameRenderedHostWithoutNavigating()
 
         Assert.Equal(1, fixture.Region.AttachCount);
         Assert.Null(fixture.Window.Content);
+        Assert.Same(fixture.RenderedView, fixture.Indicator.Content);
+        Assert.Equal("selected-value", fixture.RenderedView.Selection);
         Assert.True(fixture.Window.WasClosed);
         Assert.Empty(fixture.Service.FloatingViews);
         Assert.Equal(ViewPlacementState.Restored, session.State);
@@ -54,6 +57,7 @@ await Assert.ThrowsAsync<InvalidOperationException>(() =>
 
         Assert.Equal(1, fixture.Region.AttachCount);
         Assert.Null(fixture.Window.Content);
+        Assert.Same(fixture.RenderedView, fixture.Indicator.Content);
         Assert.Empty(fixture.Service.FloatingViews);
         Assert.True(fixture.Window.WasDisposed);
     }
@@ -62,11 +66,10 @@ private sealed class Fixture
     {
         public Fixture()
         {
-            RenderedHost = new object();
+            RenderedView = new StatefulRenderedView { Selection = "selected-value" };
             Context = new NavigationContext { RegionName = "main", ViewName = "editor" };
-            var indicator = new Mock<IInnerRegionIndicatorHost>();
-            indicator.SetupGet(x => x.Host).Returns(RenderedHost);
-            Context.IndicatorHost.Value = indicator.Object;
+            Indicator = new FakeIndicatorHost(RenderedView);
+            Context.IndicatorHost.Value = Indicator;
             Item = new RegionPlacementItem(Context, 2, true);
 
             Region = new FakeRegion(Item);
@@ -87,7 +90,8 @@ public Fixture()
             Service = provider.GetRequiredService<IViewPlacementService>();
         }
 
-        public object RenderedHost { get; }
+        public StatefulRenderedView RenderedView { get; }
+        public FakeIndicatorHost Indicator { get; }
         public NavigationContext Context { get; }
         public RegionPlacementItem Item { get; }
         public FakeRegion Region { get; }
@@ -95,6 +99,40 @@ public Fixture()
         public IViewPlacementService Service { get; }
     }
 
+    private sealed class StatefulRenderedView
+    {
+        public string? Selection { get; set; }
+    }
+
+    private sealed class FakeIndicatorHost(object content)
+        : IInnerRegionIndicatorHost, IRegionPlacementContentHost
+    {
+        private readonly object _host = new();
+
+        public object Host => _host;
+        public object? Content { get; private set; } = content;
+
+        public object DetachContent()
+        {
+            var current = Content ?? throw new InvalidOperationException();
+            Content = null;
+            return current;
+        }
+
+        public void AttachContent(object content)
+        {
+            if (Content is not null)
+                throw new InvalidOperationException();
+            Content = content;
+        }
+
+        public Task ShowContentAsync(NavigationContext context) => Task.CompletedTask;
+        public Task ShowLoadingAsync(NavigationContext context) => Task.CompletedTask;
+        public Task ShowErrorAsync(NavigationContext context, Exception? innerException) => Task.CompletedTask;
+        public Task OnLoadedAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnCancelledAsync(NavigationContext context) => Task.CompletedTask;
+    }
+
     private sealed class FakeRegion : IRegion, IRegionPlacementParticipant
     {
         private readonly RegionPlacementItem _item;

From 80952a1e7165b43944336e00bb6d5decef5905e4 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 1 Sep 2026 10:53:21 +0200
Subject: [PATCH 05/14] test(floating): define visual state contract

---
 samples/Sample.Avalonia/Views/HeavyView.axaml | 18 ++++-
 samples/Sample.Common/HeavyViewModel.cs       | 24 +++++-
 samples/Sample.Wpf/Views/HeavyView.xaml       | 19 ++++-
 .../AsyncNavigation.E2E.Tests.csproj          | 13 ++--
 .../FloatingVisualStateTests.cs               | 76 +++++++++++++++++++
 5 files changed, 135 insertions(+), 15 deletions(-)
 create mode 100644 tests/AsyncNavigation.E2E.Tests/FloatingVisualStateTests.cs

diff --git a/samples/Sample.Avalonia/Views/HeavyView.axaml b/samples/Sample.Avalonia/Views/HeavyView.axaml
index a154016..acab923 100644
--- a/samples/Sample.Avalonia/Views/HeavyView.axaml
+++ b/samples/Sample.Avalonia/Views/HeavyView.axaml
@@ -30,15 +30,25 @@
                 <Button Classes="CloseDialog" />
                 <ItemsControl ItemsSource="{Binding HeavyItems}">
                     <ItemsControl.ItemTemplate>
-                        <DataTemplate>
+                        <DataTemplate x:DataType="vm:HeavyItemViewModel">
                             <Border
                                 Margin="2"
                                 BorderBrush="Black"
                                 BorderThickness="1">
                                 <DockPanel LastChildFill="True">
-                                    <ComboBox Width="50" />
-                                    <Expander Width="50" />
-                                    <DatePicker Width="50" />
+                                    <ComboBox
+                                        Width="100"
+                                        ItemsSource="{Binding Options}"
+                                        SelectedItem="{Binding SelectedOption}" />
+                                    <Expander
+                                        Width="100"
+                                        Header="Details"
+                                        IsExpanded="{Binding IsExpanded}">
+                                        <TextBlock Text="{Binding Value}" />
+                                    </Expander>
+                                    <DatePicker
+                                        Width="140"
+                                        SelectedDate="{Binding AvaloniaSelectedDate}" />
                                 </DockPanel>
                             </Border>
                         </DataTemplate>
diff --git a/samples/Sample.Common/HeavyViewModel.cs b/samples/Sample.Common/HeavyViewModel.cs
index 8c1aa27..c7e4956 100644
--- a/samples/Sample.Common/HeavyViewModel.cs
+++ b/samples/Sample.Common/HeavyViewModel.cs
@@ -2,13 +2,14 @@
 using AsyncNavigation.Abstractions;
 using AsyncNavigation.Core;
 using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.ComponentModel;
 using System.Collections.ObjectModel;
 
 namespace Sample.Common;
 
 public partial class HeavyViewModel : InstanceCounterViewModel<HeavyViewModel>, IDialogAware, INavigationMetadata
 {
-    public ObservableCollection<byte> HeavyItems
+    public ObservableCollection<HeavyItemViewModel> HeavyItems
     {
         get;
     } = [];
@@ -60,7 +61,26 @@ private void AddItems(int count)
         var rnd = new Random();
         for (int i = 0; i < count; i++)
         {
-            HeavyItems.Add((byte)rnd.Next(0, 256));
+            HeavyItems.Add(new HeavyItemViewModel((byte)rnd.Next(0, 256)));
         }
     }
 }
+
+public partial class HeavyItemViewModel(byte value) : ObservableObject
+{
+    public byte Value { get; } = value;
+
+    public IReadOnlyList<string> Options { get; } = ["Alpha", "Beta", "Gamma"];
+
+    [ObservableProperty]
+    private string? _selectedOption;
+
+    [ObservableProperty]
+    private DateTimeOffset? _avaloniaSelectedDate;
+
+    [ObservableProperty]
+    private DateTime? _wpfSelectedDate;
+
+    [ObservableProperty]
+    private bool _isExpanded;
+}
diff --git a/samples/Sample.Wpf/Views/HeavyView.xaml b/samples/Sample.Wpf/Views/HeavyView.xaml
index c62b52c..b963cc9 100644
--- a/samples/Sample.Wpf/Views/HeavyView.xaml
+++ b/samples/Sample.Wpf/Views/HeavyView.xaml
@@ -5,6 +5,7 @@
     xmlns:an="https://github.com/NeverMorewd/AsyncNavigation"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:local="clr-namespace:Sample.Wpf.Views"
+    xmlns:vm="clr-namespace:Sample.Common;assembly=Sample.Common"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     d:DesignHeight="450"
     d:DesignWidth="800"
@@ -29,12 +30,22 @@
                 <Button Style="{StaticResource CloseDialog}" />
                 <ItemsControl ItemsSource="{Binding HeavyItems}">
                     <ItemsControl.ItemTemplate>
-                        <DataTemplate>
+                        <DataTemplate DataType="{x:Type vm:HeavyItemViewModel}">
                             <Border BorderBrush="Black" BorderThickness="1">
                                 <DockPanel LastChildFill="True">
-                                    <ComboBox Width="50" />
-                                    <Expander Width="50" />
-                                    <DatePicker Width="50" />
+                                    <ComboBox
+                                        Width="100"
+                                        ItemsSource="{Binding Options}"
+                                        SelectedItem="{Binding SelectedOption}" />
+                                    <Expander
+                                        Width="100"
+                                        Header="Details"
+                                        IsExpanded="{Binding IsExpanded}">
+                                        <TextBlock Text="{Binding Value}" />
+                                    </Expander>
+                                    <DatePicker
+                                        Width="140"
+                                        SelectedDate="{Binding WpfSelectedDate}" />
                                 </DockPanel>
                             </Border>
                         </DataTemplate>
diff --git a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
index b890028..e8186fe 100644
--- a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
+++ b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
@@ -1,20 +1,23 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0-windows</TargetFramework>
+    <TargetFramework>net10.0-windows</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <OutputType>Exe</OutputType>
 
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Avalonia.Headless.XUnit" Version="11.3.6" />
+    <PackageReference Include="Avalonia.Headless.XUnit" Version="12.0.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="xunit" Version="2.5.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
+    <PackageReference Include="xunit.v3" Version="3.2.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingVisualStateTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingVisualStateTests.cs
new file mode 100644
index 0000000..9361966
--- /dev/null
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingVisualStateTests.cs
@@ -0,0 +1,76 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Templates;
+using Avalonia.Data;
+using Avalonia.Headless.XUnit;
+using Avalonia.LogicalTree;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+
+namespace AsyncNavigation.E2E.Tests;
+
+public sealed class FloatingVisualStateTests
+{
+    [AvaloniaFact]
+    public void MovingSameViewBetweenWindows_PreservesTemplatedDatePickerState()
+    {
+        var state = new DatePickerState();
+        var presenter = new ContentPresenter
+        {
+            Content = "item",
+            ContentTemplate = new FuncDataTemplate<string>((_, _) =>
+            {
+                var picker = new DatePicker();
+                picker.Bind(DatePicker.SelectedDateProperty, new Binding(nameof(DatePickerState.SelectedDate))
+                {
+                    Source = state,
+                    Mode = BindingMode.TwoWay
+                });
+                return picker;
+            })
+        };
+        var view = new UserControl { Content = presenter };
+        var indicatorHost = new ContentControl { Content = view };
+        var origin = new Window { Width = 800, Height = 600, Content = indicatorHost };
+        var floating = new Window { Width = 800, Height = 600 };
+
+        try
+        {
+            origin.Show();
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+            view.Measure(new Size(800, 600));
+            view.Arrange(new Rect(0, 0, 800, 600));
+            Dispatcher.UIThread.RunJobs();
+
+            var originalPicker = view.GetVisualDescendants().OfType<DatePicker>().Single();
+            var selectedDate = new DateTimeOffset(2026, 9, 1, 0, 0, 0, TimeSpan.Zero);
+            originalPicker.SelectedDate = selectedDate;
+            Assert.Equal(selectedDate, state.SelectedDate);
+
+            indicatorHost.Content = null;
+            origin.Content = null;
+            floating.Content = view;
+            floating.Show();
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+            view.Measure(new Size(800, 600));
+            view.Arrange(new Rect(0, 0, 800, 600));
+            Dispatcher.UIThread.RunJobs();
+
+            var floatingPicker = view.GetVisualDescendants().OfType<DatePicker>().Single();
+            Assert.NotSame(originalPicker, floatingPicker);
+            Assert.Equal(selectedDate, floatingPicker.SelectedDate);
+        }
+        finally
+        {
+            floating.Content = null;
+            floating.Close();
+            origin.Close();
+        }
+    }
+
+    private sealed class DatePickerState
+    {
+        public DateTimeOffset? SelectedDate { get; set; }
+    }
+}

From a8ed62fe5db40b242e6d99e424c7052cbf7c64a7 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 1 Sep 2026 12:37:48 +0200
Subject: [PATCH 06/14] fix(floating): align window restore behavior and
 samples

---
 .../Views/ChildContentRegionView.axaml        |   4 +
 .../Views/ChildContentRegionView.axaml.cs     |  37 +++-
 .../Views/ItemsRegionView.axaml               |   2 +-
 .../Views/ItemsRegionView.axaml.cs            |   8 +-
 .../Views/ListBoxRegionView.axaml             |   4 +
 .../Views/ListBoxRegionView.axaml.cs          |  37 +++-
 samples/Sample.Avalonia/Views/MainView.axaml  |   2 +-
 .../Sample.Avalonia/Views/MainWindow.axaml    |   2 +-
 .../Sample.Avalonia/Views/TabRegionView.axaml |   2 +-
 samples/Sample.Wpf/MainWindow.xaml            |   4 +-
 samples/Sample.Wpf/MainWindow.xaml.cs         |   2 +-
 .../Views/ChildContentRegionView.xaml         |   4 +
 .../Views/ChildContentRegionView.xaml.cs      |  36 +++-
 samples/Sample.Wpf/Views/ItemsRegionView.xaml |   2 +-
 .../Sample.Wpf/Views/ItemsRegionView.xaml.cs  |   2 +-
 .../Sample.Wpf/Views/ListBoxRegionView.xaml   |   4 +
 .../Views/ListBoxRegionView.xaml.cs           |  52 +++--
 samples/Sample.Wpf/Views/TabRegionView.xaml   |   2 +-
 .../Sample.Wpf/Views/TabRegionView.xaml.cs    |   2 +-
 .../AssemblyInfo.cs                           |   3 +
 .../AvaloniaFloatingWindowHost.cs             |   5 +-
 .../AssemblyInfo.cs                           |   3 +
 .../WpfFloatingWindowHost.cs                  |   5 +-
 .../AsyncNavigation.E2E.Tests.csproj          |   1 +
 .../FloatingWindowLifecycleTests.cs           |  42 ++++
 .../AsyncNavigation.Wpf.E2E.Tests.csproj      |  27 +++
 .../FloatingVisualStateTests.cs               | 202 ++++++++++++++++++
 .../FloatingWindowLifecycleTests.cs           |  78 +++++++
 tests/AsyncNavigation.Wpf.E2E.Tests/README.md |  22 ++
 29 files changed, 545 insertions(+), 51 deletions(-)
 create mode 100644 src/AsyncNavigation.Avalonia.Floating/AssemblyInfo.cs
 create mode 100644 src/AsyncNavigation.Wpf.Floating/AssemblyInfo.cs
 create mode 100644 tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs
 create mode 100644 tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
 create mode 100644 tests/AsyncNavigation.Wpf.E2E.Tests/FloatingVisualStateTests.cs
 create mode 100644 tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs
 create mode 100644 tests/AsyncNavigation.Wpf.E2E.Tests/README.md

diff --git a/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml b/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml
index 1208232..0267aaa 100644
--- a/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml
@@ -39,6 +39,10 @@
                 Classes="Navigation"
                 Content="ToHeavyView"
                 Tag="HeavyView" />
+            <Button
+                Padding="8,4"
+                Click="FloatChildRegion_Click"
+                Content="Floating: current ChildContentRegion view" />
         </StackPanel>
         <ContentControl an:RegionManager.RegionName="ChildContentRegion" />
     </DockPanel>
diff --git a/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml.cs b/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml.cs
index 8d4eef0..b4b9249 100644
--- a/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/ChildContentRegionView.axaml.cs
@@ -1,12 +1,43 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using System;
+using System.Diagnostics;
 
 namespace Sample.Avalonia.Views;
 
 public partial class ChildContentRegionView : UserControl, IView
 {
-    public ChildContentRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ChildContentRegionView() : this(null)
+    {
+    }
+
+    public ChildContentRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
-}
\ No newline at end of file
+
+    private async void FloatChildRegion_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("ChildContentRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating ChildContentRegion",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float ChildContentRegion: {ex.Message}");
+        }
+    }
+}
diff --git a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
index 592927b..43cb20d 100644
--- a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml
@@ -54,7 +54,7 @@
             <Button
                 Padding="8,4"
                 Click="FloatSelectedItem_Click"
-                Content="Float selected ItemsRegion view" />
+                Content="Floating: selected ItemsRegion view" />
         </StackPanel>
         <ScrollViewer>
             <ItemsControl an:RegionManager.RegionName="ItemsRegion">
diff --git a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
index d4d6177..295fba6 100644
--- a/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/ItemsRegionView.axaml.cs
@@ -1,6 +1,5 @@
 using AsyncNavigation.Abstractions;
 using AsyncNavigation.Floating;
-using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using System;
@@ -21,11 +20,6 @@ public ItemsRegionView(IViewPlacementService? placementService)
         _placementService = placementService;
         InitializeComponent();
     }
-    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
-    {
-        base.OnAttachedToVisualTree(e);
-    }
-
     private async void FloatSelectedItem_Click(object? sender, RoutedEventArgs e)
     {
         if (_placementService is null)
@@ -40,7 +34,7 @@ private async void FloatSelectedItem_Click(object? sender, RoutedEventArgs e)
                 Height = 480
             });
         }
-        catch (InvalidOperationException ex)
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
         {
             Debug.WriteLine($"Cannot float ItemsRegion: {ex.Message}");
         }
diff --git a/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml b/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml
index c7406a2..b722b51 100644
--- a/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml
@@ -24,6 +24,10 @@
                 Classes="Navigation"
                 Content="ToHeavyView"
                 Tag="HeavyView" />
+            <Button
+                Padding="8,4"
+                Click="FloatSelectedItem_Click"
+                Content="Floating: selected CustomListBoxRegion view" />
         </StackPanel>
         <ListBox an:RegionManager.RegionName="CustomListBoxRegion" />
     </DockPanel>
diff --git a/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml.cs b/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml.cs
index e59925e..a4defcd 100644
--- a/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/ListBoxRegionView.axaml.cs
@@ -1,12 +1,43 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using System;
+using System.Diagnostics;
 
 namespace Sample.Avalonia.Views;
 
 public partial class ListBoxRegionView : UserControl, IView
 {
-    public ListBoxRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ListBoxRegionView() : this(null)
+    {
+    }
+
+    public ListBoxRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
-}
\ No newline at end of file
+
+    private async void FloatSelectedItem_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("CustomListBoxRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating CustomListBoxRegion item",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float CustomListBoxRegion: {ex.Message}");
+        }
+    }
+}
diff --git a/samples/Sample.Avalonia/Views/MainView.axaml b/samples/Sample.Avalonia/Views/MainView.axaml
index 9bfc45f..ae2896b 100644
--- a/samples/Sample.Avalonia/Views/MainView.axaml
+++ b/samples/Sample.Avalonia/Views/MainView.axaml
@@ -77,7 +77,7 @@
                             Tag="ItemsRegionView" />
                         <Button
                             Classes="Navigation"
-                            Content="Floating demo (tabs)"
+                            Content="Floating demo: TabRegion"
                             Tag="TabRegionView" />
                         <Button
                             Classes="Navigation"
diff --git a/samples/Sample.Avalonia/Views/MainWindow.axaml b/samples/Sample.Avalonia/Views/MainWindow.axaml
index e8e5485..def88af 100644
--- a/samples/Sample.Avalonia/Views/MainWindow.axaml
+++ b/samples/Sample.Avalonia/Views/MainWindow.axaml
@@ -17,7 +17,7 @@
     <DockPanel LastChildFill="True">
         <Border Padding="8" DockPanel.Dock="Top">
             <StackPanel Orientation="Horizontal" Spacing="8">
-                <Button Click="FloatMainRegion_Click" Content="Float current MainRegion view" />
+                <Button Click="FloatMainRegion_Click" Content="Floating: current MainRegion view" />
                 <TextBlock VerticalAlignment="Center" Text="The same UserControl instance moves to the window; close it to restore." />
             </StackPanel>
         </Border>
diff --git a/samples/Sample.Avalonia/Views/TabRegionView.axaml b/samples/Sample.Avalonia/Views/TabRegionView.axaml
index 284f902..eb1f5bb 100644
--- a/samples/Sample.Avalonia/Views/TabRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/TabRegionView.axaml
@@ -60,7 +60,7 @@
             <Button
                 Padding="8,4"
                 Click="FloatCurrent_Click"
-                Content="Float selected tab" />
+                Content="Floating: selected TabRegion view" />
             <TextBlock
                 Width="170"
                 Margin="4"
diff --git a/samples/Sample.Wpf/MainWindow.xaml b/samples/Sample.Wpf/MainWindow.xaml
index 47d46b6..8a53434 100644
--- a/samples/Sample.Wpf/MainWindow.xaml
+++ b/samples/Sample.Wpf/MainWindow.xaml
@@ -36,7 +36,7 @@
                 <Button
                     Padding="8,4"
                     Click="FloatMainRegion_Click"
-                    Content="Float current MainRegion view" />
+                    Content="Floating: current MainRegion view" />
                 <Button
                     Content="ToLightView"
                     Style="{StaticResource NavigationButton}"
@@ -70,7 +70,7 @@
                     Style="{StaticResource NavigationButton}"
                     Tag="ItemsRegionView" />
                 <Button
-                    Content="Floating demo (tabs)"
+                    Content="Floating demo: TabRegion"
                     Style="{StaticResource NavigationButton}"
                     Tag="TabRegionView" />
                 <Button
diff --git a/samples/Sample.Wpf/MainWindow.xaml.cs b/samples/Sample.Wpf/MainWindow.xaml.cs
index ad3850e..7ae99a0 100644
--- a/samples/Sample.Wpf/MainWindow.xaml.cs
+++ b/samples/Sample.Wpf/MainWindow.xaml.cs
@@ -35,7 +35,7 @@ private async void FloatMainRegion_Click(object sender, RoutedEventArgs e)
                 Height = 600
             });
         }
-        catch (InvalidOperationException ex)
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
         {
             MessageBox.Show(ex.Message, "Cannot float MainRegion", MessageBoxButton.OK, MessageBoxImage.Information);
         }
diff --git a/samples/Sample.Wpf/Views/ChildContentRegionView.xaml b/samples/Sample.Wpf/Views/ChildContentRegionView.xaml
index f46dc84..33ebebe 100644
--- a/samples/Sample.Wpf/Views/ChildContentRegionView.xaml
+++ b/samples/Sample.Wpf/Views/ChildContentRegionView.xaml
@@ -38,6 +38,10 @@
                 Content="ToHeavyView"
                 Style="{StaticResource NavigationButton}"
                 Tag="HeavyView" />
+            <Button
+                Padding="8,4"
+                Click="FloatChildRegion_Click"
+                Content="Floating: current ChildContentRegion view" />
         </StackPanel>
         <ContentControl an:RegionManager.RegionName="ChildContentRegion" />
     </DockPanel>
diff --git a/samples/Sample.Wpf/Views/ChildContentRegionView.xaml.cs b/samples/Sample.Wpf/Views/ChildContentRegionView.xaml.cs
index 84ab673..9e832f7 100644
--- a/samples/Sample.Wpf/Views/ChildContentRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/ChildContentRegionView.xaml.cs
@@ -1,15 +1,41 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
+using System.Windows;
 using System.Windows.Controls;
 
 namespace Sample.Wpf.Views;
 
-/// <summary>
-/// Interaction logic for ChildContentRegionView.xaml
-/// </summary>
 public partial class ChildContentRegionView : UserControl, IView
 {
-    public ChildContentRegionView()
+    private readonly IViewPlacementService? _placementService;
+
+    public ChildContentRegionView() : this(null)
+    {
+    }
+
+    public ChildContentRegionView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
+
+    private async void FloatChildRegion_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("ChildContentRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating ChildContentRegion",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            MessageBox.Show(ex.Message, "Cannot float ChildContentRegion", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
 }
diff --git a/samples/Sample.Wpf/Views/ItemsRegionView.xaml b/samples/Sample.Wpf/Views/ItemsRegionView.xaml
index 55ca185..208ed3c 100644
--- a/samples/Sample.Wpf/Views/ItemsRegionView.xaml
+++ b/samples/Sample.Wpf/Views/ItemsRegionView.xaml
@@ -53,7 +53,7 @@
             <Button
                 Padding="8,4"
                 Click="FloatSelectedItem_Click"
-                Content="Float selected ItemsRegion view" />
+                Content="Floating: selected ItemsRegion view" />
         </StackPanel>
         <ScrollViewer>
             <ItemsControl an:RegionManager.RegionName="ItemsRegion">
diff --git a/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs b/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
index 2f08ac0..f349f71 100644
--- a/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/ItemsRegionView.xaml.cs
@@ -36,7 +36,7 @@ private async void FloatSelectedItem_Click(object sender, RoutedEventArgs e)
                 Height = 480
             });
         }
-        catch (InvalidOperationException ex)
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
         {
             MessageBox.Show(ex.Message, "Cannot float ItemsRegion", MessageBoxButton.OK, MessageBoxImage.Information);
         }
diff --git a/samples/Sample.Wpf/Views/ListBoxRegionView.xaml b/samples/Sample.Wpf/Views/ListBoxRegionView.xaml
index efcc25a..32958d2 100644
--- a/samples/Sample.Wpf/Views/ListBoxRegionView.xaml
+++ b/samples/Sample.Wpf/Views/ListBoxRegionView.xaml
@@ -23,6 +23,10 @@
                 Content="ToHeavyView"
                 Style="{StaticResource NavigationButton}"
                 Tag="HeavyView" />
+            <Button
+                Padding="8,4"
+                Click="FloatSelectedItem_Click"
+                Content="Floating: selected CustomListBoxRegion view" />
         </StackPanel>
         <ListBox an:RegionManager.RegionName="CustomListBoxRegion" />
     </DockPanel>
diff --git a/samples/Sample.Wpf/Views/ListBoxRegionView.xaml.cs b/samples/Sample.Wpf/Views/ListBoxRegionView.xaml.cs
index c67db98..c7ac2d3 100644
--- a/samples/Sample.Wpf/Views/ListBoxRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/ListBoxRegionView.xaml.cs
@@ -1,29 +1,41 @@
-using AsyncNavigation.Abstractions;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Floating;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
 
-namespace Sample.Wpf.Views
+namespace Sample.Wpf.Views;
+
+public partial class ListBoxRegionView : UserControl, IView
 {
-    /// <summary>
-    /// Interaction logic for ListBoxRegionView.xaml
-    /// </summary>
-    public partial class ListBoxRegionView : UserControl,IView
+    private readonly IViewPlacementService? _placementService;
+
+    public ListBoxRegionView() : this(null)
+    {
+    }
+
+    public ListBoxRegionView(IViewPlacementService? placementService)
     {
-        public ListBoxRegionView()
+        _placementService = placementService;
+        InitializeComponent();
+    }
+
+    private async void FloatSelectedItem_Click(object sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("CustomListBoxRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating CustomListBoxRegion item",
+                Width = 720,
+                Height = 480
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
         {
-            InitializeComponent();
+            MessageBox.Show(ex.Message, "Cannot float CustomListBoxRegion", MessageBoxButton.OK, MessageBoxImage.Information);
         }
     }
 }
diff --git a/samples/Sample.Wpf/Views/TabRegionView.xaml b/samples/Sample.Wpf/Views/TabRegionView.xaml
index ac4da21..b7f272c 100644
--- a/samples/Sample.Wpf/Views/TabRegionView.xaml
+++ b/samples/Sample.Wpf/Views/TabRegionView.xaml
@@ -58,7 +58,7 @@
             <Button
                 Padding="8,4"
                 Click="FloatCurrent_Click"
-                Content="Float selected tab" />
+                Content="Floating: selected TabRegion view" />
             <TextBlock
                 Width="170"
                 Margin="4"
diff --git a/samples/Sample.Wpf/Views/TabRegionView.xaml.cs b/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
index 96a91e2..a85c408 100644
--- a/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
+++ b/samples/Sample.Wpf/Views/TabRegionView.xaml.cs
@@ -36,7 +36,7 @@ private async void FloatCurrent_Click(object sender, RoutedEventArgs e)
                 Height = 480
             });
         }
-        catch (InvalidOperationException ex)
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
         {
             MessageBox.Show(ex.Message, "Cannot float tab", MessageBoxButton.OK, MessageBoxImage.Information);
         }
diff --git a/src/AsyncNavigation.Avalonia.Floating/AssemblyInfo.cs b/src/AsyncNavigation.Avalonia.Floating/AssemblyInfo.cs
new file mode 100644
index 0000000..1efb7f6
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("AsyncNavigation.E2E.Tests")]
diff --git a/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
index 5a2dfb8..2bb9a57 100644
--- a/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
+++ b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
@@ -73,8 +73,11 @@ private void OnClosing(object? sender, WindowClosingEventArgs e)
     {
         if (_allowClose)
             return;
+
         e.Cancel = true;
-        RestoreRequested?.Invoke(this, EventArgs.Empty);
+        Dispatcher.UIThread.Post(
+            () => RestoreRequested?.Invoke(this, EventArgs.Empty),
+            DispatcherPriority.Normal);
     }
 
     private async Task InvokeAsync(Action action, CancellationToken cancellationToken)
diff --git a/src/AsyncNavigation.Wpf.Floating/AssemblyInfo.cs b/src/AsyncNavigation.Wpf.Floating/AssemblyInfo.cs
new file mode 100644
index 0000000..4c66b87
--- /dev/null
+++ b/src/AsyncNavigation.Wpf.Floating/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("AsyncNavigation.Wpf.E2E.Tests")]
diff --git a/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs b/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
index d80dd80..8ddf61d 100644
--- a/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
+++ b/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
@@ -1,6 +1,7 @@
 using AsyncNavigation.Floating;
 using System.ComponentModel;
 using System.Windows;
+using System.Windows.Threading;
 
 namespace AsyncNavigation.Wpf.Floating;
 
@@ -72,7 +73,9 @@ private void OnClosing(object? sender, CancelEventArgs e)
         if (_allowClose)
             return;
         e.Cancel = true;
-        RestoreRequested?.Invoke(this, EventArgs.Empty);
+        _ = _window.Dispatcher.InvokeAsync(
+            () => RestoreRequested?.Invoke(this, EventArgs.Empty),
+            DispatcherPriority.Normal);
     }
 
     private Task InvokeAsync(Action action, CancellationToken cancellationToken)
diff --git a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
index e8186fe..a4e3168 100644
--- a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
+++ b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
@@ -22,6 +22,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\AsyncNavigation.Avalonia\AsyncNavigation.Avalonia.csproj" />
+    <ProjectReference Include="..\..\src\AsyncNavigation.Avalonia.Floating\AsyncNavigation.Avalonia.Floating.csproj" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs
new file mode 100644
index 0000000..2126376
--- /dev/null
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs
@@ -0,0 +1,42 @@
+using AsyncNavigation.Avalonia.Floating;
+using AsyncNavigation.Floating;
+using Avalonia.Controls;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+
+namespace AsyncNavigation.E2E.Tests;
+
+public sealed class FloatingWindowLifecycleTests
+{
+    [AvaloniaFact]
+    public void User_close_restores_content_and_then_closes_the_window()
+    {
+        var content = new Border();
+        var restoredContent = new ContentControl();
+        var host = new AvaloniaFloatingWindowHost(new FloatingWindowOptions
+        {
+            Title = "Floating lifecycle test",
+            Width = 320,
+            Height = 240
+        });
+
+        host.SetContentAsync(content).GetAwaiter().GetResult();
+        host.ShowAsync().GetAwaiter().GetResult();
+        var window = TopLevel.GetTopLevel(content) as Window
+            ?? throw new InvalidOperationException("The floating window was not created.");
+
+        host.RestoreRequested += async (_, _) =>
+        {
+            await host.SetContentAsync(null);
+            restoredContent.Content = content;
+            await host.CloseAsync();
+            await host.DisposeAsync();
+        };
+
+        window.Close();
+        Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+
+        Assert.Same(content, restoredContent.Content);
+        Assert.False(window.IsVisible);
+    }
+}
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj b/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
new file mode 100644
index 0000000..e199f70
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <OutputType>Exe</OutputType>
+    <UseWPF>true</UseWPF>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
+    <PackageReference Include="xunit.v3" Version="3.2.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\AsyncNavigation.Wpf.Floating\AsyncNavigation.Wpf.Floating.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingVisualStateTests.cs b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingVisualStateTests.cs
new file mode 100644
index 0000000..df73ce4
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingVisualStateTests.cs
@@ -0,0 +1,202 @@
+using System.ComponentModel;
+using System.Runtime.ExceptionServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Threading;
+
+namespace AsyncNavigation.Wpf.E2E.Tests;
+
+public sealed class FloatingVisualStateTests
+{
+    [Fact]
+    public void Unbound_date_survives_moving_the_same_view_between_windows()
+    {
+        RunOnStaThread(() =>
+        {
+            var selectedDate = new DateTime(2026, 9, 1);
+            var view = CreateTemplatedView(new object());
+
+            using var mainWindow = new TestWindow();
+            using var floatingWindow = new TestWindow();
+
+            mainWindow.Content = view;
+            mainWindow.Show();
+            FlushDispatcher();
+
+            var originalDatePicker = FindVisualChild<DatePicker>(view)
+                ?? throw new InvalidOperationException("The DatePicker was not created.");
+
+            originalDatePicker.SelectedDate = selectedDate;
+            MoveToFloatingWindowAndBack(
+                view,
+                originalDatePicker,
+                selectedDate,
+                mainWindow,
+                floatingWindow);
+        });
+    }
+
+    [Fact]
+    public void Bound_date_survives_moving_the_same_view_between_windows()
+    {
+        RunOnStaThread(() =>
+        {
+            var selectedDate = new DateTime(2026, 9, 1);
+            var state = new ViewState();
+            var view = CreateTemplatedView(state, nameof(ViewState.SelectedDate));
+
+            using var mainWindow = new TestWindow();
+            using var floatingWindow = new TestWindow();
+
+            mainWindow.Content = view;
+            mainWindow.Show();
+            FlushDispatcher();
+
+            var originalDatePicker = FindVisualChild<DatePicker>(view)
+                ?? throw new InvalidOperationException("The DatePicker was not created.");
+
+            originalDatePicker.SelectedDate = selectedDate;
+            FlushDispatcher();
+            Assert.Equal(selectedDate, state.SelectedDate);
+
+            MoveToFloatingWindowAndBack(
+                view,
+                originalDatePicker,
+                selectedDate,
+                mainWindow,
+                floatingWindow);
+            Assert.Equal(selectedDate, state.SelectedDate);
+        });
+    }
+
+    private static void MoveToFloatingWindowAndBack(
+        UserControl view,
+        DatePicker originalDatePicker,
+        DateTime selectedDate,
+        TestWindow mainWindow,
+        TestWindow floatingWindow)
+    {
+        mainWindow.Content = null;
+        floatingWindow.Content = view;
+        floatingWindow.Show();
+        FlushDispatcher();
+
+        var floatingDatePicker = FindVisualChild<DatePicker>(view)
+            ?? throw new InvalidOperationException("The DatePicker was not found in the floating window.");
+        Assert.Same(originalDatePicker, floatingDatePicker);
+        Assert.Equal(selectedDate, floatingDatePicker.SelectedDate);
+
+        floatingWindow.Content = null;
+        mainWindow.Content = view;
+        FlushDispatcher();
+
+        var restoredDatePicker = FindVisualChild<DatePicker>(view)
+            ?? throw new InvalidOperationException("The DatePicker was not found after restoration.");
+        Assert.Same(originalDatePicker, restoredDatePicker);
+        Assert.Equal(selectedDate, restoredDatePicker.SelectedDate);
+    }
+
+    private static UserControl CreateTemplatedView(object state, string? selectedDatePath = null)
+    {
+        var datePickerFactory = new FrameworkElementFactory(typeof(DatePicker));
+        if (selectedDatePath is not null)
+        {
+            datePickerFactory.SetBinding(
+                DatePicker.SelectedDateProperty,
+                new Binding(selectedDatePath)
+                {
+                    Mode = BindingMode.TwoWay,
+                    UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
+                });
+        }
+
+        var presenter = new ContentPresenter
+        {
+            Content = state,
+            ContentTemplate = new DataTemplate { VisualTree = datePickerFactory }
+        };
+
+        return new UserControl { Content = presenter };
+    }
+
+    private static T? FindVisualChild<T>(DependencyObject parent)
+        where T : DependencyObject
+    {
+        for (var i = 0; i < System.Windows.Media.VisualTreeHelper.GetChildrenCount(parent); i++)
+        {
+            var child = System.Windows.Media.VisualTreeHelper.GetChild(parent, i);
+            if (child is T match)
+            {
+                return match;
+            }
+
+            var descendant = FindVisualChild<T>(child);
+            if (descendant is not null)
+            {
+                return descendant;
+            }
+        }
+
+        return null;
+    }
+
+    private static void FlushDispatcher() =>
+        Dispatcher.CurrentDispatcher.Invoke(static () => { }, DispatcherPriority.ApplicationIdle);
+
+    private static void RunOnStaThread(Action action)
+    {
+        Exception? failure = null;
+        var thread = new Thread(() =>
+        {
+            try
+            {
+                action();
+            }
+            catch (Exception exception)
+            {
+                failure = exception;
+            }
+            finally
+            {
+                Dispatcher.CurrentDispatcher.InvokeShutdown();
+            }
+        });
+
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+
+        if (failure is not null)
+        {
+            ExceptionDispatchInfo.Capture(failure).Throw();
+        }
+    }
+
+    private sealed class TestWindow : Window, IDisposable
+    {
+        public void Dispose() => Close();
+    }
+
+    private sealed class ViewState : INotifyPropertyChanged
+    {
+        private DateTime? _selectedDate;
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        public DateTime? SelectedDate
+        {
+            get => _selectedDate;
+            set
+            {
+                if (_selectedDate == value)
+                {
+                    return;
+                }
+
+                _selectedDate = value;
+                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(SelectedDate)));
+            }
+        }
+    }
+}
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs
new file mode 100644
index 0000000..54c3f63
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs
@@ -0,0 +1,78 @@
+using AsyncNavigation.Floating;
+using AsyncNavigation.Wpf.Floating;
+using System.Runtime.ExceptionServices;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+
+namespace AsyncNavigation.Wpf.E2E.Tests;
+
+public sealed class FloatingWindowLifecycleTests
+{
+    [Fact]
+    public void User_close_restores_content_and_then_closes_the_window()
+    {
+        RunOnStaThread(() =>
+        {
+            var content = new Border();
+            var restoredContent = new ContentControl();
+            var host = new WpfFloatingWindowHost(new FloatingWindowOptions
+            {
+                Title = "Floating lifecycle test",
+                Width = 320,
+                Height = 240
+            });
+
+            host.SetContentAsync(content).GetAwaiter().GetResult();
+            host.ShowAsync().GetAwaiter().GetResult();
+            var window = Window.GetWindow(content)
+                ?? throw new InvalidOperationException("The floating window was not created.");
+
+            host.RestoreRequested += async (_, _) =>
+            {
+                await host.SetContentAsync(null);
+                restoredContent.Content = content;
+                await host.CloseAsync();
+                await host.DisposeAsync();
+            };
+
+            window.Close();
+            FlushDispatcher();
+
+            Assert.Same(content, restoredContent.Content);
+            Assert.False(window.IsVisible);
+        });
+    }
+
+    private static void FlushDispatcher() =>
+        Dispatcher.CurrentDispatcher.Invoke(static () => { }, DispatcherPriority.ApplicationIdle);
+
+    private static void RunOnStaThread(Action action)
+    {
+        Exception? failure = null;
+        var thread = new Thread(() =>
+        {
+            try
+            {
+                action();
+            }
+            catch (Exception exception)
+            {
+                failure = exception;
+            }
+            finally
+            {
+                Dispatcher.CurrentDispatcher.InvokeShutdown();
+            }
+        });
+
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+
+        if (failure is not null)
+        {
+            ExceptionDispatchInfo.Capture(failure).Throw();
+        }
+    }
+}
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/README.md b/tests/AsyncNavigation.Wpf.E2E.Tests/README.md
new file mode 100644
index 0000000..7b4795f
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/README.md
@@ -0,0 +1,22 @@
+# WPF floating reference test
+
+This Windows-only test documents how WPF behaves when the same view is moved
+between two top-level windows. It intentionally lives outside
+`src/AsyncNavigation.slnx`, so normal solution builds and CI test runs do not
+execute it.
+
+Run it explicitly on an interactive Windows machine:
+
+```powershell
+dotnet test tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
+```
+
+The tests do not use UI Automation. They run WPF directly on an STA thread and
+check the generated `DatePicker` instance and its date before floating, while
+floating, and after restoration. Both unbound UI state and TwoWay-bound MVVM
+state are covered.
+
+The lifecycle regression test also closes a floating window through its normal
+close button path and verifies that its content is restored and the now-empty
+window actually closes. This protects against re-entering `Window.Close()` from
+inside WPF's synchronous `Closing` event.

From 6c62de954b7a11226109468140568334f750bd4c Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 29 Sep 2026 11:34:00 +0200
Subject: [PATCH 07/14] Fix floating view navigation, docking, and close
 lifecycle

---
 .../Sample.Avalonia/Views/MainWindow.axaml    |   2 +-
 .../Sample.Avalonia/Views/TabRegionView.axaml |   2 +-
 samples/Sample.Wpf/Views/TabRegionView.xaml   |   2 +-
 .../AvaloniaFloatingWindowHost.cs             |  13 +-
 src/AsyncNavigation.Avalonia/ContentRegion.cs |   3 +-
 .../FloatingServiceCollectionExtensions.cs    |   1 +
 .../IFloatingViewSession.cs                   |   1 +
 .../IFloatingWindowHost.cs                    |   1 +
 .../ViewPlacementService.cs                   | 158 ++++++--
 .../ViewPlacementState.cs                     |   4 +-
 .../WpfFloatingWindowHost.cs                  |  14 +-
 src/AsyncNavigation.Wpf/ContentRegion.cs      |   3 +-
 .../Abstractions/IRegionNavigationHistory.cs  |   1 +
 .../Abstractions/IRegionNavigationService.cs  |   7 +-
 .../IRegionPlacementNavigation.cs             |  11 +
 .../IRegionPlacementParticipant.cs            |   4 +-
 .../Abstractions/IViewPlacementCache.cs       |  11 +
 src/AsyncNavigation/NavigationContext.cs      |   3 +
 src/AsyncNavigation/RegionBase.cs             | 125 ++++++-
 .../RegionNavigationHistory.cs                |  10 +
 .../RegionNavigationService.cs                |  96 ++++-
 src/AsyncNavigation/ViewManager.cs            |  63 +++-
 .../ViewPlacementCoordinator.cs               |  41 +++
 tests/AsyncNavigation.E2E.Tests/App.axaml     |   1 +
 .../AsyncNavigation.E2E.Tests.csproj          |   2 +
 .../FloatingNavigationTests.cs                | 113 ++++++
 .../FloatingWindowLifecycleTests.cs           |  31 +-
 .../FloatingNavigationTests.cs                | 341 ++++++++++++++++++
 .../ViewPlacementServiceTests.cs              |  41 ++-
 .../AsyncNavigation.Wpf.E2E.Tests.csproj      |   1 +
 .../FloatingNavigationTests.cs                | 136 +++++++
 .../FloatingWindowLifecycleTests.cs           |  31 +-
 tests/AsyncNavigation.Wpf.E2E.Tests/README.md |  14 +-
 33 files changed, 1186 insertions(+), 101 deletions(-)
 create mode 100644 src/AsyncNavigation/Abstractions/IRegionPlacementNavigation.cs
 create mode 100644 src/AsyncNavigation/Abstractions/IViewPlacementCache.cs
 create mode 100644 src/AsyncNavigation/ViewPlacementCoordinator.cs
 create mode 100644 tests/AsyncNavigation.E2E.Tests/FloatingNavigationTests.cs
 create mode 100644 tests/AsyncNavigation.Tests/FloatingNavigationTests.cs
 create mode 100644 tests/AsyncNavigation.Wpf.E2E.Tests/FloatingNavigationTests.cs

diff --git a/samples/Sample.Avalonia/Views/MainWindow.axaml b/samples/Sample.Avalonia/Views/MainWindow.axaml
index def88af..f5c011d 100644
--- a/samples/Sample.Avalonia/Views/MainWindow.axaml
+++ b/samples/Sample.Avalonia/Views/MainWindow.axaml
@@ -18,7 +18,7 @@
         <Border Padding="8" DockPanel.Dock="Top">
             <StackPanel Orientation="Horizontal" Spacing="8">
                 <Button Click="FloatMainRegion_Click" Content="Floating: current MainRegion view" />
-                <TextBlock VerticalAlignment="Center" Text="The same UserControl instance moves to the window; close it to restore." />
+                <TextBlock VerticalAlignment="Center" Text="The same UserControl instance moves to the window; use Dock to region to return it. Closing closes the view." />
             </StackPanel>
         </Border>
         <views:MainView />
diff --git a/samples/Sample.Avalonia/Views/TabRegionView.axaml b/samples/Sample.Avalonia/Views/TabRegionView.axaml
index eb1f5bb..3bf22f5 100644
--- a/samples/Sample.Avalonia/Views/TabRegionView.axaml
+++ b/samples/Sample.Avalonia/Views/TabRegionView.axaml
@@ -64,7 +64,7 @@
             <TextBlock
                 Width="170"
                 Margin="4"
-                Text="Close the floating window to restore the tab."
+                Text="Use Dock to region to restore the tab; closing the window closes it."
                 TextWrapping="Wrap" />
         </StackPanel>
         <ScrollViewer>
diff --git a/samples/Sample.Wpf/Views/TabRegionView.xaml b/samples/Sample.Wpf/Views/TabRegionView.xaml
index b7f272c..7c9502c 100644
--- a/samples/Sample.Wpf/Views/TabRegionView.xaml
+++ b/samples/Sample.Wpf/Views/TabRegionView.xaml
@@ -62,7 +62,7 @@
             <TextBlock
                 Width="170"
                 Margin="4"
-                Text="Close the floating window to restore the tab."
+                Text="Use Dock to region to restore the tab; closing the window closes it."
                 TextWrapping="Wrap" />
         </StackPanel>
         <ScrollViewer>
diff --git a/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
index 2bb9a57..8d23ac8 100644
--- a/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
+++ b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
@@ -22,6 +22,7 @@ internal sealed class AvaloniaFloatingWindowHost : IFloatingWindowHost
 {
     private readonly Window _window;
     private bool _allowClose;
+    private readonly ContentControl _content = new();
 
     public AvaloniaFloatingWindowHost(FloatingWindowOptions options)
     {
@@ -35,13 +36,21 @@ public AvaloniaFloatingWindowHost(FloatingWindowOptions options)
         };
         if (options.Width.HasValue) _window.Width = options.Width.Value;
         if (options.Height.HasValue) _window.Height = options.Height.Value;
+        var dockButton = new Button { Content = "Dock to region", Margin = new Thickness(8) };
+        dockButton.Click += (_, _) => RestoreRequested?.Invoke(this, EventArgs.Empty);
+        DockPanel.SetDock(dockButton, Dock.Top);
+        var panel = new DockPanel { LastChildFill = true };
+        panel.Children.Add(dockButton);
+        panel.Children.Add(_content);
+        _window.Content = panel;
         _window.Closing += OnClosing;
     }
 
     public event EventHandler? RestoreRequested;
+    public event EventHandler? CloseRequested;
 
     public Task SetContentAsync(object? content, CancellationToken cancellationToken = default) =>
-        InvokeAsync(() => _window.Content = content, cancellationToken);
+        InvokeAsync(() => _content.Content = content, cancellationToken);
 
     public Task ShowAsync(CancellationToken cancellationToken = default) =>
         InvokeAsync(_window.Show, cancellationToken);
@@ -76,7 +85,7 @@ private void OnClosing(object? sender, WindowClosingEventArgs e)
 
         e.Cancel = true;
         Dispatcher.UIThread.Post(
-            () => RestoreRequested?.Invoke(this, EventArgs.Empty),
+            () => CloseRequested?.Invoke(this, EventArgs.Empty),
             DispatcherPriority.Normal);
     }
 
diff --git a/src/AsyncNavigation.Avalonia/ContentRegion.cs b/src/AsyncNavigation.Avalonia/ContentRegion.cs
index 03c8cbb..2d4bc6f 100644
--- a/src/AsyncNavigation.Avalonia/ContentRegion.cs
+++ b/src/AsyncNavigation.Avalonia/ContentRegion.cs
@@ -54,7 +54,8 @@ public override Task ProcessActivateAsync(NavigationContext navigationContext)
 
     public override Task ProcessDeactivateAsync(NavigationContext? navigationContext)
     {
-        _context.Selected = null;
+        if (navigationContext is null || ReferenceEquals(_context.Selected, navigationContext))
+            _context.Selected = null;
         return Task.CompletedTask;
     }
 
diff --git a/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs b/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs
index 8277381..69de01b 100644
--- a/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs
+++ b/src/AsyncNavigation.Floating/FloatingServiceCollectionExtensions.cs
@@ -10,6 +10,7 @@ public static class FloatingServiceCollectionExtensions
     public static IServiceCollection AddFloatingSupportCore(this IServiceCollection services)
     {
         ArgumentNullException.ThrowIfNull(services);
+        services.TryAddSingleton<ViewPlacementCoordinator>();
         services.TryAddSingleton<IViewPlacementService, ViewPlacementService>();
         return services;
     }
diff --git a/src/AsyncNavigation.Floating/IFloatingViewSession.cs b/src/AsyncNavigation.Floating/IFloatingViewSession.cs
index 317220b..92e3ea2 100644
--- a/src/AsyncNavigation.Floating/IFloatingViewSession.cs
+++ b/src/AsyncNavigation.Floating/IFloatingViewSession.cs
@@ -6,6 +6,7 @@ public interface IFloatingViewSession
     Guid NavigationId { get; }
     string OriginRegionName { get; }
     ViewPlacementState State { get; }
+    Task CloseAsync(CancellationToken cancellationToken = default);
     Task RestoreAsync(CancellationToken cancellationToken = default);
     Task ActivateAsync(CancellationToken cancellationToken = default);
 }
diff --git a/src/AsyncNavigation.Floating/IFloatingWindowHost.cs b/src/AsyncNavigation.Floating/IFloatingWindowHost.cs
index 0ae5660..9f990d6 100644
--- a/src/AsyncNavigation.Floating/IFloatingWindowHost.cs
+++ b/src/AsyncNavigation.Floating/IFloatingWindowHost.cs
@@ -3,6 +3,7 @@ namespace AsyncNavigation.Floating;
 public interface IFloatingWindowHost : IAsyncDisposable
 {
     event EventHandler? RestoreRequested;
+    event EventHandler? CloseRequested;
     Task SetContentAsync(object? content, CancellationToken cancellationToken = default);
     Task ShowAsync(CancellationToken cancellationToken = default);
     Task ActivateAsync(CancellationToken cancellationToken = default);
diff --git a/src/AsyncNavigation.Floating/ViewPlacementService.cs b/src/AsyncNavigation.Floating/ViewPlacementService.cs
index c6e5116..d946219 100644
--- a/src/AsyncNavigation.Floating/ViewPlacementService.cs
+++ b/src/AsyncNavigation.Floating/ViewPlacementService.cs
@@ -6,13 +6,15 @@ namespace AsyncNavigation.Floating;
 
 internal sealed class ViewPlacementService : IViewPlacementService, IDisposable
 {
+    private readonly ViewPlacementCoordinator _placement;
     private readonly IRegionManager _regionManager;
     private readonly IFloatingWindowHostFactory _windowFactory;
     private readonly ConcurrentDictionary<Guid, FloatingViewSession> _sessions = [];
     private readonly ConcurrentDictionary<Guid, Guid> _sessionsByNavigationId = [];
 
-    public ViewPlacementService(IRegionManager regionManager, IFloatingWindowHostFactory windowFactory)
+    public ViewPlacementService(IRegionManager regionManager, IFloatingWindowHostFactory windowFactory, ViewPlacementCoordinator placement)
     {
+        _placement = placement;
         _regionManager = regionManager;
         _windowFactory = windowFactory;
     }
@@ -28,6 +30,7 @@ public async Task<IFloatingViewSession> FloatAsync(
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(regionName);
         cancellationToken.ThrowIfCancellationRequested();
+        using var lease = await _placement.EnterAsync(regionName, cancellationToken);
 
         if (navigationId.HasValue &&
             _sessionsByNavigationId.TryGetValue(navigationId.Value, out var activeSessionId) &&
@@ -53,7 +56,7 @@ public async Task<IFloatingViewSession> FloatAsync(
         options = (options ?? new FloatingWindowOptions()).WithDefaultTitle(item.Context.ViewName);
         var host = _windowFactory.Create(options);
         var contentOwner = item.Context.IndicatorHost.Value as IRegionPlacementContentHost;
-        var session = new FloatingViewSession(this, Guid.NewGuid(), regionName, item, contentOwner, host);
+        var session = new FloatingViewSession(this, Guid.NewGuid(), regionName, region, item, contentOwner, host);
 
         if (!_sessionsByNavigationId.TryAdd(item.Context.NavigationId, session.Id))
         {
@@ -74,10 +77,17 @@ public async Task<IFloatingViewSession> FloatAsync(
         }
 
         host.RestoreRequested += session.OnRestoreRequested;
+        host.CloseRequested += session.OnCloseRequested;
+        var registered = false;
         var detached = false;
         var contentDetached = false;
         try
         {
+            if (item.Context.Target.Value is { } view)
+            {
+                _placement.Register(view, session.ActivateAsync);
+                registered = true;
+            }
             var content = contentOwner?.DetachContent() ?? GetContentHost(item);
             contentDetached = contentOwner is not null;
             session.SetContent(content);
@@ -85,11 +95,14 @@ public async Task<IFloatingViewSession> FloatAsync(
             detached = true;
             await host.SetContentAsync(content, cancellationToken);
             await host.ShowAsync(cancellationToken);
+            (region as IRegionPlacementNavigation)?.OnViewDetached(item);
             return session;
         }
         catch
         {
+            if (registered && item.Context.Target.Value is { } view) _placement.Unregister(view);
             host.RestoreRequested -= session.OnRestoreRequested;
+            host.CloseRequested -= session.OnCloseRequested;
             _sessions.TryRemove(session.Id, out _);
             _sessionsByNavigationId.TryRemove(item.Context.NavigationId, out _);
             try
@@ -124,38 +137,54 @@ public bool TryGetSession(Guid sessionId, out IFloatingViewSession? session)
 
     internal async Task RestoreCoreAsync(FloatingViewSession session, CancellationToken cancellationToken)
     {
-        if (!_regionManager.TryGetRegion(session.OriginRegionName, out var region) ||
-            region is not IRegionPlacementParticipant participant)
+        using var lease = await _placement.EnterAsync(session.OriginRegionName, cancellationToken);
+        if (!session.OriginRegion.TryGetTarget(out var originalRegion) ||
+            !_regionManager.TryGetRegion(session.OriginRegionName, out var region) ||
+            region is not IRegionPlacementParticipant participant || !ReferenceEquals(region, originalRegion))
         {
             throw new InvalidOperationException($"Origin region '{session.OriginRegionName}' is not available.");
         }
 
-        await session.Host.SetContentAsync(null, cancellationToken);
-        try
+        var contentAttached = false;
+        async Task TransferContent()
         {
-            participant.Attach(session.Item);
+            await session.Host.SetContentAsync(null, cancellationToken);
             session.ContentOwner?.AttachContent(session.Content);
+            contentAttached = true;
         }
-        catch
+        async Task RollbackContent()
+        {
+            if (contentAttached && session.ContentOwner is not null)
+                session.ContentOwner.DetachContent();
+            await session.Host.SetContentAsync(session.Content, CancellationToken.None);
+        }
+
+        if (region is IRegionPlacementNavigation navigation)
+        {
+            await navigation.RestorePlacementAsync(session.Item, TransferContent, RollbackContent, cancellationToken);
+        }
+        else
         {
-            if (session.ContentOwner is not null)
+            var attached = false;
+            try
             {
-                try
-                {
-                    participant.Detach(session.Item);
-                }
-                catch (Exception ex)
-                {
-                    Debug.WriteLine($"Could not roll back region attachment for '{session.NavigationId}': {ex}");
-                }
+                await TransferContent();
+                participant.Attach(session.Item);
+                attached = true;
+            }
+            catch
+            {
+                if (attached) participant.Detach(session.Item);
+                await RollbackContent();
+                throw;
             }
-            await session.Host.SetContentAsync(session.Content, CancellationToken.None);
-            throw;
         }
 
+        if (session.Item.Context.Target.Value is { } restoredView) _placement.Unregister(restoredView);
         _sessions.TryRemove(session.Id, out _);
         _sessionsByNavigationId.TryRemove(session.NavigationId, out _);
         session.Host.RestoreRequested -= session.OnRestoreRequested;
+        session.Host.CloseRequested -= session.OnCloseRequested;
         try
         {
             await session.Host.CloseAsync(CancellationToken.None);
@@ -167,10 +196,58 @@ internal async Task RestoreCoreAsync(FloatingViewSession session, CancellationTo
         }
     }
 
+    internal async Task CloseCoreAsync(FloatingViewSession session, CancellationToken cancellationToken)
+    {
+        using var lease = await _placement.EnterAsync(session.OriginRegionName, cancellationToken);
+        await session.Host.SetContentAsync(null, cancellationToken);
+        try
+        {
+            await session.Host.CloseAsync(CancellationToken.None);
+        }
+        catch
+        {
+            await session.Host.SetContentAsync(session.Content, CancellationToken.None);
+            throw;
+        }
+
+        if (session.Item.Context.Target.Value is { } closedView)
+        {
+            _placement.Unregister(closedView);
+            if (session.OriginRegion.TryGetTarget(out var origin))
+                (origin as IRegionPlacementNavigation)?.OnViewClosed(session.Item);
+            DisposeClosedView(closedView);
+        }
+        _sessions.TryRemove(session.Id, out _);
+        _sessionsByNavigationId.TryRemove(session.NavigationId, out _);
+        session.Host.RestoreRequested -= session.OnRestoreRequested;
+        session.Host.CloseRequested -= session.OnCloseRequested;
+        try
+        {
+            await session.Host.DisposeAsync();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Could not dispose floating window for '{session.NavigationId}': {ex}");
+        }
+    }
+
+    private static void DisposeClosedView(IView view)
+    {
+        foreach (var value in new object?[] { view, view.DataContext }.Distinct(ReferenceEqualityComparer.Instance))
+        {
+            try { (value as IDisposable)?.Dispose(); }
+            catch (Exception ex) { Debug.WriteLine($"Could not dispose closed view: {ex}"); }
+        }
+    }
+
     public void Dispose()
     {
         foreach (var session in _sessions.Values)
+        {
+            if (session.Item.Context.Target.Value is { } view) _placement.Unregister(view);
             session.Host.RestoreRequested -= session.OnRestoreRequested;
+            session.Host.CloseRequested -= session.OnCloseRequested;
+        }
         _sessions.Clear();
         _sessionsByNavigationId.Clear();
     }
@@ -184,12 +261,13 @@ internal sealed class FloatingViewSession : IFloatingViewSession
         private readonly ViewPlacementService _owner;
         private readonly SemaphoreSlim _gate = new(1, 1);
 
-        internal FloatingViewSession(ViewPlacementService owner, Guid id, string originRegionName,
+        internal FloatingViewSession(ViewPlacementService owner, Guid id, string originRegionName, IRegion originRegion,
             RegionPlacementItem item, IRegionPlacementContentHost? contentOwner, IFloatingWindowHost host)
         {
             _owner = owner;
             Id = id;
             OriginRegionName = originRegionName;
+            OriginRegion = new WeakReference<IRegion>(originRegion);
             Item = item;
             ContentOwner = contentOwner;
             Host = host;
@@ -199,6 +277,7 @@ internal FloatingViewSession(ViewPlacementService owner, Guid id, string originR
         public Guid NavigationId => Item.Context.NavigationId;
         public string OriginRegionName { get; }
         public ViewPlacementState State { get; private set; } = ViewPlacementState.Floating;
+        internal WeakReference<IRegion> OriginRegion { get; }
         internal RegionPlacementItem Item { get; }
         internal object Content { get; private set; } = null!;
         internal IRegionPlacementContentHost? ContentOwner { get; }
@@ -216,7 +295,7 @@ public async Task RestoreAsync(CancellationToken cancellationToken = default)
             await _gate.WaitAsync(cancellationToken);
             try
             {
-                if (State == ViewPlacementState.Restored)
+                if (State is ViewPlacementState.Restored or ViewPlacementState.Closed)
                     return;
                 State = ViewPlacementState.Restoring;
                 try
@@ -236,6 +315,43 @@ public async Task RestoreAsync(CancellationToken cancellationToken = default)
             }
         }
 
+        public async Task CloseAsync(CancellationToken cancellationToken = default)
+        {
+            await _gate.WaitAsync(cancellationToken);
+            try
+            {
+                if (State is ViewPlacementState.Restored or ViewPlacementState.Closed)
+                    return;
+                State = ViewPlacementState.Closing;
+                try
+                {
+                    await _owner.CloseCoreAsync(this, cancellationToken);
+                    State = ViewPlacementState.Closed;
+                }
+                catch
+                {
+                    State = ViewPlacementState.Floating;
+                    throw;
+                }
+            }
+            finally
+            {
+                _gate.Release();
+            }
+        }
+
+        internal async void OnCloseRequested(object? sender, EventArgs e)
+        {
+            try
+            {
+                await CloseAsync();
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"Could not close floating view '{NavigationId}': {ex}");
+            }
+        }
+
         public Task ActivateAsync(CancellationToken cancellationToken = default) =>
             Host.ActivateAsync(cancellationToken);
 
diff --git a/src/AsyncNavigation.Floating/ViewPlacementState.cs b/src/AsyncNavigation.Floating/ViewPlacementState.cs
index 4b08403..2a8f14c 100644
--- a/src/AsyncNavigation.Floating/ViewPlacementState.cs
+++ b/src/AsyncNavigation.Floating/ViewPlacementState.cs
@@ -4,5 +4,7 @@ public enum ViewPlacementState
 {
     Floating,
     Restoring,
-    Restored
+    Restored,
+    Closing,
+    Closed
 }
diff --git a/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs b/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
index 8ddf61d..93353f6 100644
--- a/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
+++ b/src/AsyncNavigation.Wpf.Floating/WpfFloatingWindowHost.cs
@@ -1,6 +1,7 @@
 using AsyncNavigation.Floating;
 using System.ComponentModel;
 using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Threading;
 
 namespace AsyncNavigation.Wpf.Floating;
@@ -21,6 +22,7 @@ internal sealed class WpfFloatingWindowHost : IFloatingWindowHost
 {
     private readonly Window _window;
     private bool _allowClose;
+    private readonly ContentControl _content = new();
 
     public WpfFloatingWindowHost(FloatingWindowOptions options)
     {
@@ -34,13 +36,21 @@ public WpfFloatingWindowHost(FloatingWindowOptions options)
         };
         if (options.Width.HasValue) _window.Width = options.Width.Value;
         if (options.Height.HasValue) _window.Height = options.Height.Value;
+        var dockButton = new Button { Content = "Dock to region", Margin = new Thickness(8) };
+        dockButton.Click += (_, _) => RestoreRequested?.Invoke(this, EventArgs.Empty);
+        DockPanel.SetDock(dockButton, Dock.Top);
+        var panel = new DockPanel { LastChildFill = true };
+        panel.Children.Add(dockButton);
+        panel.Children.Add(_content);
+        _window.Content = panel;
         _window.Closing += OnClosing;
     }
 
     public event EventHandler? RestoreRequested;
+    public event EventHandler? CloseRequested;
 
     public Task SetContentAsync(object? content, CancellationToken cancellationToken = default) =>
-        InvokeAsync(() => _window.Content = content, cancellationToken);
+        InvokeAsync(() => _content.Content = content, cancellationToken);
 
     public Task ShowAsync(CancellationToken cancellationToken = default) =>
         InvokeAsync(_window.Show, cancellationToken);
@@ -74,7 +84,7 @@ private void OnClosing(object? sender, CancelEventArgs e)
             return;
         e.Cancel = true;
         _ = _window.Dispatcher.InvokeAsync(
-            () => RestoreRequested?.Invoke(this, EventArgs.Empty),
+            () => CloseRequested?.Invoke(this, EventArgs.Empty),
             DispatcherPriority.Normal);
     }
 
diff --git a/src/AsyncNavigation.Wpf/ContentRegion.cs b/src/AsyncNavigation.Wpf/ContentRegion.cs
index 397aa20..2eda160 100644
--- a/src/AsyncNavigation.Wpf/ContentRegion.cs
+++ b/src/AsyncNavigation.Wpf/ContentRegion.cs
@@ -63,7 +63,8 @@ public override Task ProcessActivateAsync(NavigationContext navigationContext)
 
     public override Task ProcessDeactivateAsync(NavigationContext? navigationContext)
     {
-        _context.Selected = null;
+        if (navigationContext is null || ReferenceEquals(_context.Selected, navigationContext))
+            _context.Selected = null;
         return Task.CompletedTask;
     }
 
diff --git a/src/AsyncNavigation/Abstractions/IRegionNavigationHistory.cs b/src/AsyncNavigation/Abstractions/IRegionNavigationHistory.cs
index c546fe9..0b77f55 100644
--- a/src/AsyncNavigation/Abstractions/IRegionNavigationHistory.cs
+++ b/src/AsyncNavigation/Abstractions/IRegionNavigationHistory.cs
@@ -10,4 +10,5 @@ internal interface IRegionNavigationHistory
     NavigationContext? GoBack();
     NavigationContext? GoForward();
     void Clear();
+    void RemoveView(IView view);
 }
diff --git a/src/AsyncNavigation/Abstractions/IRegionNavigationService.cs b/src/AsyncNavigation/Abstractions/IRegionNavigationService.cs
index 2142e34..30c9841 100644
--- a/src/AsyncNavigation/Abstractions/IRegionNavigationService.cs
+++ b/src/AsyncNavigation/Abstractions/IRegionNavigationService.cs
@@ -2,7 +2,12 @@
 
 internal interface IRegionNavigationService<in T> : IDisposable where T : IRegionPresenter
 {
-    Task RequestNavigateAsync(NavigationContext navigationContext);
+    void SetCurrent(NavigationContext? context);
+    void DetachCurrent(IView? view);
+    void ForgetView(IView view);
+    Task PreparePlacementAsync(NavigationContext context);
+    Task CommitPlacementAsync(NavigationContext context, bool notify);
+    Task RequestNavigateAsync(NavigationContext navigationContext, Action? onCompleted = null, bool coordinatePlacement = true);
     Task OnNavigateFromAsync(NavigationContext navigationContext);
     Task RevertAsync(NavigationContext? navigationContext);
 }
diff --git a/src/AsyncNavigation/Abstractions/IRegionPlacementNavigation.cs b/src/AsyncNavigation/Abstractions/IRegionPlacementNavigation.cs
new file mode 100644
index 0000000..2192431
--- /dev/null
+++ b/src/AsyncNavigation/Abstractions/IRegionPlacementNavigation.cs
@@ -0,0 +1,11 @@
+namespace AsyncNavigation.Abstractions;
+
+/// <summary>Synchronizes placement changes with a region's current view and history.</summary>
+public interface IRegionPlacementNavigation
+{
+    void OnViewDetached(RegionPlacementItem item);
+    void OnViewClosed(RegionPlacementItem item);
+    /// <summary>Transfers an existing view transactionally. The caller must hold the region placement lease.</summary>
+    Task RestorePlacementAsync(RegionPlacementItem item, Func<Task> transferContent,
+        Func<Task> rollbackContent, CancellationToken cancellationToken = default);
+}
diff --git a/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs b/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs
index 6f3e77c..24a635b 100644
--- a/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs
+++ b/src/AsyncNavigation/Abstractions/IRegionPlacementParticipant.cs
@@ -5,8 +5,8 @@ namespace AsyncNavigation.Abstractions;
 /// navigation item out of a region and later put it back.
 /// </summary>
 /// <remarks>
-/// Placement changes are not navigation operations and therefore must not
-/// invoke navigation lifecycle callbacks or modify navigation history.
+/// These are low-level visual operations. Use IRegionPlacementNavigation to
+/// coordinate a placement change with current-view state and navigation history.
 /// </remarks>
 public interface IRegionPlacementParticipant
 {
diff --git a/src/AsyncNavigation/Abstractions/IViewPlacementCache.cs b/src/AsyncNavigation/Abstractions/IViewPlacementCache.cs
new file mode 100644
index 0000000..5e39e77
--- /dev/null
+++ b/src/AsyncNavigation/Abstractions/IViewPlacementCache.cs
@@ -0,0 +1,11 @@
+namespace AsyncNavigation.Abstractions;
+
+/// <summary>Optional instance-aware cache operations used by floating navigation.</summary>
+public interface IViewPlacementCache
+{
+    /// <summary>Finds a reusable instance without creating or initializing a view.</summary>
+    Task<IView?> FindCachedViewAsync(string key, Func<IView, Task<bool>> isNavigationTarget);
+
+    /// <summary>Removes entries for exactly this instance without disposing another same-name view.</summary>
+    void RemoveInstance(IView view);
+}
diff --git a/src/AsyncNavigation/NavigationContext.cs b/src/AsyncNavigation/NavigationContext.cs
index 92b8f86..6ed7e83 100644
--- a/src/AsyncNavigation/NavigationContext.cs
+++ b/src/AsyncNavigation/NavigationContext.cs
@@ -11,6 +11,9 @@ namespace AsyncNavigation;
 /// </summary>
 public partial class NavigationContext
 {
+    internal bool CacheLookupCompleted { get; set; }
+    internal bool ActivatedExternally { get; set; }
+
     private readonly TaskCompletionSource<bool> _completionTcs = new();
     private readonly ConcurrentBag<Exception> _errors = [];
 
diff --git a/src/AsyncNavigation/RegionBase.cs b/src/AsyncNavigation/RegionBase.cs
index 05937da..8791724 100644
--- a/src/AsyncNavigation/RegionBase.cs
+++ b/src/AsyncNavigation/RegionBase.cs
@@ -5,10 +5,11 @@
 
 namespace AsyncNavigation;
 
-public abstract class RegionBase<TRegion, TControl> : IRegion, IRegionPresenter
+public abstract class RegionBase<TRegion, TControl> : IRegion, IRegionPresenter, IRegionPlacementNavigation
     where TRegion : class, IRegionPresenter
     where TControl : class
 {
+    private readonly ViewPlacementCoordinator? _placement;
     private readonly IRegionNavigationService<TRegion> _regionNavigationService;
     private readonly IRegionNavigationHistory _navigationHistory;
     private readonly IRegionControlAccessor<TControl> _controlAccessor;
@@ -17,6 +18,7 @@ public RegionBase(string name, TControl control, IServiceProvider serviceProvide
     {
         ArgumentNullException.ThrowIfNull(control);
         ArgumentNullException.ThrowIfNull(serviceProvider);
+        _placement = serviceProvider.GetService<ViewPlacementCoordinator>();
         Name = name;
         _controlAccessor = new WeakRegionControlAccessor<TControl>(control);
         _regionNavigationService = serviceProvider.GetRequiredService<IRegionNavigationServiceFactory>().Create((this as TRegion)!);
@@ -52,11 +54,15 @@ protected virtual void InitializeOnRegionCreated(TControl control)
     }
     async Task<NavigationResult> IRegion.ActivateViewAsync(NavigationContext navigationContext)
     {
-        await _regionNavigationService.RequestNavigateAsync(navigationContext);
-        _navigationHistory.Add(navigationContext);
-        navigationContext.UpdateStatus(NavigationStatus.Succeeded);
+        await _regionNavigationService.RequestNavigateAsync(navigationContext, () =>
+        {
+            if (!navigationContext.ActivatedExternally)
+                _navigationHistory.Add(navigationContext);
+            navigationContext.UpdateStatus(NavigationStatus.Succeeded);
+        });
         var result = NavigationResult.Success(navigationContext);
-        RaiseNavigated(navigationContext);
+        if (!navigationContext.ActivatedExternally)
+            RaiseNavigated(navigationContext);
         return result;
     }
     Task<bool> IRegion.CanGoBackAsync()
@@ -66,14 +72,26 @@ Task<bool> IRegion.CanGoBackAsync()
 
     public async Task<NavigationResult> GoBackAsync(CancellationToken cancellationToken = default)
     {
+        using var lease = _placement is null ? null : await _placement.EnterAsync(Name, cancellationToken);
         cancellationToken.ThrowIfCancellationRequested();
         var navigationContext = _navigationHistory.GoBack() ?? throw new NavigationException("Cannot go back!");
         navigationContext.IsBackNavigation = true;
         navigationContext.LinkCancellationToken(cancellationToken);
-        await _regionNavigationService.RequestNavigateAsync(navigationContext);
+        try
+        {
+            await _regionNavigationService.RequestNavigateAsync(navigationContext, coordinatePlacement: false);
+        }
+        catch
+        {
+            _navigationHistory.GoForward();
+            throw;
+        }
+        if (navigationContext.ActivatedExternally)
+            _navigationHistory.GoForward();
         navigationContext.UpdateStatus(NavigationStatus.Succeeded);
         var result = NavigationResult.Success(navigationContext);
-        RaiseNavigated(navigationContext);
+        if (!navigationContext.ActivatedExternally)
+            RaiseNavigated(navigationContext);
         return result;
     }
 
@@ -84,14 +102,26 @@ Task<bool> IRegion.CanGoForwardAsync()
 
     public async Task<NavigationResult> GoForwardAsync(CancellationToken cancellationToken = default)
     {
+        using var lease = _placement is null ? null : await _placement.EnterAsync(Name, cancellationToken);
         cancellationToken.ThrowIfCancellationRequested();
         var navigationContext = _navigationHistory.GoForward() ?? throw new NavigationException("Cannot go forward!");
         navigationContext.IsForwardNavigation = true;
         navigationContext.LinkCancellationToken(cancellationToken);
-        await _regionNavigationService.RequestNavigateAsync(navigationContext);
+        try
+        {
+            await _regionNavigationService.RequestNavigateAsync(navigationContext, coordinatePlacement: false);
+        }
+        catch
+        {
+            _navigationHistory.GoBack();
+            throw;
+        }
+        if (navigationContext.ActivatedExternally)
+            _navigationHistory.GoBack();
         navigationContext.UpdateStatus(NavigationStatus.Succeeded);
         var result = NavigationResult.Success(navigationContext);
-        RaiseNavigated(navigationContext);
+        if (!navigationContext.ActivatedExternally)
+            RaiseNavigated(navigationContext);
         return result;
     }
     Task IRegion.NavigateFromAsync(NavigationContext navigationContext)
@@ -109,6 +139,83 @@ Task IRegion.RevertAsync(NavigationContext? navigationContext)
     {
         return _regionNavigationService.RevertAsync(navigationContext);
     }
+    public void OnViewDetached(RegionPlacementItem item)
+    {
+        _regionNavigationService.DetachCurrent(item.Context.Target.Value);
+        // Multi-item regions can select a different view when an item is detached.
+        if (!IsSinglePageRegion && this is IRegionPlacementParticipant participant)
+        {
+            try { _regionNavigationService.SetCurrent(participant.Capture().Context); }
+            catch (InvalidOperationException) { }
+        }
+    }
+
+    public void OnViewClosed(RegionPlacementItem item)
+    {
+        if (item.Context.Target.Value is not { } view) return;
+        _regionNavigationService.ForgetView(view);
+        _navigationHistory.RemoveView(view);
+    }
+
+    public async Task RestorePlacementAsync(RegionPlacementItem item, Func<Task> transferContent,
+        Func<Task> rollbackContent, CancellationToken cancellationToken = default)
+    {
+        if (this is not IRegionPlacementParticipant participant)
+            throw new NotSupportedException("The region does not support placement.");
+        RegionPlacementItem? previous = null;
+        try { previous = participant.Capture(); }
+        catch (InvalidOperationException) { }
+
+        var context = new NavigationContext
+        {
+            RegionName = Name,
+            ViewName = item.Context.ViewName,
+            Parameters = item.Context.Parameters
+        };
+        context.Target.Value = item.Context.Target.Value!;
+        context.IndicatorHost.Value = item.Context.IndicatorHost.Value!;
+        context.LinkCancellationToken(cancellationToken);
+        var restored = new RegionPlacementItem(context, item.Index, item.WasSelected);
+        var attached = false;
+        var detached = false;
+        var transferred = false;
+        object? displacedContent = null;
+        var sharedHost = previous is not null &&
+            ReferenceEquals(previous.Context.IndicatorHost.Value, item.Context.IndicatorHost.Value)
+            ? previous.Context.IndicatorHost.Value as IRegionPlacementContentHost : null;
+        try
+        {
+            if (previous is not null)
+                await _regionNavigationService.PreparePlacementAsync(context);
+            cancellationToken.ThrowIfCancellationRequested();
+            if (IsSinglePageRegion && previous is not null)
+            {
+                participant.Detach(previous);
+                detached = true;
+                displacedContent = sharedHost?.DetachContent();
+            }
+            transferred = true;
+            await transferContent();
+            participant.Attach(restored);
+            attached = true;
+            await _regionNavigationService.CommitPlacementAsync(context, notify: previous is not null);
+            cancellationToken.ThrowIfCancellationRequested();
+            _navigationHistory.Add(context);
+            context.UpdateStatus(NavigationStatus.Succeeded);
+        }
+        catch (Exception ex)
+        {
+            if (attached) participant.Detach(restored);
+            if (transferred) await rollbackContent();
+            if (displacedContent is not null) sharedHost!.AttachContent(displacedContent);
+            if (detached) participant.Attach(previous!);
+            else if (previous is not null) await ProcessActivateAsync(previous.Context);
+            _regionNavigationService.SetCurrent(previous?.Context);
+            context.UpdateStatus(ex is OperationCanceledException ? NavigationStatus.Cancelled : NavigationStatus.Failed, ex);
+            throw;
+        }
+    }
+
     public virtual void Dispose()
     {
         GC.SuppressFinalize(this);
diff --git a/src/AsyncNavigation/RegionNavigationHistory.cs b/src/AsyncNavigation/RegionNavigationHistory.cs
index 7f1d890..26a0688 100644
--- a/src/AsyncNavigation/RegionNavigationHistory.cs
+++ b/src/AsyncNavigation/RegionNavigationHistory.cs
@@ -58,6 +58,16 @@ public void Add(NavigationContext context)
         return _history[_currentIndex];
     }
 
+    public void RemoveView(IView view)
+    {
+        for (var i = _history.Count - 1; i >= 0; i--)
+        {
+            if (!ReferenceEquals(_history[i].Target.Value, view)) continue;
+            _history.RemoveAt(i);
+            if (i <= _currentIndex) _currentIndex--;
+        }
+    }
+
     public void Clear()
     {
         _history.Clear();
diff --git a/src/AsyncNavigation/RegionNavigationService.cs b/src/AsyncNavigation/RegionNavigationService.cs
index 632b533..57c5950 100644
--- a/src/AsyncNavigation/RegionNavigationService.cs
+++ b/src/AsyncNavigation/RegionNavigationService.cs
@@ -7,6 +7,7 @@ namespace AsyncNavigation;
 
 internal sealed class RegionNavigationService<T> : IRegionNavigationService<T> where T : IRegionPresenter
 {
+    private readonly ViewPlacementCoordinator? _placement;
     private readonly IViewManager _viewCacheManager;
     private readonly IRegionIndicatorManager _regionIndicatorManager;
     private readonly IAsyncJobProcessor _navigationJobScheduler;
@@ -15,6 +16,7 @@ internal sealed class RegionNavigationService<T> : IRegionNavigationService<T> w
     private readonly NavigationJobStrategy _navigationJobStrategy;
     public RegionNavigationService(T regionPresenter, IServiceProvider serviceProvider)
     {
+        _placement = serviceProvider.GetService<ViewPlacementCoordinator>();
         _regionPresenter = regionPresenter;
         _navigationJobScheduler = serviceProvider.GetRequiredService<IAsyncJobProcessor>();
         _viewCacheManager = serviceProvider.GetRequiredService<IViewManager>();
@@ -25,20 +27,25 @@ public RegionNavigationService(T regionPresenter, IServiceProvider serviceProvid
     {
         get => _current;
     }
-    public async Task RequestNavigateAsync(NavigationContext navigationContext)
+    public async Task RequestNavigateAsync(NavigationContext navigationContext, Action? onCompleted = null, bool coordinatePlacement = true)
     {
+        navigationContext.ActivatedExternally = false;
         try
         {
-            await _navigationJobScheduler.RunJobAsync(navigationContext, CreateNavigateTask, _navigationJobStrategy);
+            await _navigationJobScheduler.RunJobAsync(navigationContext, async context =>
+            {
+                using var lease = !coordinatePlacement || _placement is null ? null :
+                    await _placement.EnterAsync(context.RegionName, context.CancellationToken);
+                await CreateNavigateTask(context);
+                onCompleted?.Invoke();
+            }, _navigationJobStrategy);
         }
         catch (Exception ex) when (ex is not OperationCanceledException)
         {
-            await _regionIndicatorManager.ShowErrorAsync(navigationContext, ex);
+            if (navigationContext.IndicatorHost.IsSet)
+                await _regionIndicatorManager.ShowErrorAsync(navigationContext, ex);
             throw;
         }
-        finally
-        {
-        }
     }
 
     public Task OnNavigateFromAsync(NavigationContext navigationContext)
@@ -58,6 +65,32 @@ public Task RevertAsync(NavigationContext? navigationContext)
             return _regionPresenter.ProcessDeactivateAsync(navigationContext);
         }
     }
+    public void SetCurrent(NavigationContext? context) =>
+        _current = context?.Target.Value is { } view ? (view, context) : null;
+
+    public void DetachCurrent(IView? view)
+    {
+        if (Current.HasValue && ReferenceEquals(Current.Value.View, view))
+            _current = null;
+    }
+
+    public void ForgetView(IView view)
+    {
+        DetachCurrent(view);
+        (_viewCacheManager as IViewPlacementCache)?.RemoveInstance(view);
+    }
+
+    public Task PreparePlacementAsync(NavigationContext context) => OnBeforeNavigationAsync(context);
+    public async Task CommitPlacementAsync(NavigationContext context, bool notify)
+    {
+        if (notify) await OnAfterNavigationAsync(context);
+        else
+        {
+            SubscribeUnload(context);
+            SetCurrent(context);
+        }
+    }
+
     public void Dispose()
     {
         try
@@ -74,6 +107,25 @@ public void Dispose()
     private async Task CreateNavigateTask(NavigationContext navigationContext)
     {
         var isSinglePageRegion = _regionPresenter!.IsSinglePageRegion;
+        if (_placement is not null)
+        {
+            // Inspect reusable instances before leaving or rendering the current region.
+            // New views still initialize in the normal pipeline, after the leave guard.
+            if (!navigationContext.Target.IsSet && _regionPresenter.EnableViewCache &&
+                _viewCacheManager is IViewPlacementCache cache)
+            {
+                var cached = await cache.FindCachedViewAsync(navigationContext.ViewName,
+                    view => HandleIsNavigationTargetAsync(view, navigationContext));
+                navigationContext.CacheLookupCompleted = true;
+                if (cached is not null) navigationContext.Target.Value = cached;
+            }
+            if (navigationContext.Target.IsSet && navigationContext.Target.Value is { } target &&
+                await _placement.TryActivateAsync(target, navigationContext.CancellationToken))
+            {
+                navigationContext.ActivatedExternally = true;
+                return;
+            }
+        }
         _regionIndicatorManager.Setup(navigationContext, isSinglePageRegion);
 
         var navigationTask = RunNavigationAsync(navigationContext, _regionPresenter.NavigationPipelineMode);
@@ -121,7 +173,7 @@ private async Task OnResolveViewAsync(NavigationContext navigationContext)
             return;
         }
         var view = await _viewCacheManager.ResolveViewAsync(navigationContext.ViewName,
-                                _regionPresenter.EnableViewCache,
+                                _regionPresenter.EnableViewCache && !navigationContext.CacheLookupCompleted,
                                 view => RegionNavigationService<T>.HandleIsNavigationTargetAsync(view, navigationContext),
                                 view => RegionNavigationService<T>.HandleInitializeAsync(view, navigationContext));
         navigationContext.CancellationToken.ThrowIfCancellationRequested();
@@ -157,24 +209,32 @@ private async Task OnAfterNavigationAsync(NavigationContext navigationContext)
     {
         if (navigationContext.TryResolveViewAndAware(out var view,out var aware))
         {
-            var contextSnapshot = navigationContext;
-            WeakUnloadObserver.Subscribe(aware,async a =>
-            {
-                if (Current.HasValue)
-                {
-                    if (ReferenceEquals(Current.Value.View.DataContext, a))
-                        _current = null;
-                }
-
-                await _regionPresenter.ProcessDeactivateAsync(contextSnapshot);
-            });
+            SubscribeUnload(navigationContext);
             await aware.OnNavigatedToAsync(navigationContext);
             navigationContext.CancellationToken.ThrowIfCancellationRequested();
             _current = (view, navigationContext);
         }
+        if (navigationContext.Target.Value is { } target)
+            _current = (target, navigationContext);
         navigationContext.CancellationToken.ThrowIfCancellationRequested();
     }
 
+    private void SubscribeUnload(NavigationContext navigationContext)
+    {
+        if (!navigationContext.TryResolveNavigationAware(out var aware)) return;
+        var contextSnapshot = navigationContext;
+        WeakUnloadObserver.Subscribe(aware,async a =>
+        {
+            if (Current.HasValue)
+            {
+                if (ReferenceEquals(Current.Value.View.DataContext, a))
+                    _current = null;
+            }
+
+            await _regionPresenter.ProcessDeactivateAsync(contextSnapshot);
+        });
+    }
+
     private static Task<bool> HandleIsNavigationTargetAsync(IView view, NavigationContext navigationContext)
     {
         navigationContext.CancellationToken.ThrowIfCancellationRequested();
diff --git a/src/AsyncNavigation/ViewManager.cs b/src/AsyncNavigation/ViewManager.cs
index 875abf4..ebe2306 100644
--- a/src/AsyncNavigation/ViewManager.cs
+++ b/src/AsyncNavigation/ViewManager.cs
@@ -5,7 +5,7 @@
 
 namespace AsyncNavigation;
 
-internal sealed class ViewManager : IViewManager
+internal sealed class ViewManager : IViewManager, IViewPlacementCache
 {
     private readonly ConcurrentDictionary<string, WeakReference<IView>> _viewCache = new();
     private readonly LinkedList<string> _lruList = [];
@@ -14,9 +14,11 @@ internal sealed class ViewManager : IViewManager
     private readonly ViewCacheStrategy _strategy;
     private readonly int _maxCacheSize;
     private readonly IViewFactory _viewFactory;
+    private readonly ViewPlacementCoordinator? _placement;
 
-    public ViewManager(NavigationOptions options, IViewFactory viewFactory)
+    public ViewManager(NavigationOptions options, IViewFactory viewFactory, ViewPlacementCoordinator? placement = null)
     {
+        _placement = placement;
         _strategy = options.ViewCacheStrategy;
 #pragma warning disable CS0618 // MaxCachedViews is obsolete but still used internally for view cache size
         _maxCacheSize = options.MaxCachedViews;
@@ -26,22 +28,24 @@ public ViewManager(NavigationOptions options, IViewFactory viewFactory)
 
     public void Clear()
     {
-        var values = _viewCache.Values.ToArray();
-        _viewCache.Clear();
-        lock (_lruLock)
+        foreach (var entry in _viewCache.ToArray())
         {
-            _lruList.Clear();
-            _lruIndex.Clear();
+            if (entry.Value.TryGetTarget(out var view) && _placement?.IsFloating(view) == true)
+                continue;
+            Remove(entry.Key, dispose: true);
         }
-
-        foreach (var viewRef in values)
+    }
+    public async Task<IView?> FindCachedViewAsync(string key, Func<IView, Task<bool>> isNavigationTarget)
+    {
+        if (_viewCache.TryGetValue(key, out var reference) &&
+            reference.TryGetTarget(out var view) && await isNavigationTarget(view))
         {
-            if (viewRef.TryGetTarget(out var view))
-            {
-                DisposeView(view);
-            }
+            Touch(key);
+            return view;
         }
+        return null;
     }
+
     public async Task<IView> ResolveViewAsync(string key,
         bool useCache,
         Func<IView, Task<bool>>? isNavigationTarget = null,
@@ -82,6 +86,8 @@ public async Task<IView> ResolveViewAsync(string key,
 
     public void Remove(string cacheKey, bool dispose = false)
     {
+        if (_viewCache.TryGetValue(cacheKey, out var pinned) &&
+            pinned.TryGetTarget(out var active) && _placement?.IsFloating(active) == true) return;
         if (_viewCache.TryRemove(cacheKey, out var viewRef))
         {
             lock (_lruLock)
@@ -100,6 +106,15 @@ public void Remove(string cacheKey, bool dispose = false)
         }
     }
 
+    public void RemoveInstance(IView view)
+    {
+        foreach (var entry in _viewCache)
+        {
+            if (entry.Value.TryGetTarget(out var cached) && ReferenceEquals(cached, view))
+                Remove(entry.Key);
+        }
+    }
+
     public void AddView(string cacheKey, IView view)
     {
         if (_strategy == ViewCacheStrategy.UpdateDuplicateKey)
@@ -118,7 +133,7 @@ public void AddView(string cacheKey, IView view)
             }
         }
 
-        TrimCache();
+        TrimCache(cacheKey);
     }
 
     private void AddToLru(string key)
@@ -136,19 +151,26 @@ private void AddToLru(string key)
 
     private void Touch(string key) => AddToLru(key);
 
-    private void TrimCache()
+    private void TrimCache(string protectedKey)
     {
         while (_viewCache.Count > _maxCacheSize)
         {
             string? oldestKey = null;
             lock (_lruLock)
             {
-                if (_lruList.Last != null)
+                var node = _lruList.Last;
+                while (node is not null)
                 {
-                    oldestKey = _lruList.Last.Value;
-                    _lruIndex.Remove(oldestKey);
-                    _lruList.RemoveLast();
+                    if (node.Value != protectedKey &&
+                        (!_viewCache.TryGetValue(node.Value, out var candidate) ||
+                         !candidate.TryGetTarget(out var view) || _placement?.IsFloating(view) != true))
+                        break;
+                    node = node.Previous;
                 }
+                if (node is null) break; // Active windows are pinned, even above the cache limit.
+                oldestKey = node.Value;
+                _lruIndex.Remove(oldestKey);
+                _lruList.Remove(node);
             }
 
             if (oldestKey != null && _viewCache.TryRemove(oldestKey, out var viewRef))
@@ -166,8 +188,9 @@ public void Dispose()
         Clear();
     }
 
-    private static void DisposeView(IView view)
+    private void DisposeView(IView view)
     {
+        if (_placement?.IsFloating(view) == true) return;
         SafeDispose(view, nameof(view));
         SafeDispose(view.DataContext, nameof(view.DataContext));
     }
diff --git a/src/AsyncNavigation/ViewPlacementCoordinator.cs b/src/AsyncNavigation/ViewPlacementCoordinator.cs
new file mode 100644
index 0000000..f771752
--- /dev/null
+++ b/src/AsyncNavigation/ViewPlacementCoordinator.cs
@@ -0,0 +1,41 @@
+using AsyncNavigation.Abstractions;
+using System.Collections.Concurrent;
+
+namespace AsyncNavigation;
+
+/// <summary>Coordinates navigation and window placement by region and view instance.</summary>
+public sealed class ViewPlacementCoordinator
+{
+    private readonly ConcurrentDictionary<string, SemaphoreSlim> _gates = new();
+    private readonly ConcurrentDictionary<IView, Func<CancellationToken, Task>> _floating = new(ReferenceEqualityComparer.Instance);
+
+    public async Task<IDisposable> EnterAsync(string regionName, CancellationToken cancellationToken = default)
+    {
+        var gate = _gates.GetOrAdd(regionName, _ => new SemaphoreSlim(1, 1));
+        await gate.WaitAsync(cancellationToken);
+        return new Lease(gate);
+    }
+
+    public bool IsFloating(IView view) => _floating.ContainsKey(view);
+
+    public void Register(IView view, Func<CancellationToken, Task> activate)
+    {
+        if (!_floating.TryAdd(view, activate))
+            throw new InvalidOperationException("The view instance is already floating.");
+    }
+
+    public void Unregister(IView view) => _floating.TryRemove(view, out _);
+
+    public async Task<bool> TryActivateAsync(IView view, CancellationToken cancellationToken)
+    {
+        if (!_floating.TryGetValue(view, out var activate)) return false;
+        await activate(cancellationToken);
+        return true;
+    }
+
+    private sealed class Lease(SemaphoreSlim gate) : IDisposable
+    {
+        private SemaphoreSlim? _gate = gate;
+        public void Dispose() => Interlocked.Exchange(ref _gate, null)?.Release();
+    }
+}
diff --git a/tests/AsyncNavigation.E2E.Tests/App.axaml b/tests/AsyncNavigation.E2E.Tests/App.axaml
index c150098..d8633f0 100644
--- a/tests/AsyncNavigation.E2E.Tests/App.axaml
+++ b/tests/AsyncNavigation.E2E.Tests/App.axaml
@@ -2,5 +2,6 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              x:Class="AsyncNavigation.E2E.Tests.App">
 	<Application.Styles>
+        <FluentTheme />
 	</Application.Styles>
 </Application>
\ No newline at end of file
diff --git a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
index a4e3168..91d2dbe 100644
--- a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
+++ b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
@@ -11,8 +11,10 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Avalonia.Themes.Fluent" Version="12.0.0" />
     <PackageReference Include="Avalonia.Headless.XUnit" Version="12.0.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.6" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
     <PackageReference Include="xunit.v3" Version="3.2.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingNavigationTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingNavigationTests.cs
new file mode 100644
index 0000000..48c6ab6
--- /dev/null
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingNavigationTests.cs
@@ -0,0 +1,113 @@
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection;
+using AsyncNavigation.Avalonia.Floating;
+using Avalonia.Controls;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+using ControlType = Avalonia.Controls.Control;
+using PlatformContentRegion = AsyncNavigation.Avalonia.ContentRegion;
+using PlatformTabRegion = AsyncNavigation.Avalonia.TabRegion;
+namespace AsyncNavigation.E2E.Tests;
+
+public sealed class FloatingNavigationTests
+{
+    [AvaloniaTheory]
+    [InlineData(false, false)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(true, true)]
+    public Task Floating_navigation_and_docking_preserve_instance_ownership(bool createNew, bool tabs) =>
+        VerifyNavigationAndDock(createNew, tabs);
+    private static async Task VerifyNavigationAndDock(bool createNew, bool tabs)
+    {
+        var services = new ServiceCollection().AddNavigationSupport().AddFloatingSupportCore();
+        services.RegisterView<TestView, Model>("A");
+        services.RegisterView<TestView, Model>("B");
+        services.AddSingleton<IFloatingWindowHostFactory, WindowFactory>();
+        using var provider = services.BuildServiceProvider();
+        var manager = provider.GetRequiredService<IRegionManager>();
+        var placement = provider.GetRequiredService<IViewPlacementService>();
+        var control = tabs ? (ControlType)new TabControl() : new ContentControl();
+        IRegion region = tabs
+            ? new PlatformTabRegion("main", (TabControl)control, provider, true)
+            : new PlatformContentRegion("main", (ContentControl)control, provider, true);
+        manager.AddRegion("main", region);
+        var window = new Window { Content = control, Width = 500, Height = 400 };
+        window.Show();
+        try
+        {
+            var first = await manager.RequestNavigateAsync("main", "A");
+            Assert.True(first.IsSuccessful, first.Exception?.ToString());
+            var a1 = (TestView)first.NavigationContext!.Target.Value!;
+            var session = await placement.FloatAsync("main");
+            var floatingWindow = TopLevel.GetTopLevel(a1) as Window;
+            Assert.NotNull(floatingWindow);
+            Assert.NotSame(window, floatingWindow);
+            var next = await manager.RequestNavigateAsync("main", "B");
+            Assert.True(next.IsSuccessful, next.Exception?.ToString());
+            var b = next.NavigationContext!.Target.Value;
+            var selected = ((IRegionPlacementParticipant)region).Capture().Context;
+
+            if (createNew)
+            {
+                ((Model)a1.DataContext!).Reuse = false;
+                var newA = await manager.RequestNavigateAsync("main", "A");
+                Assert.True(newA.IsSuccessful, newA.Exception?.ToString());
+                Assert.NotSame(a1, newA.NavigationContext!.Target.Value);
+            }
+            else
+            {
+                var reused = await manager.RequestNavigateAsync("main", "A");
+                Assert.True(reused.IsSuccessful, reused.Exception?.ToString());
+                Assert.Same(a1, reused.NavigationContext!.Target.Value);
+                Assert.Same(selected, ((IRegionPlacementParticipant)region).Capture().Context);
+                Assert.Same(floatingWindow, TopLevel.GetTopLevel(a1) as Window);
+            }
+
+            await session.RestoreAsync();
+            Dispatcher.UIThread.RunJobs();
+            Assert.Equal(ViewPlacementState.Restored, session.State);
+            Assert.False(floatingWindow!.IsVisible);
+            Assert.Same(a1, ((IRegionPlacementParticipant)region).Capture().Context.Target.Value);
+            Assert.Same(window, TopLevel.GetTopLevel(a1) as Window);
+            Assert.Equal(1, ((Model)a1.DataContext!).Initializations);
+            if (tabs)
+                Assert.Equal(createNew ? 3 : 2, ((TabControl)control).Items.Count);
+            else
+            {
+                var back = await manager.GoBackAsync("main");
+                Assert.True(back.IsSuccessful, back.Exception?.ToString());
+                Assert.NotSame(a1, ((IRegionPlacementParticipant)region).Capture().Context.Target.Value);
+            }
+        }
+        finally
+        {
+            foreach (var session in placement.FloatingViews.ToArray()) await session.CloseAsync();
+            window.Close();
+        }
+    }
+
+    public sealed class TestView : UserControl, IView
+    {
+        public TestView() => Content = new TextBox { Text = "state survives docking" };
+    }
+
+    public sealed class Model : INavigationAware
+    {
+        public bool Reuse { get; set; } = true;
+        public int Initializations { get; private set; }
+        public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+        public Task InitializeAsync(NavigationContext context) { Initializations++; return Task.CompletedTask; }
+        public Task OnNavigatedToAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+        public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(Reuse);
+        public Task OnUnloadAsync(CancellationToken token) => Task.CompletedTask;
+    }
+
+    private sealed class WindowFactory : IFloatingWindowHostFactory
+    {
+        public IFloatingWindowHost Create(FloatingWindowOptions options) => new AvaloniaFloatingWindowHost(options);
+    }
+}
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs
index 2126376..29c7c25 100644
--- a/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingWindowLifecycleTests.cs
@@ -8,11 +8,14 @@ namespace AsyncNavigation.E2E.Tests;
 
 public sealed class FloatingWindowLifecycleTests
 {
-    [AvaloniaFact]
-    public void User_close_restores_content_and_then_closes_the_window()
+    [AvaloniaTheory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Dock_and_close_raise_separate_requests(bool dock)
     {
         var content = new Border();
-        var restoredContent = new ContentControl();
+        var restoreRequested = false;
+        var closeRequested = false;
         var host = new AvaloniaFloatingWindowHost(new FloatingWindowOptions
         {
             Title = "Floating lifecycle test",
@@ -25,18 +28,30 @@ public void User_close_restores_content_and_then_closes_the_window()
         var window = TopLevel.GetTopLevel(content) as Window
             ?? throw new InvalidOperationException("The floating window was not created.");
 
-        host.RestoreRequested += async (_, _) =>
+        host.RestoreRequested += (_, _) => restoreRequested = true;
+        host.CloseRequested += async (_, _) =>
         {
+            closeRequested = true;
             await host.SetContentAsync(null);
-            restoredContent.Content = content;
             await host.CloseAsync();
             await host.DisposeAsync();
         };
 
-        window.Close();
+        if (dock)
+        {
+            var panel = (DockPanel)window.Content!;
+            var button = (Button)panel.Children[0];
+            button.RaiseEvent(new global::Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+        }
+        else
+        {
+            window.Close();
+        }
         Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
 
-        Assert.Same(content, restoredContent.Content);
-        Assert.False(window.IsVisible);
+        Assert.Equal(dock, restoreRequested);
+        Assert.Equal(!dock, closeRequested);
+        Assert.Equal(dock, window.IsVisible);
+        host.DisposeAsync().AsTask().GetAwaiter().GetResult();
     }
 }
diff --git a/tests/AsyncNavigation.Tests/FloatingNavigationTests.cs b/tests/AsyncNavigation.Tests/FloatingNavigationTests.cs
new file mode 100644
index 0000000..11f9d2d
--- /dev/null
+++ b/tests/AsyncNavigation.Tests/FloatingNavigationTests.cs
@@ -0,0 +1,341 @@
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+
+namespace AsyncNavigation.Tests;
+
+public sealed class FloatingNavigationTests
+{
+    [Fact]
+    public async Task NavigateToFloatingInstance_ActivatesWindowWithoutLeavingCurrentView()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        b.Model.AllowLeave = false;
+        var selected = f.Region.Selected;
+        var historyCount = f.History.History.Count;
+
+        var reused = await f.Navigate("A");
+
+        Assert.Same(a, reused);
+        Assert.Same(selected, f.Region.Selected);
+        Assert.Same(b, f.Indicator.Content);
+        Assert.Same(a, f.Windows[0].Content);
+        Assert.Equal(1, f.Windows[0].Activations);
+        Assert.Equal(0, b.Model.FromCount);
+        Assert.Equal(historyCount, f.History.History.Count);
+        Assert.Equal(ViewPlacementState.Floating, session.State);
+    }
+
+    [Theory]
+    [InlineData("B")]
+    [InlineData("A")]
+    public async Task DockIntoOccupiedRegion_ReusesOriginalAndUpdatesCurrentAndHistory(string next)
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        a.Model.Reuse = false;
+        var other = await f.Navigate(next);
+
+        await session.RestoreAsync();
+
+        Assert.NotSame(a, other);
+        Assert.Same(a, f.Indicator.Content);
+        Assert.Same(a, f.Region.Selected!.Target.Value);
+        Assert.Same(f.Region.Selected, f.History.Current);
+        Assert.Equal(1, other.Model.FromCount);
+        Assert.Equal(1, a.Model.InitializeCount);
+        Assert.Equal(2, a.Model.ToCount);
+        Assert.True(f.Windows[0].Closed);
+        Assert.Empty(f.Placement.FloatingViews);
+        await ((IRegion)f.Region).GoBackAsync();
+        Assert.Same(other, f.Indicator.Content);
+        Assert.Equal(1, a.Model.FromCount);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task FailedDock_PreservesBothViewsAndCanBeRetried(bool failAttach)
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        var before = f.History.Current;
+        b.Model.AllowLeave = failAttach;
+        f.Region.FailNextAttach = failAttach;
+
+        await Assert.ThrowsAnyAsync<Exception>(() => session.RestoreAsync());
+
+        Assert.Same(b, f.Indicator.Content);
+        Assert.Same(b, f.Region.Selected!.Target.Value);
+        Assert.Same(a, f.Windows[0].Content);
+        Assert.Same(before, f.History.Current);
+        Assert.False(f.Windows[0].Closed);
+        Assert.Equal(ViewPlacementState.Floating, session.State);
+        b.Model.AllowLeave = true;
+        await session.RestoreAsync();
+        Assert.Same(a, f.Indicator.Content);
+    }
+
+    [Fact]
+    public async Task CloseOldInstance_DoesNotRemoveNewInstanceCacheOrHistory()
+    {
+        using var f = new Fixture();
+        var a1 = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        a1.Model.Reuse = false;
+        var a2 = await f.Navigate("A");
+
+        await session.CloseAsync();
+        var reused = await f.Navigate("A");
+
+        Assert.True(a1.Disposed);
+        Assert.False(a2.Disposed);
+        Assert.Same(a2, reused);
+        Assert.Same(a2, f.Indicator.Content);
+        Assert.DoesNotContain(f.History.History, c => ReferenceEquals(c.Target.Value, a1));
+    }
+
+    [Fact]
+    public async Task BackToFloatingView_ActivatesWindowAndKeepsHistoryPosition()
+    {
+        using var f = new Fixture();
+        await f.Navigate("A");
+        await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        var current = f.History.Current;
+
+        await ((IRegion)f.Region).GoBackAsync();
+
+        Assert.Same(b, f.Indicator.Content);
+        Assert.Same(current, f.History.Current);
+        Assert.Equal(1, f.Windows[0].Activations);
+    }
+
+    [Fact]
+    public async Task CacheClear_DoesNotDisposeFloatingView()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        await f.Placement.FloatAsync("main");
+        f.Cache.Clear();
+        Assert.False(a.Disposed);
+        Assert.Same(a, await f.Navigate("A"));
+    }
+
+    [Fact]
+    public async Task NavigationWaitsForDockTransaction()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        var guard = new TaskCompletionSource<bool>();
+        b.Model.GuardTask = guard.Task;
+        var dock = session.RestoreAsync();
+        var navigate = f.Navigate("C");
+        Assert.False(dock.IsCompleted);
+        Assert.False(navigate.IsCompleted);
+        guard.SetResult(true);
+        await dock;
+        var c = await navigate;
+        Assert.Same(c, f.Indicator.Content);
+        Assert.Equal(1, a.Model.FromCount);
+    }
+
+    [Fact]
+    public async Task NavigationCanStillCancelCurrentWhileFloatingEnabled()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        a.Model.GuardTask = new TaskCompletionSource<bool>().Task;
+        var pending = f.Navigate("B");
+        Assert.False(pending.IsCompleted);
+        a.Model.GuardTask = null;
+        var replacement = f.Navigate("C");
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => pending);
+        var c = await replacement;
+        Assert.Same(c, f.Indicator.Content);
+    }
+
+    [Fact]
+    public async Task CacheEviction_PinsFloatingViewAndDoesNotDisposeNewView()
+    {
+        using var f = new Fixture(maxCacheSize: 1);
+        var a = await f.Navigate("A");
+        await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        Assert.False(a.Disposed);
+        Assert.False(b.Disposed);
+        Assert.Same(a, await f.Navigate("A"));
+    }
+
+    [Fact]
+    public async Task CancelledDock_PreservesRegionAndFloatingWindow()
+    {
+        using var f = new Fixture();
+        var a = await f.Navigate("A");
+        var session = await f.Placement.FloatAsync("main");
+        var b = await f.Navigate("B");
+        b.Model.GuardTask = new TaskCompletionSource<bool>().Task;
+        using var cancellation = new CancellationTokenSource();
+        var dock = session.RestoreAsync(cancellation.Token);
+        cancellation.Cancel();
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => dock);
+        Assert.Same(b, f.Indicator.Content);
+        Assert.Same(a, f.Windows[0].Content);
+        Assert.Equal(ViewPlacementState.Floating, session.State);
+    }
+
+    private sealed class Fixture : IDisposable
+    {
+        private readonly ServiceProvider _provider;
+        public Fixture(int maxCacheSize = 20)
+        {
+            var manager = new Mock<IRegionManager>();
+            var windows = new Mock<IFloatingWindowHostFactory>();
+            windows.Setup(x => x.Create(It.IsAny<FloatingWindowOptions>())).Returns(() =>
+            {
+                var window = new WindowHost();
+                Windows.Add(window);
+                return window;
+            });
+            var services = new ServiceCollection()
+                .AddSingleton(new NavigationOptions { ViewCacheStrategy = ViewCacheStrategy.UpdateDuplicateKey, MaxCachedViews = maxCacheSize })
+                .AddSingleton<IViewFactory, ViewFactory>()
+                .AddSingleton<IRegionManager>(manager.Object)
+                .AddSingleton<IFloatingWindowHostFactory>(windows.Object)
+                .AddSingleton<IViewManager, ViewManager>()
+                .AddSingleton<IRegionNavigationHistory, RegionNavigationHistory>()
+                .AddSingleton<IRegionNavigationServiceFactory, RegionNavigationServiceFactory>()
+                .AddTransient<IAsyncJobProcessor, AsyncJobProcessor>()
+                .AddTransient<IRegionIndicatorManager, RegionIndicatorManager>()
+                .AddSingleton<IInnerRegionIndicatorHost>(Indicator)
+                .AddFloatingSupportCore();
+            _provider = services.BuildServiceProvider();
+            Region = new ContentRegion(_provider);
+            IRegion? region = Region;
+            manager.Setup(x => x.TryGetRegion("main", out region)).Returns(true);
+            Placement = _provider.GetRequiredService<IViewPlacementService>();
+            History = _provider.GetRequiredService<IRegionNavigationHistory>();
+            Cache = _provider.GetRequiredService<IViewManager>();
+        }
+        public ContentRegion Region { get; }
+        public IndicatorHost Indicator { get; } = new();
+        public List<WindowHost> Windows { get; } = [];
+        public IViewPlacementService Placement { get; }
+        public IRegionNavigationHistory History { get; }
+        public IViewManager Cache { get; }
+        public async Task<View> Navigate(string name)
+        {
+            var context = new NavigationContext { RegionName = "main", ViewName = name };
+            await ((IRegion)Region).ActivateViewAsync(context);
+            return (View)context.Target.Value!;
+        }
+        public void Dispose() => _provider.Dispose();
+    }
+
+    private sealed class ContentRegion(IServiceProvider provider)
+        : RegionBase<ContentRegion, object>("main", new object(), provider), IRegionPlacementParticipant
+    {
+        public NavigationContext? Selected { get; private set; }
+        public bool FailNextAttach { get; set; }
+        public override NavigationPipelineMode NavigationPipelineMode => NavigationPipelineMode.RenderFirst;
+        protected override void InitializeOnRegionCreated(object control)
+        {
+            EnableViewCache = true;
+            IsSinglePageRegion = true;
+        }
+        public override Task ProcessActivateAsync(NavigationContext context)
+        {
+            Selected = context;
+            return Task.CompletedTask;
+        }
+        public override Task ProcessDeactivateAsync(NavigationContext? context)
+        {
+            if (context is null || ReferenceEquals(Selected, context)) Selected = null;
+            return Task.CompletedTask;
+        }
+        public RegionPlacementItem Capture(Guid? id = null) =>
+            new(Selected ?? throw new InvalidOperationException("empty"), 0, true);
+        public void Detach(RegionPlacementItem item)
+        {
+            Assert.Same(Selected, item.Context);
+            Selected = null;
+        }
+        public void Attach(RegionPlacementItem item, bool activate = true)
+        {
+            if (FailNextAttach)
+            {
+                FailNextAttach = false;
+                throw new InvalidOperationException("attach failed");
+            }
+            Assert.Null(Selected);
+            Selected = item.Context;
+        }
+    }
+
+    private sealed class ViewFactory : IViewFactory
+    {
+        public IView CreateView(string key) => new View();
+        public bool CanCreateView(string key) => true;
+        public void AddView(string key, IView view) => throw new NotSupportedException();
+        public void AddView(string key, Func<string, IView> factory) => throw new NotSupportedException();
+    }
+
+    private sealed class View : IView, IDisposable
+    {
+        public Model Model { get; } = new();
+        public object? DataContext { get => Model; set => throw new NotSupportedException(); }
+        public bool Disposed { get; private set; }
+        public void Dispose() => Disposed = true;
+    }
+    private sealed class Model : INavigationAware, INavigationGuard
+    {
+        public bool AllowLeave { get; set; } = true;
+        public bool Reuse { get; set; } = true;
+        public int InitializeCount { get; private set; }
+        public int ToCount { get; private set; }
+        public int FromCount { get; private set; }
+        public Task<bool>? GuardTask { get; set; }
+        public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+        public Task InitializeAsync(NavigationContext context) { InitializeCount++; return Task.CompletedTask; }
+        public Task OnNavigatedToAsync(NavigationContext context) { ToCount++; return Task.CompletedTask; }
+        public Task OnNavigatedFromAsync(NavigationContext context) { FromCount++; return Task.CompletedTask; }
+        public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(Reuse);
+        public Task OnUnloadAsync(CancellationToken token) => Task.CompletedTask;
+        public Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken token) => GuardTask?.WaitAsync(token) ?? Task.FromResult(AllowLeave);
+    }
+    private sealed class IndicatorHost : IInnerRegionIndicatorHost, IRegionPlacementContentHost
+    {
+        public object Host => this;
+        public object? Content { get; private set; }
+        public object DetachContent() { var content = Content ?? throw new InvalidOperationException("empty"); Content = null; return content; }
+        public void AttachContent(object content) { Assert.Null(Content); Content = content; }
+        public Task ShowContentAsync(NavigationContext context) { Content = context.Target.Value; return Task.CompletedTask; }
+        public Task ShowErrorAsync(NavigationContext context, Exception? exception) => Task.CompletedTask;
+        public Task ShowLoadingAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnLoadedAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnCancelledAsync(NavigationContext context) => Task.CompletedTask;
+    }
+    private sealed class WindowHost : IFloatingWindowHost
+    {
+        public event EventHandler? RestoreRequested;
+        public event EventHandler? CloseRequested;
+        public object? Content { get; private set; }
+        public bool Closed { get; private set; }
+        public int Activations { get; private set; }
+        public Task SetContentAsync(object? content, CancellationToken token = default) { Content = content; return Task.CompletedTask; }
+        public Task ShowAsync(CancellationToken token = default) => Task.CompletedTask;
+        public Task ActivateAsync(CancellationToken token = default) { Activations++; return Task.CompletedTask; }
+        public Task CloseAsync(CancellationToken token = default) { Closed = true; return Task.CompletedTask; }
+        public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+    }
+}
diff --git a/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs b/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
index d244b94..ddc7086 100644
--- a/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
+++ b/tests/AsyncNavigation.Tests/ViewPlacementServiceTests.cs
@@ -62,6 +62,41 @@ await Assert.ThrowsAsync<InvalidOperationException>(() =>
         Assert.True(fixture.Window.WasDisposed);
     }
 
+    [Fact]
+    public async Task UserClose_RemovesSessionWithoutRestoringContent()
+    {
+        var fixture = new Fixture();
+        var session = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+
+        fixture.Window.RequestClose();
+        await session.CloseAsync();
+        await session.RestoreAsync();
+
+        Assert.Equal(ViewPlacementState.Closed, session.State);
+        Assert.Equal(0, fixture.Region.AttachCount);
+        Assert.Null(fixture.Window.Content);
+        Assert.Null(fixture.Indicator.Content);
+        Assert.True(fixture.Window.WasClosed);
+        Assert.True(fixture.Window.WasDisposed);
+        Assert.Empty(fixture.Service.FloatingViews);
+        Assert.False(fixture.Service.TryGetSession(session.Id, out _));
+    }
+
+    [Fact]
+    public async Task DockRequest_RestoresContentWithoutClosingSessionAsClosed()
+    {
+        var fixture = new Fixture();
+        var session = await fixture.Service.FloatAsync("main", fixture.Context.NavigationId);
+
+        fixture.Window.RequestRestore();
+        await session.RestoreAsync();
+        await session.CloseAsync();
+
+        Assert.Equal(ViewPlacementState.Restored, session.State);
+        Assert.Equal(1, fixture.Region.AttachCount);
+        Assert.Same(fixture.RenderedView, fixture.Indicator.Content);
+    }
+
     private sealed class Fixture
     {
         public Fixture()
@@ -70,6 +105,7 @@ public Fixture()
             Context = new NavigationContext { RegionName = "main", ViewName = "editor" };
             Indicator = new FakeIndicatorHost(RenderedView);
             Context.IndicatorHost.Value = Indicator;
+            Context.Target.Value = RenderedView;
             Item = new RegionPlacementItem(Context, 2, true);
 
             Region = new FakeRegion(Item);
@@ -99,8 +135,9 @@ public Fixture()
         public IViewPlacementService Service { get; }
     }
 
-    private sealed class StatefulRenderedView
+    private sealed class StatefulRenderedView : IView
     {
+        public object? DataContext { get; set; }
         public string? Selection { get; set; }
     }
 
@@ -167,6 +204,8 @@ public void Dispose() { }
     private sealed class FakeWindowHost : IFloatingWindowHost
     {
         public event EventHandler? RestoreRequested;
+        public event EventHandler? CloseRequested;
+        public void RequestClose() => CloseRequested?.Invoke(this, EventArgs.Empty);
         public object? Content { get; private set; }
         public bool WasShown { get; private set; }
         public bool WasClosed { get; private set; }
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj b/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
index e199f70..98b8728 100644
--- a/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/AsyncNavigation.Wpf.E2E.Tests.csproj
@@ -10,6 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.6" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
     <PackageReference Include="xunit.v3" Version="3.2.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingNavigationTests.cs b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingNavigationTests.cs
new file mode 100644
index 0000000..efd13b6
--- /dev/null
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingNavigationTests.cs
@@ -0,0 +1,136 @@
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
+using Microsoft.Extensions.DependencyInjection;
+using AsyncNavigation.Wpf.Floating;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Threading;
+using System.Runtime.ExceptionServices;
+using ControlType = System.Windows.Controls.Control;
+using PlatformContentRegion = AsyncNavigation.Wpf.ContentRegion;
+using PlatformTabRegion = AsyncNavigation.Wpf.TabRegion;
+namespace AsyncNavigation.Wpf.E2E.Tests;
+
+public sealed class FloatingNavigationTests
+{
+    [Theory]
+    [InlineData(false, false)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(true, true)]
+    public void Floating_navigation_and_docking_preserve_instance_ownership(bool createNew, bool tabs) =>
+        RunOnSta(() => VerifyNavigationAndDock(createNew, tabs));
+    private static async Task VerifyNavigationAndDock(bool createNew, bool tabs)
+    {
+        var services = new ServiceCollection().AddNavigationSupport().AddFloatingSupportCore();
+        services.RegisterView<TestView, Model>("A");
+        services.RegisterView<TestView, Model>("B");
+        services.AddSingleton<IFloatingWindowHostFactory, WindowFactory>();
+        using var provider = services.BuildServiceProvider();
+        var manager = provider.GetRequiredService<IRegionManager>();
+        var placement = provider.GetRequiredService<IViewPlacementService>();
+        var control = tabs ? (ControlType)new TabControl() : new ContentControl();
+        IRegion region = tabs
+            ? new PlatformTabRegion("main", (TabControl)control, provider, true)
+            : new PlatformContentRegion("main", (ContentControl)control, provider, true);
+        manager.AddRegion("main", region);
+        var window = new Window { Content = control, Width = 500, Height = 400 };
+        window.Show();
+        try
+        {
+            var first = await manager.RequestNavigateAsync("main", "A");
+            Assert.True(first.IsSuccessful, first.Exception?.ToString());
+            var a1 = (TestView)first.NavigationContext!.Target.Value!;
+            var session = await placement.FloatAsync("main");
+            var floatingWindow = Window.GetWindow(a1);
+            Assert.NotNull(floatingWindow);
+            Assert.NotSame(window, floatingWindow);
+            var next = await manager.RequestNavigateAsync("main", "B");
+            Assert.True(next.IsSuccessful, next.Exception?.ToString());
+            var b = next.NavigationContext!.Target.Value;
+            var selected = ((IRegionPlacementParticipant)region).Capture().Context;
+
+            if (createNew)
+            {
+                ((Model)a1.DataContext!).Reuse = false;
+                var newA = await manager.RequestNavigateAsync("main", "A");
+                Assert.True(newA.IsSuccessful, newA.Exception?.ToString());
+                Assert.NotSame(a1, newA.NavigationContext!.Target.Value);
+            }
+            else
+            {
+                var reused = await manager.RequestNavigateAsync("main", "A");
+                Assert.True(reused.IsSuccessful, reused.Exception?.ToString());
+                Assert.Same(a1, reused.NavigationContext!.Target.Value);
+                Assert.Same(selected, ((IRegionPlacementParticipant)region).Capture().Context);
+                Assert.Same(floatingWindow, Window.GetWindow(a1));
+            }
+
+            await session.RestoreAsync();
+            Dispatcher.CurrentDispatcher.Invoke(static () => { }, DispatcherPriority.ApplicationIdle);
+            Assert.Equal(ViewPlacementState.Restored, session.State);
+            Assert.False(floatingWindow!.IsVisible);
+            Assert.Same(a1, ((IRegionPlacementParticipant)region).Capture().Context.Target.Value);
+            Assert.Same(window, Window.GetWindow(a1));
+            Assert.Equal(1, ((Model)a1.DataContext!).Initializations);
+            if (tabs)
+                Assert.Equal(createNew ? 3 : 2, ((TabControl)control).Items.Count);
+            else
+            {
+                var back = await manager.GoBackAsync("main");
+                Assert.True(back.IsSuccessful, back.Exception?.ToString());
+                Assert.NotSame(a1, ((IRegionPlacementParticipant)region).Capture().Context.Target.Value);
+            }
+        }
+        finally
+        {
+            foreach (var session in placement.FloatingViews.ToArray()) await session.CloseAsync();
+            window.Close();
+        }
+    }
+
+    public sealed class TestView : UserControl, IView
+    {
+        public TestView() => Content = new TextBox { Text = "state survives docking" };
+    }
+
+    public sealed class Model : INavigationAware
+    {
+        public bool Reuse { get; set; } = true;
+        public int Initializations { get; private set; }
+        public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+        public Task InitializeAsync(NavigationContext context) { Initializations++; return Task.CompletedTask; }
+        public Task OnNavigatedToAsync(NavigationContext context) => Task.CompletedTask;
+        public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+        public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(Reuse);
+        public Task OnUnloadAsync(CancellationToken token) => Task.CompletedTask;
+    }
+
+    private sealed class WindowFactory : IFloatingWindowHostFactory
+    {
+        public IFloatingWindowHost Create(FloatingWindowOptions options) => new WpfFloatingWindowHost(options);
+    }
+    private static void RunOnSta(Func<Task> action)
+    {
+        Exception? failure = null;
+        var thread = new Thread(() =>
+        {
+            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext());
+            var frame = new DispatcherFrame();
+            async void Run()
+            {
+                try { await action(); }
+                catch (Exception ex) { failure = ex; }
+                finally { frame.Continue = false; }
+            }
+            Dispatcher.CurrentDispatcher.BeginInvoke((Action)Run);
+            Dispatcher.PushFrame(frame);
+            Dispatcher.CurrentDispatcher.InvokeShutdown();
+        });
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+        if (failure is not null) ExceptionDispatchInfo.Capture(failure).Throw();
+    }
+}
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs
index 54c3f63..994fc29 100644
--- a/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/FloatingWindowLifecycleTests.cs
@@ -9,13 +9,16 @@ namespace AsyncNavigation.Wpf.E2E.Tests;
 
 public sealed class FloatingWindowLifecycleTests
 {
-    [Fact]
-    public void User_close_restores_content_and_then_closes_the_window()
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Dock_and_close_raise_separate_requests(bool dock)
     {
         RunOnStaThread(() =>
         {
             var content = new Border();
-            var restoredContent = new ContentControl();
+            var restoreRequested = false;
+            var closeRequested = false;
             var host = new WpfFloatingWindowHost(new FloatingWindowOptions
             {
                 Title = "Floating lifecycle test",
@@ -28,19 +31,31 @@ public void User_close_restores_content_and_then_closes_the_window()
             var window = Window.GetWindow(content)
                 ?? throw new InvalidOperationException("The floating window was not created.");
 
-            host.RestoreRequested += async (_, _) =>
+            host.RestoreRequested += (_, _) => restoreRequested = true;
+            host.CloseRequested += async (_, _) =>
             {
+                closeRequested = true;
                 await host.SetContentAsync(null);
-                restoredContent.Content = content;
                 await host.CloseAsync();
                 await host.DisposeAsync();
             };
 
-            window.Close();
+            if (dock)
+            {
+                var panel = (DockPanel)window.Content!;
+                var button = (Button)panel.Children[0];
+                button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
+            }
+            else
+            {
+                window.Close();
+            }
             FlushDispatcher();
 
-            Assert.Same(content, restoredContent.Content);
-            Assert.False(window.IsVisible);
+            Assert.Equal(dock, restoreRequested);
+            Assert.Equal(!dock, closeRequested);
+            Assert.Equal(dock, window.IsVisible);
+            host.DisposeAsync().AsTask().GetAwaiter().GetResult();
         });
     }
 
diff --git a/tests/AsyncNavigation.Wpf.E2E.Tests/README.md b/tests/AsyncNavigation.Wpf.E2E.Tests/README.md
index 7b4795f..af7f5de 100644
--- a/tests/AsyncNavigation.Wpf.E2E.Tests/README.md
+++ b/tests/AsyncNavigation.Wpf.E2E.Tests/README.md
@@ -16,7 +16,15 @@ check the generated `DatePicker` instance and its date before floating, while
 floating, and after restoration. Both unbound UI state and TwoWay-bound MVVM
 state are covered.
 
-The lifecycle regression test also closes a floating window through its normal
-close button path and verifies that its content is restored and the now-empty
-window actually closes. This protects against re-entering `Window.Close()` from
+The lifecycle regression tests verify that the Dock to region button requests
+restoration, while the normal window close button requests closure without
+restoring content. Closure is deferred to avoid re-entering `Window.Close()`
 inside WPF's synchronous `Closing` event.
+
+The navigation integration tests exercise both ContentRegion and TabRegion with
+real views and windows. They verify that navigating to a cached floating instance
+activates its existing window, while a new instance can open in the main region.
+Docking into an occupied content region switches to the original instance and
+keeps the previous view available through Back. Docking into a tab region keeps
+other tabs and selects the restored tab. Equivalent tests run in the Avalonia
+headless suite with Fluent templates.

From fcd5fb53542163882f96a90703e0e69caf1ddcff Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 29 Sep 2026 11:41:06 +0200
Subject: [PATCH 08/14] docs: replace obsolete NavigationAwareBase examples

---
 readme.md                                     | 43 +++++++++++++++----
 readme_zh-cn.md                               | 43 +++++++++++++++----
 .../Abstractions/INavigationGuard.cs          | 12 +++---
 3 files changed, 76 insertions(+), 22 deletions(-)

diff --git a/readme.md b/readme.md
index 63d6e23..679c315 100644
--- a/readme.md
+++ b/readme.md
@@ -94,14 +94,32 @@ var result = await _dialogService.ShowViewDialogAsync("Confirm");
 
 ### 4. React to navigation in view models
 
+View models implement `INavigationAware` directly. The library does not provide a navigation base class; you can define one in your application to share default implementations.
+
 ```csharp
-// Derive from NavigationAwareBase and override only what you need.
-public class HomeViewModel : NavigationAwareBase
+using AsyncNavigation;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using System.Threading;
+using System.Threading.Tasks;
+
+public class HomeViewModel : INavigationAware
 {
-    public override async Task OnNavigatedToAsync(NavigationContext context)
+    public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+
+    public Task InitializeAsync(NavigationContext context) => Task.CompletedTask;
+
+    public Task OnNavigatedToAsync(NavigationContext context)
     {
-        await LoadDataAsync(context.CancellationToken);
+        // Load page data here; use context.CancellationToken for async operations.
+        return Task.CompletedTask;
     }
+
+    public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnUnloadAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+    // Allow reuse when caching is enabled; return false to request a new instance.
+    public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(true);
 }
 ```
 
@@ -110,12 +128,21 @@ public class HomeViewModel : NavigationAwareBase
 ## Navigation Guard
 
 ```csharp
-public class EditViewModel : NavigationAwareBase, INavigationGuard
+public class EditViewModel : INavigationAware, INavigationGuard
 {
-    public async Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken ct)
+    public bool HasUnsavedChanges { get; set; }
+    public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+
+    public Task InitializeAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnNavigatedToAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnUnloadAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(true);
+
+    public Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken ct)
     {
-        // Return false to cancel — show a confirmation dialog here if needed.
-        return !HasUnsavedChanges;
+        // Return false to cancel; show a confirmation dialog asynchronously here if needed.
+        return Task.FromResult(!HasUnsavedChanges);
     }
 }
 ```
diff --git a/readme_zh-cn.md b/readme_zh-cn.md
index 90be970..f3877ef 100644
--- a/readme_zh-cn.md
+++ b/readme_zh-cn.md
@@ -94,14 +94,32 @@ var result = await _dialogService.ShowViewDialogAsync("Confirm");
 
 ### 4. 在视图模型中响应导航
 
+视图模型直接实现 `INavigationAware`。库不提供导航基类；如需复用默认实现，可以在应用中定义自己的基类。
+
 ```csharp
-// 继承 NavigationAwareBase，按需重写方法即可。
-public class HomeViewModel : NavigationAwareBase
+using AsyncNavigation;
+using AsyncNavigation.Abstractions;
+using AsyncNavigation.Core;
+using System.Threading;
+using System.Threading.Tasks;
+
+public class HomeViewModel : INavigationAware
 {
-    public override async Task OnNavigatedToAsync(NavigationContext context)
+    public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+
+    public Task InitializeAsync(NavigationContext context) => Task.CompletedTask;
+
+    public Task OnNavigatedToAsync(NavigationContext context)
     {
-        await LoadDataAsync(context.CancellationToken);
+        // 在此加载页面数据；异步操作可使用 context.CancellationToken。
+        return Task.CompletedTask;
     }
+
+    public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnUnloadAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+    // 启用缓存时，允许复用此实例；返回 false 可请求新实例。
+    public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(true);
 }
 ```
 
@@ -110,12 +128,21 @@ public class HomeViewModel : NavigationAwareBase
 ## 导航守卫
 
 ```csharp
-public class EditViewModel : NavigationAwareBase, INavigationGuard
+public class EditViewModel : INavigationAware, INavigationGuard
 {
-    public async Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken ct)
+    public bool HasUnsavedChanges { get; set; }
+    public event AsyncEventHandler<AsyncEventArgs>? AsyncRequestUnloadEvent;
+
+    public Task InitializeAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnNavigatedToAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnNavigatedFromAsync(NavigationContext context) => Task.CompletedTask;
+    public Task OnUnloadAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+    public Task<bool> IsNavigationTargetAsync(NavigationContext context) => Task.FromResult(true);
+
+    public Task<bool> CanNavigateAsync(NavigationContext context, CancellationToken ct)
     {
-        // 返回 false 可取消导航，通常在此弹出确认对话框
-        return !HasUnsavedChanges;
+        // 返回 false 可取消导航；如需确认，可在此异步显示对话框。
+        return Task.FromResult(!HasUnsavedChanges);
     }
 }
 ```
diff --git a/src/AsyncNavigation/Abstractions/INavigationGuard.cs b/src/AsyncNavigation/Abstractions/INavigationGuard.cs
index 4b8e14c..dd51c1d 100644
--- a/src/AsyncNavigation/Abstractions/INavigationGuard.cs
+++ b/src/AsyncNavigation/Abstractions/INavigationGuard.cs
@@ -6,14 +6,14 @@ namespace AsyncNavigation.Abstractions;
 /// navigations away from the current view (e.g., unsaved-changes confirmation).
 /// </summary>
 /// <example>
+/// Add the following members to a view model implementing both
+/// <see cref="INavigationAware"/> and <see cref="INavigationGuard"/>:
 /// <code>
-/// public class EditViewModel : NavigationAwareBase, INavigationGuard
+/// public bool HasUnsavedChanges { get; set; }
+///
+/// public Task&lt;bool&gt; CanNavigateAsync(NavigationContext context, CancellationToken ct)
 /// {
-///     public async Task&lt;bool&gt; CanNavigateAsync(NavigationContext context, CancellationToken ct)
-///     {
-///         if (!HasUnsavedChanges) return true;
-///         return await _dialogService.ConfirmAsync("Discard unsaved changes?", ct);
-///     }
+///     return Task.FromResult(!HasUnsavedChanges);
 /// }
 /// </code>
 /// </example>

From 58d3be6a80fd8ec6de6c53d1bd945cb1d95709f6 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 29 Sep 2026 11:57:14 +0200
Subject: [PATCH 09/14] fix: restore obsolete navigation base and clear cache
 before disposal

---
 readme.md                                     |  2 +-
 readme_zh-cn.md                               |  2 +-
 .../AsyncNavigation}/NavigationAwareBase.cs   |  6 ++-
 src/AsyncNavigation/ViewManager.cs            | 26 +++++++++---
 .../NavigationAwareBaseTests.cs               | 14 ++++++-
 .../ViewManagerExtendedTests.cs               | 40 ++++++++++++++++++-
 6 files changed, 79 insertions(+), 11 deletions(-)
 rename {tests/AsyncNavigation.Tests/Infrastructure => src/AsyncNavigation}/NavigationAwareBase.cs (90%)

diff --git a/readme.md b/readme.md
index 679c315..3adb397 100644
--- a/readme.md
+++ b/readme.md
@@ -94,7 +94,7 @@ var result = await _dialogService.ShowViewDialogAsync("Confirm");
 
 ### 4. React to navigation in view models
 
-View models implement `INavigationAware` directly. The library does not provide a navigation base class; you can define one in your application to share default implementations.
+View models implement `INavigationAware` directly. `NavigationAwareBase` remains available for compatibility but is obsolete; new code should implement `INavigationAware`. You can define an application base class to share default implementations.
 
 ```csharp
 using AsyncNavigation;
diff --git a/readme_zh-cn.md b/readme_zh-cn.md
index f3877ef..11ade05 100644
--- a/readme_zh-cn.md
+++ b/readme_zh-cn.md
@@ -94,7 +94,7 @@ var result = await _dialogService.ShowViewDialogAsync("Confirm");
 
 ### 4. 在视图模型中响应导航
 
-视图模型直接实现 `INavigationAware`。库不提供导航基类；如需复用默认实现，可以在应用中定义自己的基类。
+视图模型直接实现 `INavigationAware`。`NavigationAwareBase` 为兼容旧代码而保留，但已标记弃用，建议新代码实现 `INavigationAware`。如需复用默认实现，可以在应用中定义自己的基类。
 
 ```csharp
 using AsyncNavigation;
diff --git a/tests/AsyncNavigation.Tests/Infrastructure/NavigationAwareBase.cs b/src/AsyncNavigation/NavigationAwareBase.cs
similarity index 90%
rename from tests/AsyncNavigation.Tests/Infrastructure/NavigationAwareBase.cs
rename to src/AsyncNavigation/NavigationAwareBase.cs
index fa9878e..ed6d6ef 100644
--- a/tests/AsyncNavigation.Tests/Infrastructure/NavigationAwareBase.cs
+++ b/src/AsyncNavigation/NavigationAwareBase.cs
@@ -1,7 +1,7 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
 using AsyncNavigation.Core;
 
-namespace AsyncNavigation.Tests.Infrastructure;
+namespace AsyncNavigation;
 
 /// <summary>
 /// Abstract base class that provides no-op default implementations of all
@@ -9,6 +9,7 @@ namespace AsyncNavigation.Tests.Infrastructure;
 /// need to override a subset of the navigation lifecycle methods, avoiding the
 /// boilerplate of empty implementations for the rest.
 /// </summary>
+/// <remarks>Retained for compatibility. New view models should implement INavigationAware directly.</remarks>
 /// <example>
 /// <code>
 /// public class HomeViewModel : NavigationAwareBase
@@ -21,6 +22,7 @@ namespace AsyncNavigation.Tests.Infrastructure;
 /// }
 /// </code>
 /// </example>
+[Obsolete("NavigationAwareBase is retained for compatibility. Implement INavigationAware directly instead.", false)]
 public abstract class NavigationAwareBase : INavigationAware
 {
     /// <inheritdoc/>
diff --git a/src/AsyncNavigation/ViewManager.cs b/src/AsyncNavigation/ViewManager.cs
index ebe2306..ec21bd9 100644
--- a/src/AsyncNavigation/ViewManager.cs
+++ b/src/AsyncNavigation/ViewManager.cs
@@ -28,13 +28,29 @@ public ViewManager(NavigationOptions options, IViewFactory viewFactory, ViewPlac
 
     public void Clear()
     {
-        foreach (var entry in _viewCache.ToArray())
+        var removedViews = new List<IView>();
+        // Remove all eligible entries before invoking user disposal code. A throwing
+        // Dispose must not leave unrelated old entries available for reuse.
+        lock (_lruLock)
         {
-            if (entry.Value.TryGetTarget(out var view) && _placement?.IsFloating(view) == true)
-                continue;
-            Remove(entry.Key, dispose: true);
+            foreach (var entry in _viewCache.ToArray())
+            {
+                entry.Value.TryGetTarget(out var view);
+                if (view is not null && _placement?.IsFloating(view) == true)
+                    continue;
+                if (!((ICollection<KeyValuePair<string, WeakReference<IView>>>)_viewCache).Remove(entry))
+                    continue;
+                if (_lruIndex.Remove(entry.Key, out var node))
+                    _lruList.Remove(node);
+                if (view is not null)
+                    removedViews.Add(view);
+            }
         }
+
+        foreach (var view in removedViews)
+            DisposeView(view);
     }
+
     public async Task<IView?> FindCachedViewAsync(string key, Func<IView, Task<bool>> isNavigationTarget)
     {
         if (_viewCache.TryGetValue(key, out var reference) &&
@@ -205,7 +221,7 @@ private static void SafeDispose(object? obj, string name)
             }
             catch (Exception ex)
             {
-                Debug.Fail($"Dispose {name} error.", ex.ToString());
+                Debug.WriteLine($"Dispose {name} error: {ex}");
                 throw;
             }
         }
diff --git a/tests/AsyncNavigation.Tests/NavigationAwareBaseTests.cs b/tests/AsyncNavigation.Tests/NavigationAwareBaseTests.cs
index 21840c7..2c8cb0f 100644
--- a/tests/AsyncNavigation.Tests/NavigationAwareBaseTests.cs
+++ b/tests/AsyncNavigation.Tests/NavigationAwareBaseTests.cs
@@ -1,9 +1,21 @@
-using AsyncNavigation.Tests.Infrastructure;
+using System.Reflection;
+
+#pragma warning disable CS0618 // Exercise the retained compatibility API.
 
 namespace AsyncNavigation.Tests;
 
 public class NavigationAwareBaseTests
 {
+    [Fact]
+    public void CompatibilityBase_IsInLibraryAndObsoleteWithWarningOnly()
+    {
+        Assert.Same(typeof(NavigationContext).Assembly, typeof(NavigationAwareBase).Assembly);
+        var obsolete = typeof(NavigationAwareBase).GetCustomAttribute<ObsoleteAttribute>();
+        Assert.NotNull(obsolete);
+        Assert.False(obsolete.IsError);
+        Assert.Contains("INavigationAware", obsolete.Message);
+    }
+
     private sealed class TestAware : NavigationAwareBase
     {
         public Task RequestUnload(CancellationToken ct = default) => RequestUnloadAsync(ct);
diff --git a/tests/AsyncNavigation.Tests/ViewManagerExtendedTests.cs b/tests/AsyncNavigation.Tests/ViewManagerExtendedTests.cs
index 5a1ed64..3a21a8f 100644
--- a/tests/AsyncNavigation.Tests/ViewManagerExtendedTests.cs
+++ b/tests/AsyncNavigation.Tests/ViewManagerExtendedTests.cs
@@ -25,10 +25,12 @@ public class ViewManagerExtendedTests
     /// </summary>
     private static (IViewManager Manager, IServiceProvider Provider) BuildManager(
         int max = 10,
-        ViewCacheStrategy strategy = ViewCacheStrategy.IgnoreDuplicateKey)
+        ViewCacheStrategy strategy = ViewCacheStrategy.IgnoreDuplicateKey,
+        ViewPlacementCoordinator? placement = null)
     {
         var sc = new ServiceCollection();
         sc.AddNavigationTestSupport(new NavigationOptions { MaxCachedViews = max, ViewCacheStrategy = strategy });
+        if (placement is not null) sc.AddSingleton(placement);
         sc.RegisterView<TestView, TestNavigationAware>("V1");
         sc.RegisterView<AnotherTestView, TestNavigationAware>("V2");
         var sp = sc.BuildServiceProvider();
@@ -149,6 +151,42 @@ public async Task Clear_DisposesAllViews()
         Assert.True(spy2.Disposed);
     }
 
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task Clear_DisposeFailure_RemovesAllNonFloatingEntries(bool withFloating)
+    {
+        var placement = withFloating ? new ViewPlacementCoordinator() : null;
+        var (manager, _) = BuildManager(placement: placement);
+        var first = await manager.ResolveViewAsync("V1", true);
+        var second = await manager.ResolveViewAsync("V2", true);
+        first.DataContext = new ThrowingDisposable();
+        second.DataContext = new ThrowingDisposable();
+        var floating = new TestView { DataContext = new DisposableSpy() };
+        if (placement is not null)
+        {
+            manager.AddView("floating", floating);
+            placement.Register(floating, _ => Task.CompletedTask);
+        }
+
+        Assert.Throws<InvalidOperationException>(() => manager.Clear());
+        if (placement is not null)
+        {
+            Assert.Same(floating, await manager.ResolveViewAsync("floating", true));
+            Assert.False(((DisposableSpy)floating.DataContext!).Disposed);
+        }
+
+        Assert.Null(await ((IViewPlacementCache)manager).FindCachedViewAsync("V1", _ => Task.FromResult(true)));
+        Assert.Null(await ((IViewPlacementCache)manager).FindCachedViewAsync("V2", _ => Task.FromResult(true)));
+        Assert.NotSame(first, await manager.ResolveViewAsync("V1", true));
+        Assert.NotSame(second, await manager.ResolveViewAsync("V2", true));
+    }
+
+    private sealed class ThrowingDisposable : IDisposable
+    {
+        public void Dispose() => throw new InvalidOperationException("Disposal failed.");
+    }
+
     // -----------------------------------------------------------------------
     // Concurrent access
     // -----------------------------------------------------------------------

From 01dfa5539efdd4a165a1814ea310b9e2e20df630 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 29 Sep 2026 12:07:10 +0200
Subject: [PATCH 10/14] fix(ci): update Android SDK packages and iOS minimum
 version

---
 .github/workflows/ci.yml                               | 2 ++
 samples/Sample.Avalonia.iOS/Info.plist                 | 2 +-
 samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj | 2 +-
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8ceb93a..289248b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -199,6 +199,8 @@ jobs:
       - name: Setup Android SDK
         if: matrix.platform == 'Android'
         uses: android-actions/setup-android@v3
+        with:
+          packages: platform-tools
 
       - name: Install Android workload
         if: matrix.platform == 'Android'
diff --git a/samples/Sample.Avalonia.iOS/Info.plist b/samples/Sample.Avalonia.iOS/Info.plist
index 3fff6e2..91a3c19 100644
--- a/samples/Sample.Avalonia.iOS/Info.plist
+++ b/samples/Sample.Avalonia.iOS/Info.plist
@@ -13,7 +13,7 @@
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
 	<key>MinimumOSVersion</key>
-	<string>13.0</string>
+	<string>15.0</string>
 	<key>UIDeviceFamily</key>
 	<array>
 		<integer>1</integer>
diff --git a/samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj b/samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj
index cefb484..08ce307 100644
--- a/samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj
+++ b/samples/Sample.Avalonia.iOS/Sample.Avalonia.iOS.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net10.0-ios</TargetFramework>
-    <SupportedOSPlatformVersion>13.0</SupportedOSPlatformVersion>
+    <SupportedOSPlatformVersion>15.0</SupportedOSPlatformVersion>
     <Nullable>enable</Nullable>
 	<ValidateXcodeVersion>false</ValidateXcodeVersion>
   </PropertyGroup>

From 4e3737310fb84969f36ce98015134cf994a76d96 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 29 Sep 2026 16:01:24 +0200
Subject: [PATCH 11/14] fix: address floating placement review findings from PR
 #55

- Make ViewPlacementCoordinator.EnterAsync reentrant per logical async
  call chain to fix a deadlock when a navigation callback (e.g.
  OnNavigatedToAsync) triggers a placement change on the same region;
  exposes IsHeld() for lease-contract enforcement.
- Make WeakUnloadObserver.Subscribe idempotent so docking a floated
  view back no longer double-subscribes its unload handler.
- Respect RegionPlacementItem.WasSelected on Attach instead of forcing
  activation, and only correct selection on a failed restore when it
  was actually disturbed.
- Set up the indicator host unconditionally at the start of
  CreateNavigateTask so a failed or externally-activated navigation
  always has a usable IndicatorHost.
- Add the missing Selected ?? Items.LastOrDefault() fallback to
  TabRegion/TabbedPageRegion.Capture() to match ItemsRegion behavior.
- Fail fast in GetContentHost when an indicator host doesn't support
  content detachment, instead of silently corrupting the visual tree.
- Enforce the documented placement-lease contract in
  RegionBase.RestorePlacementAsync via ViewPlacementCoordinator.IsHeld.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 src/AsyncNavigation.Avalonia/TabRegion.cs     |  2 +-
 .../TabbedPageRegion.cs                       |  2 +-
 .../ViewPlacementService.cs                   | 18 +++--
 src/AsyncNavigation.Wpf/TabRegion.cs          |  2 +-
 src/AsyncNavigation/RegionBase.cs             | 13 +++-
 .../RegionNavigationService.cs                |  6 +-
 .../ViewPlacementCoordinator.cs               | 70 ++++++++++++++++---
 src/AsyncNavigation/WeakUnloadObserver.cs     | 16 ++++-
 8 files changed, 108 insertions(+), 21 deletions(-)

diff --git a/src/AsyncNavigation.Avalonia/TabRegion.cs b/src/AsyncNavigation.Avalonia/TabRegion.cs
index 39ac9fd..74cf21d 100644
--- a/src/AsyncNavigation.Avalonia/TabRegion.cs
+++ b/src/AsyncNavigation.Avalonia/TabRegion.cs
@@ -72,7 +72,7 @@ public RegionPlacementItem Capture(Guid? navigationId = null)
     {
         var context = navigationId.HasValue
             ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
-            : _context.Selected;
+            : _context.Selected ?? _context.Items.LastOrDefault();
 
         if (context is null)
             throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
diff --git a/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs b/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
index e057bcf..e324526 100644
--- a/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
+++ b/src/AsyncNavigation.Avalonia/TabbedPageRegion.cs
@@ -84,7 +84,7 @@ public RegionPlacementItem Capture(Guid? navigationId = null)
     {
         var context = navigationId.HasValue
             ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
-            : _context.Selected;
+            : _context.Selected ?? _context.Items.LastOrDefault();
         if (context is null)
             throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
 
diff --git a/src/AsyncNavigation.Floating/ViewPlacementService.cs b/src/AsyncNavigation.Floating/ViewPlacementService.cs
index d946219..ae3dd25 100644
--- a/src/AsyncNavigation.Floating/ViewPlacementService.cs
+++ b/src/AsyncNavigation.Floating/ViewPlacementService.cs
@@ -109,7 +109,7 @@ public async Task<IFloatingViewSession> FloatAsync(
             {
                 await host.SetContentAsync(null, CancellationToken.None);
                 if (detached)
-                    participant.Attach(item);
+                    participant.Attach(item, activate: false);
                 if (contentDetached)
                     contentOwner!.AttachContent(session.Content);
             }
@@ -169,7 +169,7 @@ async Task RollbackContent()
             try
             {
                 await TransferContent();
-                participant.Attach(session.Item);
+                participant.Attach(session.Item, activate: false);
                 attached = true;
             }
             catch
@@ -252,9 +252,17 @@ public void Dispose()
         _sessionsByNavigationId.Clear();
     }
 
-    private static object GetContentHost(RegionPlacementItem item) =>
-        item.Context.IndicatorHost.Value?.Host
-        ?? throw new InvalidOperationException("The navigation item does not have an indicator host.");
+    private static object GetContentHost(RegionPlacementItem item)
+    {
+        if (item.Context.IndicatorHost.Value is not { } host)
+            throw new InvalidOperationException("The navigation item does not have an indicator host.");
+        // Reaching here means the host isn't an IRegionPlacementContentHost, so its content
+        // cannot be detached from its current visual parent. Fail fast instead of proceeding
+        // as if detachment succeeded, which would corrupt the visual tree.
+        throw new NotSupportedException(
+            $"Indicator host '{host.GetType()}' does not implement {nameof(IRegionPlacementContentHost)} " +
+            "and cannot be detached for floating placement.");
+    }
 
     internal sealed class FloatingViewSession : IFloatingViewSession
     {
diff --git a/src/AsyncNavigation.Wpf/TabRegion.cs b/src/AsyncNavigation.Wpf/TabRegion.cs
index 18c44f4..5b7018c 100644
--- a/src/AsyncNavigation.Wpf/TabRegion.cs
+++ b/src/AsyncNavigation.Wpf/TabRegion.cs
@@ -78,7 +78,7 @@ public RegionPlacementItem Capture(Guid? navigationId = null)
     {
         var context = navigationId.HasValue
             ? _context.Items.FirstOrDefault(item => item.NavigationId == navigationId.Value)
-            : _context.Selected;
+            : _context.Selected ?? _context.Items.LastOrDefault();
 
         if (context is null)
             throw new InvalidOperationException($"Region '{Name}' does not contain the requested navigation item.");
diff --git a/src/AsyncNavigation/RegionBase.cs b/src/AsyncNavigation/RegionBase.cs
index 8791724..bdd64e0 100644
--- a/src/AsyncNavigation/RegionBase.cs
+++ b/src/AsyncNavigation/RegionBase.cs
@@ -162,6 +162,9 @@ public async Task RestorePlacementAsync(RegionPlacementItem item, Func<Task> tra
     {
         if (this is not IRegionPlacementParticipant participant)
             throw new NotSupportedException("The region does not support placement.");
+        if (_placement is not null && !_placement.IsHeld(Name))
+            throw new InvalidOperationException(
+                $"RestorePlacementAsync for region '{Name}' must be called while holding the region's placement lease.");
         RegionPlacementItem? previous = null;
         try { previous = participant.Capture(); }
         catch (InvalidOperationException) { }
@@ -196,7 +199,9 @@ public async Task RestorePlacementAsync(RegionPlacementItem item, Func<Task> tra
             }
             transferred = true;
             await transferContent();
-            participant.Attach(restored);
+            // Let the attach honor whether the item was selected/active when it was originally
+            // detached (restored.WasSelected), instead of forcing selection on every restore.
+            participant.Attach(restored, activate: false);
             attached = true;
             await _regionNavigationService.CommitPlacementAsync(context, notify: previous is not null);
             cancellationToken.ThrowIfCancellationRequested();
@@ -209,7 +214,11 @@ public async Task RestorePlacementAsync(RegionPlacementItem item, Func<Task> tra
             if (transferred) await rollbackContent();
             if (displacedContent is not null) sharedHost!.AttachContent(displacedContent);
             if (detached) participant.Attach(previous!);
-            else if (previous is not null) await ProcessActivateAsync(previous.Context);
+            // Attach(restored, activate: false) only disturbed the current selection when the
+            // restored item itself was selected before it was detached; only then does the
+            // Detach(restored) above (which may have picked an unrelated neighbor) need correcting.
+            else if (attached && restored.WasSelected && previous is not null)
+                await ProcessActivateAsync(previous.Context);
             _regionNavigationService.SetCurrent(previous?.Context);
             context.UpdateStatus(ex is OperationCanceledException ? NavigationStatus.Cancelled : NavigationStatus.Failed, ex);
             throw;
diff --git a/src/AsyncNavigation/RegionNavigationService.cs b/src/AsyncNavigation/RegionNavigationService.cs
index 57c5950..91eeae5 100644
--- a/src/AsyncNavigation/RegionNavigationService.cs
+++ b/src/AsyncNavigation/RegionNavigationService.cs
@@ -107,6 +107,11 @@ public void Dispose()
     private async Task CreateNavigateTask(NavigationContext navigationContext)
     {
         var isSinglePageRegion = _regionPresenter!.IsSinglePageRegion;
+        // Set up the indicator host up front so it is always available - even if the
+        // fast path below (cache lookup / TryActivateAsync) throws or short-circuits -
+        // so a failed navigation can still show an error and a successful NavigationResult
+        // always carries a usable IndicatorHost.
+        _regionIndicatorManager.Setup(navigationContext, isSinglePageRegion);
         if (_placement is not null)
         {
             // Inspect reusable instances before leaving or rendering the current region.
@@ -126,7 +131,6 @@ await _placement.TryActivateAsync(target, navigationContext.CancellationToken))
                 return;
             }
         }
-        _regionIndicatorManager.Setup(navigationContext, isSinglePageRegion);
 
         var navigationTask = RunNavigationAsync(navigationContext, _regionPresenter.NavigationPipelineMode);
 
diff --git a/src/AsyncNavigation/ViewPlacementCoordinator.cs b/src/AsyncNavigation/ViewPlacementCoordinator.cs
index f771752..b75bf9c 100644
--- a/src/AsyncNavigation/ViewPlacementCoordinator.cs
+++ b/src/AsyncNavigation/ViewPlacementCoordinator.cs
@@ -6,16 +6,53 @@ namespace AsyncNavigation;
 /// <summary>Coordinates navigation and window placement by region and view instance.</summary>
 public sealed class ViewPlacementCoordinator
 {
-    private readonly ConcurrentDictionary<string, SemaphoreSlim> _gates = new();
+    private readonly ConcurrentDictionary<string, RegionGate> _gates = new();
     private readonly ConcurrentDictionary<IView, Func<CancellationToken, Task>> _floating = new(ReferenceEqualityComparer.Instance);
 
-    public async Task<IDisposable> EnterAsync(string regionName, CancellationToken cancellationToken = default)
+    /// <summary>
+    /// Acquires the placement lease for a region. Reentrant within the same logical async
+    /// call chain: code that already holds the lease (e.g. a navigation callback that in turn
+    /// triggers a placement change on the same region) re-enters immediately instead of
+    /// deadlocking against itself.
+    /// </summary>
+    /// <remarks>
+    /// Deliberately not an `async` method: AsyncLocal writes made inside an async method are
+    /// invisible to its caller once it returns (the compiler-generated state machine restores
+    /// the caller's captured ExecutionContext), even when the method never actually suspends.
+    /// The uncontended/reentrant fast paths below write <see cref="RegionGate.Depth"/> directly
+    /// in this plain method body so the mark stays visible to the caller's subsequent code -
+    /// which is what lets a nested re-entry on the same region see it. Only the genuinely
+    /// contended wait is delegated to an async helper, where that guarantee no longer holds.
+    /// </remarks>
+    public Task<IDisposable> EnterAsync(string regionName, CancellationToken cancellationToken = default)
     {
-        var gate = _gates.GetOrAdd(regionName, _ => new SemaphoreSlim(1, 1));
-        await gate.WaitAsync(cancellationToken);
-        return new Lease(gate);
+        var gate = _gates.GetOrAdd(regionName, _ => new RegionGate());
+        if (gate.Depth.Value > 0)
+        {
+            gate.Depth.Value++;
+            return Task.FromResult<IDisposable>(new Lease(gate, reentrant: true));
+        }
+
+        var wait = gate.Semaphore.WaitAsync(cancellationToken);
+        if (wait.IsCompletedSuccessfully)
+        {
+            gate.Depth.Value = 1;
+            return Task.FromResult<IDisposable>(new Lease(gate, reentrant: false));
+        }
+        return EnterSlowAsync(gate, wait);
+    }
+
+    private static async Task<IDisposable> EnterSlowAsync(RegionGate gate, Task wait)
+    {
+        await wait;
+        gate.Depth.Value = 1;
+        return new Lease(gate, reentrant: false);
     }
 
+    /// <summary>Returns whether the current logical async call chain already holds the placement lease for the region.</summary>
+    public bool IsHeld(string regionName) =>
+        _gates.TryGetValue(regionName, out var gate) && gate.Depth.Value > 0;
+
     public bool IsFloating(IView view) => _floating.ContainsKey(view);
 
     public void Register(IView view, Func<CancellationToken, Task> activate)
@@ -33,9 +70,26 @@ public async Task<bool> TryActivateAsync(IView view, CancellationToken cancellat
         return true;
     }
 
-    private sealed class Lease(SemaphoreSlim gate) : IDisposable
+    private sealed class RegionGate
+    {
+        public readonly SemaphoreSlim Semaphore = new(1, 1);
+        public readonly AsyncLocal<int> Depth = new();
+    }
+
+    private sealed class Lease(RegionGate gate, bool reentrant) : IDisposable
     {
-        private SemaphoreSlim? _gate = gate;
-        public void Dispose() => Interlocked.Exchange(ref _gate, null)?.Release();
+        private RegionGate? _gate = gate;
+        public void Dispose()
+        {
+            var g = Interlocked.Exchange(ref _gate, null);
+            if (g is null) return;
+            if (reentrant)
+                g.Depth.Value--;
+            else
+            {
+                g.Depth.Value = 0;
+                g.Semaphore.Release();
+            }
+        }
     }
 }
diff --git a/src/AsyncNavigation/WeakUnloadObserver.cs b/src/AsyncNavigation/WeakUnloadObserver.cs
index b548f32..685cdb5 100644
--- a/src/AsyncNavigation/WeakUnloadObserver.cs
+++ b/src/AsyncNavigation/WeakUnloadObserver.cs
@@ -1,5 +1,6 @@
-using AsyncNavigation.Abstractions;
+using AsyncNavigation.Abstractions;
 using AsyncNavigation.Core;
+using System.Runtime.CompilerServices;
 
 namespace AsyncNavigation;
 
@@ -9,8 +10,19 @@ namespace AsyncNavigation;
 /// </summary>
 internal sealed class WeakUnloadObserver
 {
+    // Tracks the currently-subscribed handler per instance so re-subscribing the same
+    // INavigationAware (e.g. after floating and docking a view back) replaces the previous
+    // handler instead of stacking a second one that would fire alongside it.
+    private static readonly ConditionalWeakTable<INavigationAware, AsyncEventHandler<AsyncEventArgs>> _subscriptions = new();
+
     public static void Subscribe(INavigationAware navigationAware, Action<INavigationAware> onUnloadCallback)
     {
+        if (_subscriptions.TryGetValue(navigationAware, out var previousHandler))
+        {
+            navigationAware.AsyncRequestUnloadEvent -= previousHandler;
+            _subscriptions.Remove(navigationAware);
+        }
+
         var weakReference = new WeakReference<INavigationAware>(navigationAware);
 
         async Task HandleRequestUnloadAsync(object? sender, AsyncEventArgs args)
@@ -28,7 +40,7 @@ async Task HandleRequestUnloadAsync(object? sender, AsyncEventArgs args)
             onUnloadCallback?.Invoke(target);
         }
 
+        _subscriptions.Add(navigationAware, HandleRequestUnloadAsync);
         navigationAware.AsyncRequestUnloadEvent += HandleRequestUnloadAsync;
     }
 }
-

From 6c47307f3a2df0aceda89f76c0a697893c40a958 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 29 Sep 2026 18:18:19 +0200
Subject: [PATCH 12/14] feat(floating): support floating views under
 WASM/single-view lifetime

AvaloniaFloatingWindowHostFactory previously required Avalonia's classic
desktop lifetime and threw NotSupportedException otherwise, so FloatAsync
was unusable on browser/WASM and mobile single-view apps. It now selects
the host per ApplicationLifetime: classic desktop still gets a real OS
Window, while single-view apps get a new AvaloniaOverlayFloatingWindowHost
that renders the floating content as a draggable, resizable in-page
overlay panel (via Avalonia's OverlayLayer) with the same Dock/Close
contract as the native window host.

Verified with a new headless E2E test and manually in Sample.Avalonia.Browser
via dotnet run + Chrome: float, drag, dock, and close all round-trip
correctly with no console errors.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../AvaloniaFloatingWindowHost.cs             |  16 +-
 .../AvaloniaOverlayFloatingWindowHost.cs      | 220 ++++++++++++++++++
 .../FloatingOverlayWindowTests.cs             |  72 ++++++
 3 files changed, 305 insertions(+), 3 deletions(-)
 create mode 100644 src/AsyncNavigation.Avalonia.Floating/AvaloniaOverlayFloatingWindowHost.cs
 create mode 100644 tests/AsyncNavigation.E2E.Tests/FloatingOverlayWindowTests.cs

diff --git a/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
index 8d23ac8..bd31e6a 100644
--- a/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
+++ b/src/AsyncNavigation.Avalonia.Floating/AvaloniaFloatingWindowHost.cs
@@ -12,9 +12,19 @@ public IFloatingWindowHost Create(FloatingWindowOptions options)
     {
         if (!Dispatcher.UIThread.CheckAccess())
             throw new InvalidOperationException("Floating windows must be created on the Avalonia UI thread.");
-        if (Application.Current?.ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime)
-            throw new NotSupportedException("Floating windows require Avalonia's classic desktop lifetime.");
-        return new AvaloniaFloatingWindowHost(options);
+
+        // Classic desktop hosts get a real OS window; everything else (browser/WASM, mobile
+        // single-view apps) has no windowing system, so floating content is rendered as an
+        // in-page overlay panel instead.
+        return Application.Current?.ApplicationLifetime switch
+        {
+            IClassicDesktopStyleApplicationLifetime => new AvaloniaFloatingWindowHost(options),
+            ISingleViewApplicationLifetime { MainView: { } mainView } => new AvaloniaOverlayFloatingWindowHost(options, mainView),
+            ISingleViewApplicationLifetime => throw new InvalidOperationException(
+                "The single-view application lifetime does not have a MainView to host floating content in."),
+            _ => throw new NotSupportedException(
+                "Floating windows require Avalonia's classic desktop or single-view application lifetime.")
+        };
     }
 }
 
diff --git a/src/AsyncNavigation.Avalonia.Floating/AvaloniaOverlayFloatingWindowHost.cs b/src/AsyncNavigation.Avalonia.Floating/AvaloniaOverlayFloatingWindowHost.cs
new file mode 100644
index 0000000..2d156c1
--- /dev/null
+++ b/src/AsyncNavigation.Avalonia.Floating/AvaloniaOverlayFloatingWindowHost.cs
@@ -0,0 +1,220 @@
+using AsyncNavigation.Floating;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
+
+namespace AsyncNavigation.Avalonia.Floating;
+
+/// <summary>
+/// Renders a floating "window" as a draggable, resizable in-page overlay panel instead of a
+/// native OS window. Selected automatically for Avalonia's single-view application lifetime
+/// (browser/WASM, mobile), where there is no windowing system to host a real <see cref="Window"/>.
+/// </summary>
+internal sealed class AvaloniaOverlayFloatingWindowHost : IFloatingWindowHost
+{
+    private const double DefaultWidth = 400;
+    private const double DefaultHeight = 300;
+    private const double MinWidth = 200;
+    private const double MinHeight = 120;
+    private const double CascadeStep = 28;
+    private const int CascadeSlots = 10;
+
+    private static int _cascadeIndex;
+    private static int _nextZIndex = 1;
+
+    private readonly Control _mainView;
+    private readonly ContentControl _content = new();
+    private readonly Border _panel;
+
+    private OverlayLayer? _layer;
+    private bool _dragging;
+    private Point _dragStartPointerPosition;
+    private Point _dragStartPanelPosition;
+    private bool _resizing;
+    private Point _resizeStartPointerPosition;
+    private Size _resizeStartSize;
+
+    public AvaloniaOverlayFloatingWindowHost(FloatingWindowOptions options, Control mainView)
+    {
+        _mainView = mainView;
+
+        var titleText = new TextBlock
+        {
+            Text = options.Title,
+            VerticalAlignment = VerticalAlignment.Center,
+            Margin = new Thickness(8, 0, 0, 0),
+            FontWeight = FontWeight.SemiBold
+        };
+
+        var dockButton = new Button { Content = "Dock", Margin = new Thickness(4, 2) };
+        dockButton.Click += (_, _) => RestoreRequested?.Invoke(this, EventArgs.Empty);
+
+        // A plain ASCII glyph, not "✕": the default WASM/browser font set doesn't cover it and
+        // renders tofu instead.
+        var closeButton = new Button { Content = "X", Margin = new Thickness(0, 2, 4, 2) };
+        closeButton.Click += (_, _) => CloseRequested?.Invoke(this, EventArgs.Empty);
+
+        var titleBarButtons = new StackPanel { Orientation = Orientation.Horizontal };
+        titleBarButtons.Children.Add(dockButton);
+        titleBarButtons.Children.Add(closeButton);
+        Grid.SetColumn(titleBarButtons, 1);
+
+        var titleBar = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("*,Auto"),
+            Background = Brushes.Gainsboro,
+            Cursor = new Cursor(StandardCursorType.SizeAll)
+        };
+        titleBar.Children.Add(titleText);
+        titleBar.Children.Add(titleBarButtons);
+        titleBar.PointerPressed += OnTitleBarPointerPressed;
+        titleBar.PointerMoved += OnTitleBarPointerMoved;
+        titleBar.PointerReleased += OnTitleBarPointerReleased;
+        Grid.SetRow(titleBar, 0);
+
+        Grid.SetRow(_content, 1);
+
+        var body = new Grid { RowDefinitions = new RowDefinitions("Auto,*") };
+        body.Children.Add(titleBar);
+        body.Children.Add(_content);
+
+        var resizeGrip = new Border
+        {
+            Width = 14,
+            Height = 14,
+            Background = Brushes.Transparent,
+            Cursor = new Cursor(StandardCursorType.BottomRightCorner),
+            HorizontalAlignment = HorizontalAlignment.Right,
+            VerticalAlignment = VerticalAlignment.Bottom
+        };
+        resizeGrip.PointerPressed += OnResizeGripPointerPressed;
+        resizeGrip.PointerMoved += OnResizeGripPointerMoved;
+        resizeGrip.PointerReleased += OnResizeGripPointerReleased;
+
+        var root = new Grid();
+        root.Children.Add(body);
+        root.Children.Add(resizeGrip);
+
+        _panel = new Border
+        {
+            Width = options.Width ?? DefaultWidth,
+            Height = options.Height ?? DefaultHeight,
+            BorderBrush = Brushes.DimGray,
+            BorderThickness = new Thickness(1),
+            Background = Brushes.White,
+            Child = root
+        };
+    }
+
+    public event EventHandler? RestoreRequested;
+    public event EventHandler? CloseRequested;
+
+    public Task SetContentAsync(object? content, CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _content.Content = content, cancellationToken);
+
+    public Task ShowAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() =>
+        {
+            var topLevel = TopLevel.GetTopLevel(_mainView)
+                ?? throw new InvalidOperationException(
+                    "Could not resolve a TopLevel for the current view to host floating content in.");
+            _layer = OverlayLayer.GetOverlayLayer(topLevel)
+                ?? throw new InvalidOperationException("Could not find an overlay layer to host floating content in.");
+
+            if (!_layer.Children.Contains(_panel))
+            {
+                var offset = (_cascadeIndex++ % CascadeSlots) * CascadeStep;
+                Canvas.SetLeft(_panel, offset);
+                Canvas.SetTop(_panel, offset);
+                _layer.Children.Add(_panel);
+            }
+            BringToFront();
+        }, cancellationToken);
+
+    public Task ActivateAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() =>
+        {
+            BringToFront();
+            _panel.Focus();
+        }, cancellationToken);
+
+    public Task CloseAsync(CancellationToken cancellationToken = default) =>
+        InvokeAsync(() => _layer?.Children.Remove(_panel), cancellationToken);
+
+    public ValueTask DisposeAsync()
+    {
+        var task = InvokeAsync(() => _layer?.Children.Remove(_panel), CancellationToken.None);
+        return new ValueTask(task);
+    }
+
+    private void BringToFront() => _panel.ZIndex = _nextZIndex++;
+
+    private void OnTitleBarPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        if (_layer is null || !e.GetCurrentPoint(_panel).Properties.IsLeftButtonPressed) return;
+        _dragging = true;
+        _dragStartPointerPosition = e.GetPosition(_layer);
+        _dragStartPanelPosition = new Point(Canvas.GetLeft(_panel), Canvas.GetTop(_panel));
+        e.Pointer.Capture((IInputElement)sender!);
+        BringToFront();
+        e.Handled = true;
+    }
+
+    private void OnTitleBarPointerMoved(object? sender, PointerEventArgs e)
+    {
+        if (!_dragging || _layer is null) return;
+        var delta = e.GetPosition(_layer) - _dragStartPointerPosition;
+        var maxLeft = Math.Max(0, _layer.Bounds.Width - _panel.Bounds.Width);
+        var maxTop = Math.Max(0, _layer.Bounds.Height - _panel.Bounds.Height);
+        Canvas.SetLeft(_panel, Math.Clamp(_dragStartPanelPosition.X + delta.X, 0, maxLeft));
+        Canvas.SetTop(_panel, Math.Clamp(_dragStartPanelPosition.Y + delta.Y, 0, maxTop));
+    }
+
+    private void OnTitleBarPointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        if (!_dragging) return;
+        _dragging = false;
+        e.Pointer.Capture(null);
+    }
+
+    private void OnResizeGripPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        if (_layer is null || !e.GetCurrentPoint(_panel).Properties.IsLeftButtonPressed) return;
+        _resizing = true;
+        _resizeStartPointerPosition = e.GetPosition(_layer);
+        _resizeStartSize = new Size(_panel.Width, _panel.Height);
+        e.Pointer.Capture((IInputElement)sender!);
+        BringToFront();
+        e.Handled = true;
+    }
+
+    private void OnResizeGripPointerMoved(object? sender, PointerEventArgs e)
+    {
+        if (!_resizing || _layer is null) return;
+        var delta = e.GetPosition(_layer) - _resizeStartPointerPosition;
+        _panel.Width = Math.Max(MinWidth, _resizeStartSize.Width + delta.X);
+        _panel.Height = Math.Max(MinHeight, _resizeStartSize.Height + delta.Y);
+    }
+
+    private void OnResizeGripPointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        if (!_resizing) return;
+        _resizing = false;
+        e.Pointer.Capture(null);
+    }
+
+    private static async Task InvokeAsync(Action action, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        if (Dispatcher.UIThread.CheckAccess())
+        {
+            action();
+            return;
+        }
+        await Dispatcher.UIThread.InvokeAsync(action);
+    }
+}
diff --git a/tests/AsyncNavigation.E2E.Tests/FloatingOverlayWindowTests.cs b/tests/AsyncNavigation.E2E.Tests/FloatingOverlayWindowTests.cs
new file mode 100644
index 0000000..7ec8eab
--- /dev/null
+++ b/tests/AsyncNavigation.E2E.Tests/FloatingOverlayWindowTests.cs
@@ -0,0 +1,72 @@
+using AsyncNavigation.Avalonia.Floating;
+using AsyncNavigation.Floating;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Headless.XUnit;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+
+namespace AsyncNavigation.E2E.Tests;
+
+public sealed class FloatingOverlayWindowTests
+{
+    [AvaloniaTheory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Overlay_host_renders_in_page_and_raises_separate_requests(bool dock)
+    {
+        var mainView = new Grid();
+        var window = new Window { Content = mainView, Width = 500, Height = 400 };
+        window.Show();
+        try
+        {
+            var content = new Border();
+            var restoreRequested = false;
+            var closeRequested = false;
+            var host = new AvaloniaOverlayFloatingWindowHost(
+                new FloatingWindowOptions { Title = "Overlay lifecycle test", Width = 320, Height = 240 },
+                mainView);
+
+            host.RestoreRequested += (_, _) => restoreRequested = true;
+            host.CloseRequested += (_, _) => closeRequested = true;
+
+            host.SetContentAsync(content).GetAwaiter().GetResult();
+            host.ShowAsync().GetAwaiter().GetResult();
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+
+            var topLevel = TopLevel.GetTopLevel(mainView);
+            var overlay = OverlayLayer.GetOverlayLayer(topLevel!);
+            Assert.NotNull(overlay);
+            // The overlay host must NOT open a separate OS window: floated content stays under
+            // the same TopLevel as the page that hosts it - that is the whole point on WASM.
+            Assert.Same(topLevel, TopLevel.GetTopLevel(content));
+
+            var dockButton = FindButton(overlay!, "Dock");
+            var closeButton = FindButton(overlay!, "X");
+
+            if (dock)
+                dockButton.RaiseEvent(new global::Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            else
+                closeButton.RaiseEvent(new global::Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded);
+
+            Assert.Equal(dock, restoreRequested);
+            Assert.Equal(!dock, closeRequested);
+
+            host.CloseAsync().GetAwaiter().GetResult();
+            Assert.DoesNotContain(FindButtons(overlay!), b => b == dockButton);
+            host.DisposeAsync().AsTask().GetAwaiter().GetResult();
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    private static Button FindButton(OverlayLayer overlay, string text) =>
+        FindButtons(overlay).First(b => (b.Content as string) == text);
+
+    private static IEnumerable<Button> FindButtons(OverlayLayer overlay) =>
+        overlay.GetVisualDescendants().OfType<Button>();
+}

From 691632dbcc8e343526687d16846b23f6cf1f0df0 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 29 Sep 2026 18:39:04 +0200
Subject: [PATCH 13/14] sample(floating): unify the MainRegion floating demo
 across platforms

MainWindow.axaml previously hosted its own "Floating: current MainRegion
view" button + description around <views:MainView />, so the demo only
existed on classic desktop; MainView (the shared root used directly by
Avalonia's single-view lifetime on browser/WASM, Android and iOS) never
had it. Move the button and its FloatMainRegion_Click handler into
MainView itself, and have MainWindow construct MainView in code and
forward its IViewPlacementService instead of duplicating the header.
Desktop, browser, Android and iOS now show the identical set of floating
samples (MainRegion, TabRegion, ChildContentRegion, ItemsRegion,
ListBoxRegion), with desktop's existing behavior as the reference.

Verified in Sample.Avalonia.Browser via dotnet run + Chrome: the
MainRegion float/dock button now shows on the home page and round-trips
correctly.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 samples/Sample.Avalonia/App.axaml.cs          |  2 +-
 samples/Sample.Avalonia/Views/MainView.axaml  | 11 +++++--
 .../Sample.Avalonia/Views/MainView.axaml.cs   | 33 ++++++++++++++++++-
 .../Sample.Avalonia/Views/MainWindow.axaml    | 10 ------
 .../Sample.Avalonia/Views/MainWindow.axaml.cs | 32 +++---------------
 5 files changed, 46 insertions(+), 42 deletions(-)

diff --git a/samples/Sample.Avalonia/App.axaml.cs b/samples/Sample.Avalonia/App.axaml.cs
index 1509e78..5bb8a3b 100644
--- a/samples/Sample.Avalonia/App.axaml.cs
+++ b/samples/Sample.Avalonia/App.axaml.cs
@@ -83,7 +83,7 @@ public override void OnFrameworkInitializationCompleted()
         }
         else if (ApplicationLifetime is ISingleViewApplicationLifetime singleViewPlatform)
         {
-            singleViewPlatform.MainView = new MainView
+            singleViewPlatform.MainView = new MainView(sp.GetRequiredService<AsyncNavigation.Floating.IViewPlacementService>())
             {
                 DataContext = sp.GetRequiredService<MainWindowViewModel>()
             };
diff --git a/samples/Sample.Avalonia/Views/MainView.axaml b/samples/Sample.Avalonia/Views/MainView.axaml
index ae2896b..26f5c0f 100644
--- a/samples/Sample.Avalonia/Views/MainView.axaml
+++ b/samples/Sample.Avalonia/Views/MainView.axaml
@@ -10,8 +10,15 @@
     d:DesignWidth="800"
     x:DataType="vm:MainWindowViewModel"
     mc:Ignorable="d">
-    <Grid RowDefinitions="*,30">
+    <Grid RowDefinitions="Auto,*,30">
+        <Border Grid.Row="0" Padding="8">
+            <StackPanel Orientation="Horizontal" Spacing="8">
+                <Button Click="FloatMainRegion_Click" Content="Floating: current MainRegion view" />
+                <TextBlock VerticalAlignment="Center" Text="The same UserControl instance moves to the window; use Dock to region to return it. Closing closes the view." />
+            </StackPanel>
+        </Border>
         <SplitView
+            Grid.Row="1"
             DisplayMode="CompactInline"
             IsPaneOpen="{Binding IsSplitViewPaneOpen}"
             OpenPaneLength="310"
@@ -133,7 +140,7 @@
         </SplitView>
         <SelectableTextBlock
             Name="footer"
-            Grid.Row="1"
+            Grid.Row="2"
             HorizontalAlignment="Center"
             VerticalAlignment="Center" />
     </Grid>
diff --git a/samples/Sample.Avalonia/Views/MainView.axaml.cs b/samples/Sample.Avalonia/Views/MainView.axaml.cs
index 4a38b47..0157044 100644
--- a/samples/Sample.Avalonia/Views/MainView.axaml.cs
+++ b/samples/Sample.Avalonia/Views/MainView.axaml.cs
@@ -1,18 +1,49 @@
 using AsyncNavigation.Core;
+using AsyncNavigation.Floating;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Data;
+using Avalonia.Interactivity;
 using Sample.Common;
+using System;
+using System.Diagnostics;
 
 namespace Sample.Avalonia.Views;
 
 public partial class MainView : UserControl
 {
-    public MainView()
+    private readonly IViewPlacementService? _placementService;
+
+    public MainView() : this(null)
+    {
+    }
+
+    public MainView(IViewPlacementService? placementService)
     {
+        _placementService = placementService;
         InitializeComponent();
     }
 
+    private async void FloatMainRegion_Click(object? sender, RoutedEventArgs e)
+    {
+        if (_placementService is null)
+            return;
+
+        try
+        {
+            await _placementService.FloatAsync("MainRegion", options: new FloatingWindowOptions
+            {
+                Title = "AsyncNavigation floating MainRegion",
+                Width = 900,
+                Height = 600
+            });
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
+        {
+            Debug.WriteLine($"Cannot float MainRegion: {ex.Message}");
+        }
+    }
+
     protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
     {
         base.OnAttachedToVisualTree(e);
diff --git a/samples/Sample.Avalonia/Views/MainWindow.axaml b/samples/Sample.Avalonia/Views/MainWindow.axaml
index f5c011d..c090e35 100644
--- a/samples/Sample.Avalonia/Views/MainWindow.axaml
+++ b/samples/Sample.Avalonia/Views/MainWindow.axaml
@@ -11,16 +11,6 @@
     xmlns:vm="using:Sample.Common"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    xmlns:views="clr-namespace:Sample.Avalonia.Views"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     x:DataType="vm:MainWindowViewModel">
-    <DockPanel LastChildFill="True">
-        <Border Padding="8" DockPanel.Dock="Top">
-            <StackPanel Orientation="Horizontal" Spacing="8">
-                <Button Click="FloatMainRegion_Click" Content="Floating: current MainRegion view" />
-                <TextBlock VerticalAlignment="Center" Text="The same UserControl instance moves to the window; use Dock to region to return it. Closing closes the view." />
-            </StackPanel>
-        </Border>
-        <views:MainView />
-    </DockPanel>
 </Window>
diff --git a/samples/Sample.Avalonia/Views/MainWindow.axaml.cs b/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
index 9825d35..d5820ac 100644
--- a/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
+++ b/samples/Sample.Avalonia/Views/MainWindow.axaml.cs
@@ -1,46 +1,22 @@
 using Avalonia.Controls;
-using System;
-using System.Diagnostics;
-using System.Threading;
-using System.Threading.Tasks;
 
 using AsyncNavigation.Floating;
-using Avalonia.Interactivity;
 
 namespace Sample.Avalonia.Views
 {
     public partial class MainWindow : Window
     {
-        private readonly IViewPlacementService? _placementService;
-
         public MainWindow() : this(null)
         {
         }
 
         public MainWindow(IViewPlacementService? placementService)
         {
-            _placementService = placementService;
             InitializeComponent();
-        }
-
-        private async void FloatMainRegion_Click(object? sender, RoutedEventArgs e)
-        {
-            if (_placementService is null)
-                return;
-
-            try
-            {
-                await _placementService.FloatAsync("MainRegion", options: new FloatingWindowOptions
-                {
-                    Title = "AsyncNavigation floating MainRegion",
-                    Width = 900,
-                    Height = 600
-                });
-            }
-            catch (Exception ex) when (ex is InvalidOperationException or NotSupportedException)
-            {
-                Debug.WriteLine($"Cannot float MainRegion: {ex.Message}");
-            }
+            // MainView carries the whole app UI (including the "float MainRegion" demo), shared
+            // as-is with the single-view (browser/mobile) lifetime in App.axaml.cs, so desktop
+            // and single-view platforms show exactly the same floating samples.
+            Content = new MainView(placementService);
         }
     }
 }

From e4d571adb237c5a6ede7eec33c4b9fb92c317469 Mon Sep 17 00:00:00 2001
From: Easley <nevermore.wd@me.com>
Date: Tue, 29 Sep 2026 18:51:48 +0200
Subject: [PATCH 14/14] ci: run the Avalonia headless E2E tests on Windows,
 macOS and Linux

AsyncNavigation.E2E.Tests (Avalonia.Headless.XUnit) already exercises
floating/docking/visual-state behavior but was never wired into CI - only
tests/AsyncNavigation.Tests ran, and the sample jobs just build, never
test. Add a test-e2e job mirroring the existing test job's 3-OS matrix.

Retarget the test project from net10.0-windows to net10.0: nothing in it
uses a Windows-only API, and Avalonia.Headless is cross-platform by
design, so the Windows-only TFM was an unnecessary constraint blocking
Linux/macOS runs. Verified locally (Windows) in both Debug and Release.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .github/workflows/ci.yml                      | 42 +++++++++++++++++++
 .../AsyncNavigation.E2E.Tests.csproj          |  2 +-
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 289248b..3857009 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -69,6 +69,48 @@ jobs:
           path: ./test-results/results.trx
           if-no-files-found: warn
 
+  test-e2e:
+    name: E2E (Avalonia headless) / ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: ${{ env.DOTNET_VERSION }}
+
+      - name: Cache NuGet packages
+        uses: actions/cache@v4
+        with:
+          path: ~/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.props') }}
+          restore-keys: ${{ runner.os }}-nuget-
+
+      - name: Restore
+        run: dotnet restore tests/AsyncNavigation.E2E.Tests
+
+      - name: Test
+        run: >
+          dotnet test tests/AsyncNavigation.E2E.Tests
+          --configuration Release
+          --no-restore
+          --logger "console;verbosity=normal"
+          --logger "trx;LogFileName=results.trx"
+          --results-directory ./test-results
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()              # upload even when tests fail so we can inspect
+        with:
+          name: e2e-test-results-${{ matrix.os }}
+          path: ./test-results/results.trx
+          if-no-files-found: warn
+
   build-libs:
     name: Build Libraries
     runs-on: ubuntu-latest
diff --git a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
index 91d2dbe..def97ef 100644
--- a/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
+++ b/tests/AsyncNavigation.E2E.Tests/AsyncNavigation.E2E.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net10.0-windows</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <OutputType>Exe</OutputType>